RAPPORT DE TP CHIFFREMENT ET

DECHIFFREMENT AES ET

November 2023

Nom & Prénoms Matricule

ATCHIENGNAG NGUEYEP ULRICH JOEL 000000
MEMEZAGUE NGUEMO FABIOLA 20V2210
POKOSSI Loı̈c 00000
SOUME ISSA 000000
Coordinateur : Dr EBELE

1
Contents
1 CONTEXTE ET TECHNIQUE 5
1.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2 Technique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2 MODE OPERATOIRE 6
2.1 (Electronic Codebook ECB) . . . . . . . . . . . . . . . . . . . . . 6
2.1.1 Probleme . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2 Cipher Block Chaining (CBC) . . . . . . . . . . . . . . . . . . . . 6

3 Data Encryption standard (DES) 6

3.1 Historique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.2 L’algorithme du DES . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.2.1 Permutation initiale . . . . . . . . . . . . . . . . . . . . . 8
3.2.2 Scindement en blocs de 32 bits . . . . . . . . . . . . . . . 8
3.3 Rondes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.4 Fonction d’expansion . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.5 Fonction de substitution . . . . . . . . . . . . . . . . . . . . . . . 11
3.6 Permutation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.6.1 Itération . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.6.2 Permutation initiale inverse . . . . . . . . . . . . . . . . . 12
3.7 Génération des clés . . . . . . . . . . . . . . . . . . . . . . . . . . 12

4 Advanced Encryption standard (AES) 14

4.1 Principe de l’algorithme . . . . . . . . . . . . . . . . . . . . . . . 14
4.1.1 Paramètres d’entrée/sortie AES . . . . . . . . . . . . . . . 15
4.1.2 Hexadécimal et binaire . . . . . . . . . . . . . . . . . . . . 16
4.2 Principe de ByteSub . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.2.1 ByteSub : fonction non linéaire . . . . . . . . . . . . . . . 18
4.2.2 Inversibilité de f () : . . . . . . . . . . . . . . . . . . . . . 19
4.2.3 Inversibilité de l’inverse . . . . . . . . . . . . . . . . . . . 21
4.3 Principe de ShiftRow . . . . . . . . . . . . . . . . . . . . . . . . 21
4.4 Réversibilité de ShiftRow : . . . . . . . . . . . . . . . . . . . . . . 23
4.5 Principe de MixColumn : . . . . . . . . . . . . . . . . . . . . . . 23
4.5.1 Explication de la fonction . . . . . . . . . . . . . . . . . . 24
4.6 Principe de AddKey . . . . . . . . . . . . . . . . . . . . . . . . . 25
4.6.1 Détail de l’algorithme . . . . . . . . . . . . . . . . . . . . 25
4.6.2 Réversibilité de AddKey . . . . . . . . . . . . . . . . . . 26
4.7 RoundKey . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
4.7.1 Principe de ”Key Schedule” . . . . . . . . . . . . . . . . 26
4.8 Algorithme de Key Schedule . . . . . . . . . . . . . . . . . . . . . 26
4.8.1 Réversibilité . . . . . . . . . . . . . . . . . . . . . . . . . . 29

2
5 Application 29
5.1 Choix du Langage Python . . . . . . . . . . . . . . . . . . . . . . 29
5.2 Conception Orientée Objet (POO) . . . . . . . . . . . . . . . . . 29
5.3 Architecture MVC . . . . . . . . . . . . . . . . . . . . . . . . . . 30
5.4 Documentation et Distribution . . . . . . . . . . . . . . . . . . . 30
5.5 Fonctionnement de l’Application . . . . . . . . . . . . . . . . . . 30
5.6 Interface Principale de l’Application . . . . . . . . . . . . . . . . 30
5.6.1 File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
5.6.2 AES (Advanced Encryption Standard) . . . . . . . . . . . 30
5.6.3 DES (Data Encryption Standard) . . . . . . . . . . . . . 31
5.6.4 Help . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
5.7 Exemple d’utilisation . . . . . . . . . . . . . . . . . . . . . . . . . 31

6 Limites de Notre Système 36

6.1 Développement en Cours . . . . . . . . . . . . . . . . . . . . . . . 36
6.2 Taille de Clé de Chiffrement en AES . . . . . . . . . . . . . . . . 36
6.3 Gestion de la Communication Interne . . . . . . . . . . . . . . . 40
6.4 Documentation en Cours d’Élaboration . . . . . . . . . . . . . . 40

7 Perspectives Futures 40

3
Introduction
La cryptographie c’est l’art d’écrire de manière cacher. Sécuriser une commu-
nications revients à assurer la confidentialité, l’authentification, l’intégrité, la
disponibilité et la responsabilité.

4
 Figure 1: situation du contexte

1 CONTEXTE ET TECHNIQUE
1.1 Contexte
On a un individu Alice(A) qui veut envoyer un message à un autre individu
Bob(B) en passant par un canal ou un attaquant Eve (Ev) ne doit pas voir le
message originel. Ce message M (message en clair ou plain Text). A veux donc
une fonction, un algorithme qu’on appellera E qui prend donc le message M et
le transforme en un autre message C : E(M) = C. de tel manière que C est
incompréhensible et seul B pourra retrouver M à partir de C (message chiffré
ou Cipher Text). Cette fonction E est une fonction de chiffrement (Encryptions)
ainsi, Eve voire le message mais ne peu pas lire le contenue, puis Bob voire le
message et utilise une autre fonction D : fonction de déchiffrement (Descryption)
qui prends C et le transforme en M : D(C) = M

1.2 Technique
Il existe plusieurs techniques pour construire ces deux fonctions (chiffrement
et déchiffrement) telles que le chiffrement de César, de Vigenère, Vernam, le
chiffrement par bloc, par flux et bien d’autres. Dans le cadre de ce rapport,
nous allons nous intéresser ici à la technique de chiffrement par bloc (Block
Ciphers) qui consiste à découper un message M en morceaux de taille constante
qu’on appelle des blocs, puis à utiliser la clé pour chiffrer chacun de ces blocs
et les recombiner. Il existe actuellement deux méthodes principales de Block
Ciphers :
• DES
• AES

5
2 MODE OPERATOIRE
Que ce soit la méthode DES ou AES, le mode d’opération de l’un et l’autre
peut s’appliquer au même processus de fonctionnement. Ainsi, nous distinguons
plusieurs modes parmi lesquels on peut citer :

• ECB (Electronic Codebook)

• CBC (Cipher Block Chaining)

2.1 (Electronic Codebook ECB)

Notre message M est découpé en 3 blocks : m1, m2, m3 C’est construit avec 3
blocs C1, C2etC3

2.1.1 Probleme
Le chiffrement de chaque bloc de manière indépendante et de la même manière
produits les mêmes blocs chiffrés. Donc avec suffisamment de block, un at-
taquant peu faire une analyse sur les blocs et essayer de deviner le bloc en
claire.

2.2 Cipher Block Chaining (CBC)

Notre message M est découpé en 3 blocs : m1, m2, m3
C est construite avec les 3 blocs c1, c2, c3 comme le premier bloc na pas de
blocs précèdent, on utilise un bloc généré automatiquement qu’on appelle le
vecteur d’initialisation (IV)

3 Data Encryption standard (DES)

3.1 Historique
Le 15 mai 1973, le NBS (National Bureau of Standards, actuellement appelé
NIST - National Institute of Standards and Technology) a émis un appel dans
le Federal Register (équivalent aux Etats-Unis du Journal Officiel en France)
en vue de la conception d’un algorithme de chiffrement répondant à plusieurs
critères essentiels :

6
 Figure 2: Illustration

1. Posséder un niveau élevé de sécurité tout en utilisant une clé de petite

taille pour le chiffrement et le déchiffrement.
2. Être compréhensible.
3. Ne pas dépendre de la confidentialité de l’algorithme.
4. Être adaptable et économique.

5. Être efficace et exportable.

Fin 1974, IBM a présenté ”Lucifer”, qui a été modifié le 23 novembre 1976
pour devenir le DES (Data Encryption Standard) grâce à la collaboration de la
NSA (National Security Agency). Le DES a été officiellement approuvé en 1978
par le NBS et standardisé par l’ANSI (American National Standard Institute)
sous le nom de ANSI X3.92, plus connu sous le nom de DEA (Data Encryption
Algorithm).
Le DES fonctionne comme un système de chiffrement symétrique par blocs
de 64 bits, avec 8 bits (un octet) dédiés à un test de parité pour vérifier l’intégrité
de la clé. Chaque bit de parité (1 sur 8 bits) teste un octet de la clé pour la
parité impaire, assurant ainsi un nombre impair de ’1’ dans chaque octet. La
clé est effectivement constituée de 56 bits, le reste étant utilisé pour la parité.
L’algorithme implique des combinaisons, des substitutions, et des permuta-
tions entre le texte à chiffrer et la clé, permettant des opérations bidirectionnelles
pour le chiffrement et le déchiffrement. Cette combinaison de substitutions et
de permutations est appelée ”code produit”.
La clé, formée de 16 blocs de 4 bits notés k1 à k16, est codée sur 64 bits,
bien que seuls 56 bits soient effectivement utilisés pour le chiffrement, offrant
ainsi 256 clés différentes (soit 7.2 × 1016 ).

7
 Les grandes étapes de l’algorithme DES comprennent le fractionnement du
texte en blocs de 64 bits, la permutation initiale des blocs, le découpage des blocs
en deux parties (gauche et droite), des rondes de permutations et substitutions
répétées 16 fois, et enfin, le recollement des parties gauche et droite, suivi de la
permutation initiale inverse.

3.2 L’algorithme du DES

Les grandes lignes de l’algorithme sont les suivantes :
Fractionnement du texte en blocs de 64 bits (8 octets) ; Permutation initiale
des blocs ; Découpage des blocs en deux parties: gauche et droite, nommées G et
D ; Etapes de permutation et de substitution répétées 16 fois (appelées rondes)
; Recollement des parties gauche et droite puis permutation initiale inverse.

Fractionnement du texte
3.2.1 Permutation initiale
Dans un premier temps, chaque bit d’un bloc est soumis à la permutation ini-
tiale, pouvant être représentée par la matrice de permutation initiale (notée PI)
suivante
Cette matrice de permutation indique, en parcourant la matrice de gauche
à droite puis de haut en bas, que le 58ème bit du bloc de texte de 64 bits se
retrouve en première position, le 50ème en seconde position et ainsi de suite.

3.2.2 Scindement en blocs de 32 bits

Une fois la permutation initiale réalisée, le bloc de 64 bits est scindé en deux
blocs de 32 bits, notés respectivement G et D (pour gauche et droite, la notation
anglo-saxonne étant L et R pour Left and Right). On note G0 et D0 l’état initial
de ces deux blocs :
Il est intéressant de remarquer que G0 contient tous les bits possédant une
position paire dans le message initial, tandis que D0 contient les bits de position
impaire.

3.3 Rondes
Les blocs Gn et Dn sont soumis à un ensemble de transformation itératives
appelées rondes, explicitées dans ce schéma, et dont les détails sont donnés plus
bas :

3.4 Fonction d’expansion

Les 32 bits du bloc D0 sont étendus à 48 bits grâce à une table (matrice) appelé
table d’expansion (notée E), dans laquelle les 48 bits sont mélangés et 16 d’entre
eux sont dupliqués :

8
9
10
 Ainsi, le dernier bit de D0 (c’est-à-dire le 7ème bit du bloc d’origine) devient
le premier, le premier devient le second, ... De plus, les bits 1,4,5,8,9,12,13,16,17,20,21,24,25,28
et 29 de D0 (respectivement 57, 33, 25, l, 59, 35, 27, 3, 6l, 37, 29, 5, 63, 39, 31
et 7 du bloc d’origine) sont dupliqués et disséminés dans la matrice.
OU exclusif avec la clé La matrice résultante de 48 bits est appelée D’0
ou bien E[D0]. L’algorithme DES procède ensuite à un OU exclusif entre la
première clé K1 et E[D0]. Le résultat de ce OU exclusif est une matrice de 48
bits que nous appelerons D0 par commodité (il ne s’agit pas du D0 de départ!).

3.5 Fonction de substitution

D0 est ensuite scindé en 8 blocs de 6 bits, noté D0i. Chacun de ces blocs
passe par des fonctions de sélection (appelées parfois boı̂tes de substitution ou
fonctions de compression), notées généralement Si. Les premiers et derniers
bits de chaque D0i détermine (en binaire) la ligne de la fonction de sélection,
les autres bits (respectivement 2, 3, 4 et 5) déterminent la colonne. La sélection
de la ligne se faisant sur deux bits, il y a 4 possibilités (0,1,2,3). La sélection
de la colonne se faisant sur 4 bits, il y a 16 possibilités (0 à 15). Grâce à cette
information, la fonction de sélection ”sélectionne” une valeur codée sur 4 bits.
Voici la première fonction de substitution, représentée par une matrice de 4
par 16 :
Soit D01 égal à 101110. Les premiers et derniers bits donnent 10, c’est-à-dire
2 en binaire. Les bits 2,3,4 et 5 donnent 0111, soit 7 en binaire. Le résultat de
la fonction de sélection est donc la valeur situé à la ligne n°2, dans la colonne
n°7. Il s’agit de la valeur 11, soit en binaire 111.
Chacun des 8 blocs de 6 bits est passé dans la fonction de sélection corre-
spondante, ce qui donne en sortie 8 valeurs de 4 bits chacune. Voici les autres
fonctions de sélection :
Chaque bloc de 6 bits est ainsi substitué en un bloc de 4 bits. Ces bits sont
regroupés pour former un bloc de 32 bits.

3.6 Permutation
Le bloc de 32 bits obtenu est enfin soumis à une permutation P dont voici la
table :
Exclusif L’ensemble de ces résultats en sortie de P est soumis à un OU
Exclusif avec le G0 de départ (comme indiqué sur le premier schéma) pour
donner D1, tandis que le D0 initial donne G1.

3.6.1 Itération
L’ensemble des étapes précédentes (rondes) est réitéré 16 fois.

11
3.6.2 Permutation initiale inverse
A la fin des itérations, les deux blocs G16 et D16 sont ”recollés, puis soumis à
la permutation initiale inverse : Le résultat en sortie est un texte codé de 64
bits !

3.7 Génération des clés

Etant donné que l’algorithme du DES présenté ci-dessus est public, toute la
sécurité repose sur la complexité des clés de chiffrement.
L’algorithme ci-dessous montre comment obtenir à partir d’une clé de 64
bits (composé de 64 caractères alphanumériques quelconques) 8 clés diversifiées
de 48 bits chacune servant dans l’algorithme du DES :
Dans un premier temps les bits de parité de la clé sont éliminés afin d’obtenir
une clé d’une longueur utile de 56 bits.
La première étape consiste en une permutation notée CP-1 dont la matrice
est présentée ci-dessous :
Cette matrice peut en fait s’écrire sous la forme de deux matrice Gi et Di
(pour gauche et droite) composées chacune de 28 bits :
On note G0 et D0 le résultat de cette première permutation.

12
13
 Ces deux blocs subissent ensuite une rotation à gauche, de telles façons que
les bits en seconde position prennent la première position, ceux en troisième
position la seconde, ... Les bits en première position passent en dernière position.
Les 2 blocs de 28 bits sont ensuite regroupés en un bloc de 56 bits. Celui-ci
passe par une permutation, notée CP-2, fournissant en sortie un bloc de 48 bits,
représentant la clé Ki.
Des itérations de l’algorithme permettent de donner les 16 clés K1 à K16
utilisées dans l’algortihme du DES.

4 Advanced Encryption standard (AES)

L’Advanced Encryptions Standard (AES) est le chiffrement symétrique le plus
largement utilisé. C’est un algorithme de chiffrement symétrique. La même
clé est utilisée pour chiffrer et déchiffrer un texte. Il repose entièrement sur
des notions mathématiques liées aux ensembles (les corps notamment) et a
l’arithmétique modulaire. Ici nous allons expliciter le déroulement global de
l’algorithme, ainsi que les bases mathématiques nécessaires.
L’AES travaille avec des blocs de données de taille fixe. Chaque bloc est un
tableau de 4*4 octets. Chacune de ses cellules (d’un octet) est appelé un mot.
L’AES travaille donc avec des blocs de 128 bits. Pour coder de plus gros
volumes de données, un découpage préalable de la donnée en bloc est réalisé,
avant que chaque bloc soit encodé séparément. Avec AES, nous avons des blocs
de 16 octets (128 bits) et des tailles de clé de 16, 24, 32 octets.

4.1 Principe de l’algorithme

L’AES chiffre un bloc d’entrée en un bloc de sortie. Le bloc de donnée se
présente sous la forme suivante :
A1 A2 A3 A4
A5 A6 A7 A8
A9 A10 A11 A12
A13 A14 A15 A16
Chacun des éléments du bloc A est un octet, et il y en a 16 pour un bloc,
soit 128 bits au total.

14
 Figure 3: Schéma général de l’AES

L’input (données entrées dans l’algorithme) est ce que l’on appelle le Plain
Text, le texte non chiffré. L’output (données en sortie de l’algorithme) est ce
que l’on appelle le Cypher Text, le texte chiffré.
Pour chiffrer, il applique sur le Plain Text 4 fonctions distinctes dans un ordre
précis et de façon répétitive, chacunes étant réversibles. La clé de chiffrement
est utilisée pour chiffrer mais aussi pour déterminer le nombre de répétition.
Les clés peuvent faire 128, 192 ou 256 bits, correspondant respectivement à 10,
12 et 14 répétitions. Avant chaque répétition, on créera ce que l’on appelle la
RoundKey, qui est une clé dérivée de la clé initiale.
Le schéma général de l’AES est le suivant :
Chaque fonction sera explicitée dans sa section propre.

4.1.1 Paramètres d’entrée/sortie AES

Nous passons par un certain nombre de processus et où nous opérons sur 16
octets en entrée et en sortie. Chaque bloc, appelé état, est exploité comme une
matrice 4x4, telle que :
01 02 03 04
05 06 06 07
08 09 0A 0B
0C 0D 0E 0F
Pour différentes tailles de clés, on passe par un certain nombre de tours (N)
:
1. Clé 128 bits (16 octets) → N=10 tours
2. Clé 192 bits (24 octets) → N=12 tours
3. Clé 256 bits (32 octets) → N=14 tours

Et le tour final consiste en :

1. Remplaçons les octets.

15
 2. Décalons la ligne.
3. Ajoutons une clé d’arrondi.

4.1.2 Hexadécimal et binaire

Nous savons que les octets dans le bloc de donnée sont représentés en hexadécimal.
Cela ne correspond PAS à l’ensemble des entiers ! Il serait faux de convertir
en base 10. Un élément du bloc de donnée (octet) peut être converti en un
polynôme appartenant à GF(28 ). Le passage à l’héxadécimal permet unique-
ment de contracter l’écriture (passer de 8 à 2 caractères). L’héxadécimal est
une écriture en base 16, ainsi l’élément le plus à droite est multiplié par 160 .
Le second par 161 , ensuite par 162 et ainsi de suite. Pour passer du binaire
à l’héxadécimal : On sépare l’octet entre ses 4 bits de poids faible (4 plus à
droite) et ses 4 bits de poids forts (4 plus à gauche). On somme ensuite, comme
s’il s’agissait de deux chiffres représentés en binaire. Tout peut se faire selon le
schéma suivant :
4 bits de poids faible 4 bits de poids forts
z}|{ z}|{
h7 h6 h5 h4 h1 h3 h2 h1 h0 h2
Avec :

h1 = b7 · 23 + b6 · 22 + b5 · 21 + b4 · 20

h2 = b3 · 23 + b2 · 22 + b1 · 21 + b0 · 20

Par construction, un chiffre en héxadécimal peut prendre les valeurs suiv-

antes : {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F } avecA, B, ..., F correspondant à
10, 11, ..., 15.
ex :
Un élément du bloc de donnée contient ”10011011” (équivalent au polynôme
X 7 + X 4 + X 4 + X 1 + X 0 ). Pour simplifier l’écriture, on passe à l’héxadécimal
: ”10011011” est séparé en ”1001” et ”1011”. Grâce à la formule précédente,
on a :
h1 = 8 + 0 + 0 + 1 = 9
h2 = 8 + 0 + 2 + 1 = 11

Or en héxadécimal, 11 correspond à B. De plus, dans de nombreux langages

informatiques, on ajoute un préfixe (par exemple 0x en Javascript) pour le
différencier de la base 10. On a donc au final : 100110112 = 0x9B

4.2 Principe de ByteSub

ByteSub est une application avec les propriétés suivantes :

16
 Figure 4: Tableau multiplication

• Bijective : ∀y ∈ F, ∃!x ∈ E; f (x) = y

• Non linéaire : ByteSub(E(A)) + ByteSub(E(B)) ̸= ByteSub(E(A + B))
Dans notre cas, les ensembles E et F sont les mêmes. Il s’agit de GF (28 ).
La bijectivité permet de s’assurer que lors du chiffrement tous les éléments aient
une image différente. Ainsi, lors du déchiffrement, il n’y aura pas d’incohérence,
une fonction bijective étant inversible, tel que son inverse est aussi une fonction
bijective.
∀x ∈ E, ∃!y ∈ F ; f −1 (y) = x
La non linéarité permet de se protéger de certaines attaques.
Le but de ByteSub est d’effectuer une substitution octet (byte) par octet.
Cela s’effectue en deux étapes distinctes. Dans cette partie, on va reprendre
A = 100110112 = 0x9B, dans le but de créer un exemple. ByteSub : passage à
l’inverse Tout d’abord, on remplace la valeur A = (a7 a6 a5 a4 a3 a2 a1 a0 ) (un mot
du bloc de donnée) par son inverse dans GF (28 ). Étant donné que nous sommes
dans un corps, il faut préciser quelle opération nous utilisons. Dans ce cas, il
s’agit de l’inverse dans le groupe multiplicatif, d’élément neutre 0x01. Dans
ce groupe, 0x00 n’ayant pas d’inverse, il est son propre inverse par convention.
Cela peut se faire via une table :
(Pour passer du binaire à l’héxadécimal, voir l’onglet sur l’algorithme AES).
Celle-ci peut directement être codée ”en dur” dans un programme, elle ne varie
jamais. On a donc : A = (a7 a6 a5 a4 a3 a2 a1 a0 ) B ′ = (b′7 b′6 b′5 b′4 b′3 b′2 b′1 b′0 ) = A−1
Exemple : Si l’on reprend l’inverse de A, on a donc : A−1 = B ′ = 100010002 =
0x88

17
4.2.1 ByteSub : fonction non linéaire
Dans cette seconde étape, on modifie la valeur en la multipliant par un vecteur
puis en ajoutant un terme constant, le tout modulo 2. Le fait que cette fonction
soit bijective permettra plus tard le déchiffrement de cette étape.
Ainsi : Soit B = f (B ′ ), avec la fonction f () correspondant à :

b0 10001111 b′0 1
b1 11000111 b′1 1
b2 11100011 b′2 0
b3 = 11110001 ·b′3 +02
b4 11111000 b′4 0
b5 01111100 b′5 1
b6 00111110 b′6 1
b7 00011111 b′7 0

Exemple :
On reprend B ′ = 100010002 = 0x88. Après calcul, on trouve f (B ′ ) = B =
000101002 = 0x14. ByteSub : simplification Il est possible de simplifier cette
étape. En effet, cette transformation f () est une bijection. Chaque élément de
GF (28 ) possède une image unique et un antécédent unique. De plus, l’inverse
d’un élément est unique.
En effet, soit a, b, c, e ∈ GF (28 ) avec b et c inverses de a et élément neutre. Alors
a · b = a · c = e. Donc (a · b) · b = (b · a) · c car · est associative. Donc e · b = e · c
car b est inverse de a. Donc b = c car e est neutre. L’inverse est donc unique
pour chaque élément, pour l’opération ·.
Chaque élément de GF (28 ) a donc un inverse unique et une image unique par
f (). L’ensemble GF est fini, il est donc possible de calculer ByteSub pour
chacun de ses éléments.
Cela donne la table suivante (ici en notation hexadécimale) :

18
 A f (A) = B A f (A) = B A f (A) = B A f (A) = B
00 63 10 42 20 51 30 90
01 7C 11 67 21 FB 31 46
02 77 12 23 22 16 32 BF
03 7B 13 FC 23 AC 33 37
04 F2 14 D7 24 CF 34 87
05 6B 15 45 25 62 35 8D
06 6F 16 A4 26 97 36 D3
07 C5 17 E0 27 F0 37 27
08 30 18 E4 28 86 38 89
09 01 19 5D 29 A1 39 62
0A 67 1A 35 2A 6D 3A B7
0B 2B 1B 8E 2B 2D 3B 0C
0C FE 1C 1F 2C 71 3C 99
0D D7 1D 18 2D 96 3D 59
0E AB 1E 5A 2E 9A 3E 1A
0F 76 1F 7E 2F B1 3F 65

Avec la fonction f () correspondant à :

b0 10001111
b1 11000111
b2 11100011
b3 11110001 ⊕ b′3
b4 11111000
b5 01111100
b6 00111110
b7 00011111

Maintenant, il est possible d’appliquer cette table à chaque élément de GF (28 )

pour obtenir le résultat de ByteSub.
On peut voir qu’il n’y a aucune symétrie ou de point spécifique.
Exemple : SI l’on reprend A = 100110112 = 0x9B. On peut directement
faire la correspondance (inverse et passage par f ()). Cela donne bien B =
000101002 = 0x14.

4.2.2 Inversibilité de f () :
ByteSub étant bijective, il est possible de construire sa fonction inverse. Pour
la fonction f (), elle représente un système de 8 inconnues à 8 équations, il est
donc possible de le résoudre. Cela permet d’obtenir la fonction suivante :

b′0 : 01010010b0 : 0b′1 : 00101001b1 : 0b′2 : 10010100b2 : 0b′3 ≡ 01001010·b3 +02b′4 : 00100101b4 : 0b′5 : 10010010b5 :

Cela complète l’explication sur l’inversibilité de la fonction f () dans ByteSub.

19
Figure 5: f()

20
 Figure 6: Tableau Multiplicatif Inverse

4.2.3 Inversibilité de l’inverse

De plus, comme on peut le voir dans la table des inverses, si a inverse de b alors
b inverse de a. On peut donc réutiliser cette table:

Ainsi, il est possible de remonter ByteSub. Tout d’abord en trouvant la fonc-

tion inverse f −1 (). Ensuite, de reprendre l’inverse du résultat, pour retomber
sur l’élement initial.
Simplification du déchiffrement de ByteSub
De même que pour ByteSub, il est possible de précalculer le résultat pour chaque
élément :

Si vous voulez, vous pouvez vérifier :

1. qu’aucun élément n’est sa propre image
2. qu’aucun élément n’est symétrique
3. que la fonction est bien bijective

4.3 Principe de ShiftRow

ShiftRow fait partie, avec MixColumn, de la couche de diffusion. Le but est
d’introduire de la confusion dans les données en modifiant l’ordre des bits. Pour
cela, un simple décalage (Shift) est effectué sur chaque ligne (Row) du bloc
de données. On utilisera par la suite la matrice A pour représenter le bloc de
données initial, où l’intérêt est porté sur les indices des éléments :

A1 A2 A3 A4
A5 A6 A7 A8
A=
A9 A10 A11 A12
A13 A14 A15 A16

La modification opérée par ShiftRow est très simple à comprendre et à mettre

en œuvre. Elle effectue un décalage ligne par ligne. La première ligne est
décalée de 0, la deuxième de 1, et ainsi de suite. On peut le faire dans un
programme informatique de plusieurs façons. Si chaque élément, de gauche à

21
22
droite et de haut en bas, est noté de 1 à 16, alors on peut utiliser un tableau de
correspondance :

1 2 3 4 6 7 8 5 11 12 9 10 16 13 14 15
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

Cela permet facilement de donner les nouvelles coordonnées de chaque élément.

Dans la partie ”Application” de ce site, ce tableau assure la correspondance
avant et après l’opération.

Exemple :

A1 A2 A3 A4 A1 A2 A3 A4
A5 A6 A7 A8 A6 A7 A8 A5
A9 A10 A11 A12 A11 A12 A10 A16
A13 A14 A15 A16 A16 A13 A14 A15

4.4 Réversibilité de ShiftRow :

On peut voir rapidement qu’il est facile d’inverser ShiftRow. Le tableau utilisé
précédemment peut être utilisé dans les deux sens.

A1 A2 A3 A4 A1 A2 A3 A4
A6 A7 A8 A5 A5 A6 A7 A8
A11 A12 A10 A16 A9 A10 A11 A12
A16 A13 A14 A15 A13 A14 A15 A16

4.5 Principe de MixColumn :

MixColumn fait partie (avec ShiftRow) de l’étape de diffusion. Son but est de
faire intervenir de multiples bits dans le codage d’un seul, ce qui permet de
lier rapidement tous les éléments d’un bloc entre eux via des transformations
matricielles. Le déchiffrement devient plus complexe sans connaı̂tre la clé. On
utilisera la matrice A pour représenter le bloc de données initial et la matrice
B pour représenter le bloc de données après modification par MixColumn :

A1 A2 A3 A4
A5 A6 A7 A8
A=
A9 A10 A11 A12
A13 A14 A15 A16

C1 C2 C3 C4
C5 C6 C7 C8
C=
C9 C10 C11 C12
C13 C14 C15 C16

23
4.5.1 Explication de la fonction
La fonction MixColumn est une opération d’algèbre linéaire. Elle suit l’égalité
suivante :

C i = S × Ai

Où i est l’indice de colonne pour les matrices A et C, et S est une matrice à
coefficients fixes spécifique à MixColumn. Les coefficients de S sont des éléments
de GF(28 )etsontreprésentésenhexadécimal :

Ci = 0x02 · Ai + 0x03 · Ai+4 + 0x01 · Ai+8 + 0x01 · Ai+12

Sous forme d’octets, on a : 0x01 = 000000012 , 0x02 = 000000102 , 0x03 =

000000112 .
La multiplication par 0x01 ne change rien, car il s’agit de l’élément neutre de
la multiplication. La multiplication par 0x02 équivaut à décaler tous les digits de
l’octet d’un cran vers la gauche (ce qui équivaut à multiplier le polynôme corre-
spondant par 21 ).Danscertainscas, celapeutdépasserGF (28 )etilf autréduireparlepolynômecaractéristiquedel′
En reprenant l’expression initiale de MixColumn, on peut voir qu’il s’agit
d’un système à 4 inconnues et 4 équations. Dans le cas du chiffrement, les
inconnues sont C1, C2, C3 et C4. Dans le cas du déchiffrement, il s’agit de
A1, A2, A3 et A4. Inverser MixColumn revient à résoudre ce système. Les
coefficients de la transformation étant fixes, on peut simplement implémenter le
même calcul en utilisant une matrice résultant de la résolution du système. On
obtient ainsi :

Ai = S ′ × Ci

Avec S’ représentant la matrice suivante :

0x0E 0x0B 0x0D

0x09
0x09 0x0E 0x0B
0x0D
S′ =
0x0D 0x09 0x0E
0x0B
0x0B 0x0D 0x09
0x0E
Le déchiffrement de cette étape devient donc :

Ai = S ′ × Ci

Ai+4 = 0x09·Ci +0x0E·Ci+4 +0x0B·Ci+8 +0x0D·Ci+12 Ai+8 = 0x0D·Ci +0x09·Ci+4 +0x0E·Ci+8 +0x0B·Ci+12 A

Pour déchiffrer cette étape, il suffit de calculer :

24
 Ci = S ′ × Ai

avec la matrice S’ donnée précédemment :

0x0E 0x0B 0x0D

0x09
0x09 0x0E 0x0B
′ 0x0D
S =
0x0D 0x09 0x0E
0x0B
0x0B 0x0D 0x09
0x0E

Le déchiffrement de cette étape devient alors :

Ci = S ′ × Ai

Ci+4 = S ′ × Ai+4

Ci+8 = S ′ × Ai+8

Ci+12 = S ′ × Ai+12

Cela permet de retrouver les valeurs originales d’A1, A2, A3 et A4 à partir

de C1, C2, C3 et C4.
Note : Les matrices S et S’ utilisées dans MixColumn et son inverse sont
spécifiques à l’algorithme AES et dérivent directement de la théorie mathématique
sous-jacente à l’algorithme.

4.6 Principe de AddKey

Le but de AddKey est de sommer le bloc de données courant avec la clé
courante, qui est dérivée de la clé initiale via l’opération RoundKey (ou routine
d’expansion). Cette fonction est la seule qui chiffre réellement les données et
nécessite la clé pour être réalisée et déchiffrée. AddKey dépend totalement de
la clé, en plus de la routine d’expansion.

4.6.1 Détail de l’algorithme

AddKey prend les 128 bits de la clé après son expansion et les somme directe-
ment avec le bloc de données via une opération XOR bit à bit. Par exemple,
pour 8 bits (un mot du bloc de données) : RoundKey = 11101100 et Mot =
10011011 La somme bit à bit (modulo 2, car les éléments sont issus de GF(2))
donne : 11101100 + 10011011 = 01110111

25
4.6.2 Réversibilité de AddKey
Étant donné que l’AES est un algorithme symétrique, la même clé peut être
utilisée pour le chiffrement et le déchiffrement.
Dans le cas de AddKey, cela est simple à démontrer : Lors du déchiffrement,
le processus est inversé et toutes les modifications sont supprimées les unes
après les autres. Avec l’ordre fixe, il est possible de savoir quelle RoundKey a
été utilisée pour chaque itération en les créant toutes puis en remontant de la
dernière à la première.
L’opération XOR utilisée lors du chiffrement nécessitera un XOR avec la
même clé lors du déchiffrement. Ainsi, la clé ajoutée sera compensée par elle-
même : 11101100 + 10011011 + 11101100 = 10011011
Cela est possible car l’opération XOR est associative : Avec Ki étant la
RoundKey courante, Mi le mot courant et Ci le résultat de l’opération XOR tel
que Ci = Mi +Ki Alors Ci +Ki = (Mi +Ki )+Ki AlorsCi +Ki = Mi +(Ki +Ki )
par associativité Ainsi Ci + Ki = Mi
La clé courante Ki se compense donc elle-même. L’opération XOR donnant
0x00, qui correspond à l’élément neutre de l’opération + dans GF (28 ).

4.7 RoundKey
4.7.1 Principe de ”Key Schedule”
Les clés de l’AES sont de 128, 192 ou 256 bits, correspondant à un certain nom-
bre de répétitions du chiffrement. Pour éviter certaines attaques issues de la
cryptanalyse, ces clés sont étendues, c’est-à-dire que d’autres clés sont créées
à partir de la clé initiale. Ainsi, le ”Key schedule” permet de générer une clé
différente à chaque tour de chiffrement, chaque sous-clé faisant 128 bits. On peut
donc se demander pourquoi utiliser des clés de tailles différentes et pourquoi ne
pas utiliser une clé de la taille du bloc de données multipliée par le nombre de
tours.
Les clés de 128 bits sont plus faibles que celles de 192, qui sont elles-mêmes plus
faibles que celles de 256 bits. Cela est dû au ”Key schedule”, qui permet de
contrer certaines attaques. De plus, utiliser une seule grande clé présenterait
des risques. D’abord, il y a le risque que les utilisateurs choisissent une clé facile
à retenir, donc plus facile à trouver. Ensuite, l’AES utilise en fait une seule
grande clé via le ”Key schedule”. Cela permet d’avoir une clé complexe lors du
chiffrement, mais suffisamment courte pour être retenue.

4.8 Algorithme de Key Schedule

Nous nous concentrerons ici sur le ”Key schedule” des clés de 128 bits. Il y
a une légère variation pour les clés de plus grande taille. Les clés de 128 bits
correspondent à 16 octets, qui sont ensuite regroupés par groupe de 4 octets.
Dans le cas d’une clé de 128 bits, il y a 10 répétitions de l’algorithme, donc
il faut générer 10 clés supplémentaires (une clé est utilisée avant le début des

26
répétitions). Le ”Key schedule” se répète à chaque nouvelle clé, et donc la ième
clé est calculée à partir de la clé i+1.
Le schéma se répète à chaque itération du ”Key schedule” (pour la répétition
suivante, W4 devient W0, et ainsi de suite). La somme est effectuée via une
opération XOR (bit à bit) sur les deux blocs de 128 bits (somme dans GF(2)).
La fonction g() est ici importante. Elle s’applique sur un bloc de 4 octets et se
divise en 3 étapes, où g1, g2, g3 représentent les 3 étapes de la fonction g() :
1. Un décalage de 3 (similaire à un ”ShiftColumn”) :
• g1(W 3) = g1(V12 V13 V14 V15 ) = V13 V14 V15 V12
2. Ensuite, chaque octet est transformé via la transformation ”SubByte” :
• g2(V13 V14 V15 V12 ) = s(V13 )s(V14 )s(V15 )s(V12 ) = V13
′ ′
V14 ′
V15 ′
V12
3. Le premier octet est sommé avec un coefficient (puissance de 2 dans
GF(28 )) qui dépend de l’indice j de la répétition :
′ ′ ′
g3(V13 V14 V15 V12′ )=V13
′ +R ′ ′ ′
j−1 ·V14 +V15 +V12

où R = 0 · X + 0 · X + 0 · X + 0 · X 4 + 0 · X 3 + 0 · X 2 +
7 6 5

1 · X 1 + 0 · X 0.
Comme nous sommes toujours dans GF(28 ), les puissances de ce polynôme
sont restreintes par le polynôme caractéristique de l’AES, P (voir section
Maths). Ainsi, on a :

• Indice de la répétition j = 1 ; R0 P = (00000001)2

• j = 2 ; R1 P = (00000010)2
• j = 3 ; R2 P = (00000100)2
• j = 4 ; R9 P = (00110110)2

Pour résumer, les 128 bits sont regroupés par groupe de 4 octets. Le premier
octet est sommé avec le troisième, modifié par g(). Tous les autres octets sont
ensuite sommés avec l’élément précédent et l’élément équivalent dans la clé
précédente. Cela donne le schéma suivant :
Clés de 192 bits le schéma pour la création des sous-clés de 192 bits est
presque similaire :
Il y a cependant un élément à prendre en compte, il y a besoin d’aller
jusqu’à W51. Or, ont créé à chaque fois 6 nouveaux éléments (W5→W11).
On arrive donc à W47, il ne faut donc que 4 éléments supplémentaires (W48→W51).
Pour la fonction g(), il s’agit toujours du dernier élément de la ligne précédente
(le 6ème parmis 6). (Il serait possible de créer encore 6 éléments, mais 2 ne
seraient jamais utilisés.) Clés de 256 bits le schéma pour la création des-clés de
256 bits est presque similaire :
De même que pour les clés de 192 bits, lors de la dernière itération il n’est
nécessaire de créer que 4 éléments (W56→W59). On peut voir un ajout ici,
il s’agit de la deuxième étape de la fonction g(), l’opération SubByte.

27
 Figure 7: Key Schedule

Figure 8: création des sous-clés de 192 bits

Figure 9: création des-clés de 256 bits

28
4.8.1 Réversibilité
L’AES étant symétrique, la même clé est utilisée pour le déchiffrement. Les
mêmes Round Key (clé par itération) sont donc utilisées. La différence va
résider dans la création des clés, en effet, il y a deux manières de faire :

• Toutes les créer avant le chiffrement, ce qui peut prendre du temps (selon
la taille de la clé)
• Les créer au fur et à mesure des itérations
Or, dans le cas du déchiffrement, on commence par utiliser la clé de la
dernière itération. En effet, on déchiffre dans l’ordre des couches, or la dernière
itération utilisant la dernière clé, on est obligé de créer toutes les clés avant de
pouvoir déchiffrer.

5 Application
Nous allons maintenant présenter notre Application de Cryptographie utilisant
les Algorithmes AES et DES.
Notre application de cryptographie repose sur les algorithmes avancés de
chiffrement AES (Advanced Encryption Standard) et DES (Data Encryption
Standard). Nous avons choisi d’implémenter ces algorithmes en utilisant le
langage de programmation Python en raison de sa nature de haut niveau, de
sa vaste communauté de développeurs, et de sa flexibilité pour la création de
bibliothèques personnalisées.

5.1 Choix du Langage Python

Langage de Haut Niveau : Python offre une syntaxe claire et concise, ce qui
facilite le développement et la maintenance du code.
Communauté Étendue : La communauté Python est riche en ressources, ce
qui a facilité notre apprentissage et résolution de problèmes grâce aux forums,
tutoriels, et bibliothèques existantes.
Distribution de Bibliothèques : Python permet de distribuer facilement des
bibliothèques personnalisées, ce qui simplifie l’intégration de notre solution dans
d’autres projets.
Interface Graphique avec PyQt5
Pour l’interface utilisateur, nous avons choisi PyQt5, une bibliothèque Python
pour la création d’interfaces graphiques. Ceci a permis de fournir une expérience
utilisateur conviviale et intuitive.

5.2 Conception Orientée Objet (POO)

Nous avons adopté une approche orientée objet (POO) pour la conception de
notre application. Le dossier ”bibliotheque” contient l’ensemble de nos fichiers
source UI, à l’exception du fichier ”main.pyw”, qui agit comme une classe

29
contrôleur permettant de gérer la vue sur nos objets. Cette structure suit le
modèle MVC (Modèle-Vue-Contrôleur).

5.3 Architecture MVC

L’architecture MVC facilite la séparation des préoccupations dans notre ap-
plication, rendant le code plus lisible, maintenable, et extensible. Le modèle
gère la logique métier, la vue gère l’interface utilisateur, et le contrôleur gère la
communication entre les deux.

5.4 Documentation et Distribution

Une documentation approfondie est en cours de rédaction pour expliquer en
détail le fonctionnement de notre système. La disponibilité de notre bibliothèque
via la commande pip install crypto_des_aes sera effective dans les deux à
trois prochaines semaines.

5.5 Fonctionnement de l’Application

Dans ce rapport, nous expliquerons brièvement le fonctionnement de notre
système, mettant en évidence les principaux aspects de l’implémentation des
algorithmes AES et DES.

5.6 Interface Principale de l’Application

Au lancement de notre application, les utilisateurs sont accueillis par une inter-
face conviviale proposant plusieurs options pour gérer leurs données et commu-
nications de manière sécurisée. Les options principales sont réparties en quatre
catégories : File, AES, DES, Help.

5.6.1 File
L’option ”File” offre une fonctionnalité permettant de chiffrer des données sous
forme de fichiers. Actuellement, notre application prend en charge le chiffrement
de fichiers au format texte (txt) et d’images (png, jpeg, gif). Nous travaillons
activement pour étendre cette prise en charge à d’autres formats tels que les
documents (docs), les archives (zip), les vidéos (mov, avi), les présentations
(ppt), et bien d’autres.

5.6.2 AES (Advanced Encryption Standard)

Le bouton ”AES” permet d’utiliser l’algorithme de chiffrement AES pour crypter
et décrypter des données. Cette fonctionnalité est conçue pour assurer la confi-
dentialité des communications en chiffrant le texte directement saisi au clavier.
Il s’agit d’une solution pratique pour sécuriser les échanges entre utilisateurs,
offrant une alternative simple au chiffrement de fichiers.

30
5.6.3 DES (Data Encryption Standard)
Similaire à l’option AES, le bouton ”DES” propose une fonctionnalité de chiffre-
ment et déchiffrement, cette fois en utilisant l’algorithme de chiffrement DES.
Cette option est également pensée pour sécuriser les communications en chiffrant
le texte saisi au clavier. Notre implémentation s’inspire de logiciels existants tels
que Veracrypt, GpgEx, EncryptOnClick, et d’autres solutions de chiffrement
couramment utilisées.

5.6.4 Help
Le bouton ”Help” fournit un accès facile à la documentation en ligne et hors
ligne. Les utilisateurs pourront y trouver des informations détaillées sur le
fonctionnement de l’application, des tutoriels d’utilisation, et des conseils de
sécurité. Cette ressource est essentielle pour guider les utilisateurs tout au long
de leur expérience avec l’application.
Nous allons maintenant passer à un exemple d’utilisation :

5.7 Exemple d’utilisation

A la sélection du fichier File, nous aurons une interface qui nous proposera un
choix de type de fichier à chiffrer (DES/AES).

31
 Puis sélectionnons maintenant l’option AES
Puis nous sélectionnons le fichier contenant notre clé de chiffrement

Après cette opération nous pouvons bien vérifier que c’est effectivement le bon
fichier que nous avons sélectionné
A cette étape, nous allons passer au choix de notre fichier contenant le texte
en claire que nous voulons chiffrer

Puis

On donne un nom au fichier qui de sortir

Une fois l’opération éffectuez on peu tout simplement voir le contenu de

notre fichier crypté (en cours : je suis en train de finis le code de cette partir )
Pour ce qui concerne le chiffrement de communication direct, nous allons
étudier le cas ici avec le chiffrement DES Commençons par cliquer sur le l’option
DES puis sur Encrypt
Puis entrons notre clé et notre texte à chiffrer

Notons que nous pouvons aussi générer des clés de chiffrement à partir du
buttons de clé suivante.

32
33
34
35
6 Limites de Notre Système
Les travaux présentés ici, réalisés sous la supervision du Dr. EBELE, expert en
sécurité informatique, dans le cadre du cours d’introduction à la cryptographie,
demeurent actuellement incomplets. Bien que notre application soit fonction-
nelle, des aspects importants nécessitent encore des développements futurs pour
la rendre plus robuste et complète.

6.1 Développement en Cours

Notre projet est en phase de développement continu, et de nouvelles fonction-
nalités sont en cours d’implémentation. Nous sommes engagés à améliorer notre
application en intégrant des fonctionnalités qui seront rencontrées dans différents
projets informatiques liés à la cryptographie. Ces développements visent à ren-
forcer la sécurité, la convivialité et l’efficacité globale de notre système.

6.2 Taille de Clé de Chiffrement en AES

Actuellement, notre application supporte une taille de clé de chiffrement prédéfinie
pour l’algorithme AES. Une limite que nous identifions est l’absence de prise en
charge de différentes tailles de clé de chiffrement. Dans le cadre de futures mises
à jour, nous prévoyons d’ajouter la prise en charge de différentes longueurs de
clés pour permettre une personnalisation accrue de la sécurité.

36
37
38
39
6.3 Gestion de la Communication Interne
Une autre limite actuelle réside dans la gestion de la communication entre les
différents objets de notre application. Nous sommes conscients que pour opti-
miser le fonctionnement de notre système, il est nécessaire d’améliorer la coordi-
nation et l’échange d’informations entre ces objets. Cela inclut une optimisation
des mécanismes de communication interne pour garantir une performance opti-
male et le design pattern.

6.4 Documentation en Cours d’Élaboration

Bien que nous travaillions sur une documentation approfondie, celle-ci n’est pas
encore complètement finalisée. Nous nous engageons à fournir une documenta-
tion exhaustive pour faciliter l’utilisation de notre application, notamment en
expliquant en détail les fonctionnalités, les bonnes pratiques de sécurité et les
éventuelles questions techniques.

7 Perspectives Futures
Nous restons déterminés à faire évoluer notre application, en tenant compte des
retours des utilisateurs, des avancées en cryptographie et des besoins croissants
en matière de sécurité. Notre objectif est d’offrir un outil de chiffrement complet,
fiable et adaptable, contribuant ainsi à la protection des données dans divers
contextes informatiques.

Conclusion
En conclusion, ce projet de développement d’une application de chiffrement
utilisant les algorithmes AES et DES a été une aventure enrichissante dans le
domaine de la cryptographie. Sous la direction de l’honorable Dr. EBELE, nous
avons pu explorer les concepts fondamentaux de la sécurité informatique et les
mettre en pratique.
L’utilisation du langage de programmation Python, associé à la bibliothèque
PyQt5 pour l’interface graphique, a permis la création d’une application con-
viviale, capable de chiffrer et de déchiffrer des données de manière sécurisée.
L’approche de développement orientée objet (POO) et l’architecture de modèle-
vue-contrôleur (MVC) ont contribué à la structure modulaire et à la mainten-
abilité du code.
Bien que notre application soit fonctionnelle, il reste des défis à relever et
des fonctionnalités à améliorer. La gestion de différentes tailles de clés pour
l’algorithme AES et l’optimisation de la communication entre les différents com-
posants sont des axes de développement futurs.
Dans le cadre de la sécurité informatique, la sensibilisation à l’importance de
protéger les données sensibles est cruciale. Notre application vise à fournir un

40
moyen accessible de renforcer la confidentialité des informations, en particulier
dans un monde numérique en constante évolution.
En poursuivant le développement de notre application, nous espérons con-
tribuer à la démocratisation de la cryptographie et à la sensibilisation à la
sécurité des données. Nous sommes déterminés à continuer d’explorer les avancées
technologiques, à intégrer les retours des utilisateurs et à répondre aux exigences
croissantes en matière de protection des informations.
Nous exprimons notre gratitude envers le Dr. EBELE pour son encadrement
et sa guidance tout au long de ce projet, ainsi qu’à tous ceux qui ont contribué
de près ou de loin à sa réalisation. Ce travail marque le début d’un engage-
ment continu dans la recherche et le développement de solutions de sécurité
informatique robustes et accessibles.

41
List of Figures
1 situation du contexte . . . . . . . . . . . . . . . . . . . . . . . . . 5
2 Illustration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3 Schéma général de l’AES . . . . . . . . . . . . . . . . . . . . . . . 15
4 Tableau multiplication . . . . . . . . . . . . . . . . . . . . . . . . 17
5 f() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
6 Tableau Multiplicatif Inverse . . . . . . . . . . . . . . . . . . . . 21
7 Key Schedule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
8 création des sous-clés de 192 bits . . . . . . . . . . . . . . . . . . 28
9 création des-clés de 256 bits . . . . . . . . . . . . . . . . . . . . . 28

42