LABROT / BENHAIDA / SALGUEIRO GP-121 1PI

COMPTE-RENDU : GRAND PROJET

PROGRAMMATION (GP-121)

UNE MESSAGERIE SECURISE : SEB

‘Secrets
LABROT-BENHAIDA-SALGUEIRO 1PI
07/04/2025

Professeur : M. ALIASGHARI

1
LABROT / BENHAIDA / SALGUEIRO GP-121 1PI

Table des Matières

1. Introduction ......................................................... 3
1.1 Contexte .......................................................
1.2 Objectifs .......................................................

2. Cadre Théorique .................................................. 3/4

2.1 Définitions ...................................................
2.2 Travaux Antérieurs .........................................

3. Méthodologie .................................................... 4
3.1 Collecte des Données ..................................
3.2 Analyse des Données ..................................

4. Résultats ........................................................ 11
4.1 Présentation des Résultats ..........................
4.2 Interprétation ..............................................

5. Conclusion.................................. 13

6. Bibliographie ......................................................... 14

2
LABROT / BENHAIDA / SALGUEIRO GP-121 1PI

INTRODUCTION :

La sécurisation des données est devenue un enjeu majeur dans

notre société de plus en plus connectée. Dans ce contexte, la cryptologie
joue un rôle essentiel en garantissant la confidentialité et l’intégrité des
informations échangées. Ce Grand Projet Programmation (GP-121) s’inscrit
dans cette problématique actuelle en proposant le développement d’un
outil de chiffrement et de déchiffrement fondé, dans notre cas, sur
l’algorithme de Vigenère, intégré à une interface graphique simple et
intuitive.

Ce projet a pour objectif principal de concevoir une application capable de

chiffrer et déchiffrer des messages à l’aide d’un algorithme poly
alphabétique, tout en offrant une expérience utilisateur fluide grâce à
l’utilisation de la bibliothèque Tkinter en Python. L’approche choisie
permet de combiner des compétences en algorithmique, en structuration
de code et en conception d’interfaces interactives, dans un cadre à la fois
théorique et pratique.

Le présent rapport est structuré de manière à retracer l’ensemble des

étapes du projet. Il débute par une présentation du cadre théorique de la
cryptologie et des concepts clés utilisés. Ensuite, la méthodologie adoptée
pour la réalisation de l’interface et de l’algorithme est détaillée. Les
résultats obtenus sont ensuite exposés et analysés, avant de conclure sur
les apports du projet et les perspectives d'amélioration envisagées.

Cadre Théorique :
La cryptologie est l'art de sécuriser l'information grâce à des processus
comme le chiffrement, qui transforme un texte lisible en texte
incompréhensible à l'aide d'une clé, et le déchiffrement, qui permet de le
rendre à nouveau lisible. Les clés, qu'elles soient symétriques (même clé
pour chiffrer et déchiffrer) ou asymétriques (clé publique et clé privée),
sont au cœur de la sécurité. Les algorithmes comme AES (Advanced
Encryption Standard) ou RSA assurent ces transformations, Le hachage
permet de vérifier que les données n'ont pas été modifiées, mais il est
impossible de revenir en arrière pour retrouver les données originales. La
signature numérique vérifie l'authenticité des messages, et diverses
attaques tentent de contourner ces mécanismes. La cryptologie est donc
essentielle pour protéger nos communications et nos données dans un
monde numérique.

3
LABROT / BENHAIDA / SALGUEIRO GP-121 1PI

Le chiffrement de Vigenère est une méthode classique de substitution

polyalphabétique qui utilise une clé composée de lettres pour chiffrer un
message en décalant chaque lettre du texte clair en fonction de la lettre
correspondante dans la clé. La clé est répétée pour correspondre à la
longueur du message, et chaque lettre est transformée selon son décalage
dans l'alphabet, rendant le texte chiffré difficile à interpréter sans la clé.
Bien que cette méthode soit plus résistante que les chiffrements
monoalphabétiques, elle reste vulnérable à des attaques comme l'analyse
fréquentielle ou la méthode de Kasiski. Facile à comprendre et à
implémenter, elle est souvent utilisée comme introduction à la
cryptographie.

La sécurité en cryptographie vise à protéger les informations en

garantissant leur confidentialité, leur intégrité, leur authentification et leur
non-répudiation (cela garantit qu'une personne ou une entité ne peut pas
nier avoir effectué une action, comme envoyer un message ou signer un
document, en fournissant des preuves irréfutables). Elle utilise des
techniques comme le chiffrement pour empêcher l'accès non autorisé et
les signatures numériques pour valider l'origine des données. En revanche,
la cryptanalyse cherche à identifier les failles des systèmes de sécurité en
exploitant des méthodes comme l'analyse fréquentielle, les attaques par
force brute ou les techniques avancées telles que la cryptanalyse
différenciée. Ces deux notions, bien que opposées, se complètent en
permettant d'améliorer la robustesse des systèmes cryptographiques face
aux menaces croissantes.

Méthodologie :

L’implémentation du projet repose sur l’utilisation du langage Python,

couplé à la bibliothèque Tkinter pour la conception de l’interface
graphique. L’objectif principal est de permettre à l’utilisateur de chiffrer et
déchiffrer un message texte à l’aide d’une clé numérique. La fenêtre
principale est créée à l’aide de Tk() et stylisée avec des couleurs sombres
pour un rendu visuel moderne et agréable. Tous les éléments graphiques
sont disposés verticalement grâce aux méthodes Label, Entry, Text, Button
et StringVar, facilitant la lecture et l’interaction.

L'utilisateur commence par entrer une clé sous forme de liste de nombres
séparés par des virgules. Le message à chiffrer est ensuite saisi dans une
zone de texte. En cliquant sur le bouton Chiffrer, la fonction
message_chiffrer() est appelée : elle récupère les données saisies,
transforme la clé en liste d'entiers, et appelle la fonction mot_chiffrer() qui

4
LABROT / BENHAIDA / SALGUEIRO GP-121 1PI

chiffre le texte selon un algorithme de décalage cyclique basé sur la clé.

Les lettres du message sont converties en valeurs numériques avec ord(),
modifiées modulo 26, puis reconverties avec chr().

À l’inverse, l’utilisateur peut également entrer un message chiffré, puis

cliquer sur le bouton Déchiffrer. La fonction message_dechiffrer() est alors
appelée, utilisant mot_dechiffrer() pour retrouver le message original via
une opération inverse du chiffrement, toujours en respectant la position
des lettres majuscules, minuscules et en conservant les caractères
spéciaux.

Enfin, la ligne [Link]() maintient l’interface active tant que

l'utilisateur ne ferme pas la fenêtre. Ce projet démontre la puissance de
Python pour combiner des algorithmes simples à une interface intuitive,
tout en mettant en œuvre des pratiques de programmation telles que la
gestion des erreurs, la modularité des fonctions et l'interactivité utilisateur.

Nous avons commencé par importer la bibliothèque tkinter car elle nous a
permis de créer une interface utilisateur graphique sans avoir besoin
d’écrire du code complexe. De plus, la bibliothèque Tkinter est livré par
défaut avec python ce qui évite d’avoir à installer des bibliothèques
supplémentaires. Nous avons aussi importé « messagebox » qui sert à
afficher des alertes ou des messages d’erreur.

Ensuite, nous avons utilisé la méthode de Vigenère pour chiffrer les

messages qui est un chiffrement polyalphabétique. Il consiste à coder un
message en utilisant une clé qui sert à décaler chaque lettre du texte
d’origine. Nous utilisons une clé sous forme de nombres. Cela renforce la
sécurité par rapport à un simplement chiffrement de césar.

Dans la fonction mot_chiffrer, une boucle for est utilisée pour parcourir
chaque caractère du message à chiffrer. Si le caractère est une lettre
(majuscule ou minuscule), il est transformé en position numérique (0 à
25), puis modifié en fonction de la clé fournie (une liste d’entiers) selon le
principe du chiffrement de Vigenère. Le résultat est ensuite reconverti en
lettre. La clé est utilisée de façon cyclique grâce à i = (i + 1) % k.
Les caractères spéciaux, comme la ponctuation ou les espaces, sont
conservés tels quels pour ne pas altérer la structure du message
5
LABROT / BENHAIDA / SALGUEIRO GP-121 1PI

Nous avons utilisé la même méthode pour le chiffrement que pour le

déchiffrement qui est ainsi basés sur Vigenère, avec une clé sous forme de
nombres, cela améliore légèrement la sécurité mais reste vulnérable à des
attaques avancées si on voulait renforcer la sécurité on devrait utiliser une
clé plus longue.

La boucle for de la fonction mot_dechiffrer parcourt chaque caractère du

message chiffré. Si c’est une lettre, elle est convertie en position
numérique (0 à 25), puis la clé est soustraite pour inverser le chiffrement
selon le principe du décalage inverse du chiffrement de Vigenère. Le + 26
garantit un résultat toujours positif avant l’opération modulo 26. Ensuite,
le code numérique est reconverti en lettre.
La clé est utilisée en boucle grâce à i = (i + 1) % k, ce qui permet de
répéter la clé autant que nécessaire.
Les caractères spéciaux (espaces, ponctuation, etc.) sont ignorés dans le

6
LABROT / BENHAIDA / SALGUEIRO GP-121 1PI

processus et ajoutés tels quels au message final pour en préserver le

format d’origine.

Les fonctions message_chiffrer() et message_dechiffrer() assurent la

liaison entre l'interface graphique et la logique de
chiffrement/déchiffrement. Elles récupèrent les données saisies par
l’utilisateur via les champs champ_message, champ_message_chiffre et
champ_cle, puis vérifient que le message et la clé sont bien présents.
La clé doit être saisie sous forme de suite d’entiers séparés par des
virgules (ex. : 3,1,4). Elle est ensuite convertie en liste d’entiers grâce à
une compréhension de liste. En cas d'erreur, un message d'alerte ou
d'erreur est affiché via messagebox.
Une fois les données valides, les fonctions appellent respectivement
mot_chiffrer() ou mot_dechiffrer() pour transformer le message. Le résultat
est ensuite affiché dans l’interface via une variable StringVar, ce qui met
automatiquement à jour les champs de sortie pour l’utilisateur

7
LABROT / BENHAIDA / SALGUEIRO GP-121 1PI

Nous avons créé une interface graphique avec tk(). L’interface graphique a
été conçue pour être simple, claire et fonctionnelle, tout en assurant une
bonne expérience utilisateur. Nous n’avons pas surchargé l’interface
graphique pour que le code soit plus simple

L’interface graphique du projet est construite avec Tkinter, un module

intégré à Python permettant de créer des fenêtres interactives. L’élément
racine (racine) représente la fenêtre principale, dans laquelle tous les
composants sont placés avec soin pour une utilisation intuitive. Le design
graphique adopte un fond sombre (#282828) avec des éléments
contrastés pour un affichage clair et moderne.

Le titre principal s’affiche en haut grâce à un Label stylisé avec une police
en gras et une couleur bleu ciel, donnant une première impression
soignée. Ensuite, l’utilisateur est invité à entrer une clé via un champ de

8
LABROT / BENHAIDA / SALGUEIRO GP-121 1PI

saisie (Entry), conçu avec un fond gris foncé et une bordure visible pour
attirer l’attention.

La zone de saisie du message à chiffrer est réalisée avec un composant

Text, permettant une saisie multi-lignes. Le bouton “Chiffrer”, de couleur
verte, déclenche la fonction message_chiffrer() lors du clic et chiffre le
message selon la clé donnée.

Le résultat chiffré s'affiche immédiatement dans un champ Entry, lié à une

variable StringVar pour mettre à jour automatiquement le contenu affiché.
L’utilisateur peut aussi entrer manuellement un message chiffré, qui sera
interprété par la fonction de déchiffrement.

Le bouton “Déchiffrer”, de couleur rouge orangé, exécute la fonction

message_dechiffrer() et affiche le message déchiffré dans un autre champ
de sortie. Chaque composant graphique est espacé (pady) pour offrir une
bonne lisibilité et une navigation fluide.

L’interface est donc pensée pour guider l’utilisateur de manière logique,

en séparant bien les sections de chiffrement et de déchiffrement, tout en
assurant une expérience utilisateur fluide et ergonomique.

9
LABROT / BENHAIDA / SALGUEIRO GP-121 1PI

Enfin nous avons terminé ce programme avec une ligne indispensable car
elle nous permet de demarrer la boucle principale de l’interface
graphique. Cette ligne a son importance dans notre programme car c’est
grâce a cette derniere que l’application reste interactive.

Dans ce projet, nous avons conçu une interface graphique en Python

permettant de chiffrer et déchiffrer des messages à l’aide d’un algorithme
de type Vigénère . Le choix de la bibliothèque Tkinter s’est imposé
naturellement car elle est simple d’utilisation, légère et intégrée à Python,
ce qui la rend idéale pour développer une interface conviviale sans
dépendances externes.

L’algorithme repose sur une clé composée de décalages numériques, ce

qui offre une alternative intéressante aux versions classiques utilisant des
lettres. Le programme est structuré en fonctions distinctes afin de garantir
une bonne lisibilité du code et de faciliter la maintenance.

Lors de la conception, plusieurs difficultés ont été rencontrées, notamment

la gestion des majuscules et minuscules, le déroulement automatique de
la clé, le traitement des caractères spéciaux à ne pas chiffrer, et la
synchronisation entre les entrées utilisateurs et les affichages dans
l’interface. Ces problèmes ont été résolus en utilisant des conditions
adaptées (isupper(), isalpha()) et en bouclant la clé avec l’opérateur
modulo.

10
LABROT / BENHAIDA / SALGUEIRO GP-121 1PI

De plus, une attention particulière a aussi été portée à l’ergonomie de

l’interface pour que l’utilisateur puisse facilement saisir un message, une
clé, puis visualiser le message chiffré ou déchiffré. Ce projet a ainsi permis
de mettre en œuvre un algorithme de cryptographie simple dans un
environnement interactif, tout en développant des compétences en
structuration de code, en logique algorithmique et en conception
d’interfaces utilisateurs.

Ainsi ; le programme développé permet de chiffrer et déchiffrer

efficacement un message à l'aide d'une clé numérique, basée sur le
principe de l'algorithme de Vigenère. L'interface graphique, conçue avec la
bibliothèque Tkinter, facilite l'utilisation de l'application : l'utilisateur peut
saisir un message en clair, entrer une clé de chiffrement, puis obtenir
immédiatement le texte chiffré ou déchiffré.

Plusieurs tests ont été réalisés afin de vérifier le bon fonctionnement de

l'outil. Ces tests ont confirmé :

 La gestion correcte des majuscules et des minuscules.

 L’ignorance des caractères spéciaux et des espaces lors du
chiffrement.
 La bonne synchronisation entre la clé et le texte, grâce à l'utilisation
de l’opérateur modulo.
 L’affichage clair des résultats dans l’interface.

RESULTATS :
Voici un exemple de message crypté :

11
LABROT / BENHAIDA / SALGUEIRO GP-121 1PI

Ainsi que ce même message décrypté :

Le système repose sur un chiffrement de Vigenère modifié, utilisant une

clé composée de décalages numériques. Ce type de chiffrement est plus
robuste qu’un chiffrement monoalphabétique classique (comme le
chiffrement de César), notamment en raison de l’usage d’une clé répétée
qui rend l’analyse fréquentielle plus complexe.

Cependant, ce système présente plusieurs faiblesses :

Par exemple, sa vulnérabilité à l’analyse fréquentielle : si la clé est courte

et utilisée de manière répétitive, un attaquant peut appliquer des
techniques telles que la méthode de Kasiski ou l’indice de coïncidence
pour retrouver la clé.

Ou encore le manque d’usage de clés dynamiques ou de mécanismes de

renforcement ; comme le salage ou l’intégration d’un hachage pour
vérifier l’intégrité du message.

De plus un petit problème technique apparait ; quand l’onglet tkinker n’est

pas en pleine écran il peut arriver que les messages décrypter ne s’affiche
pas.

En résumé, ce système est approprié pour un usage pédagogique ou pour

des données non sensibles, mais ne garantit pas une sécurité suffisante
face à un attaquant déterminé.

12
LABROT / BENHAIDA / SALGUEIRO GP-121 1PI

Malgré les bons résultats obtenus, plusieurs axes d'amélioration sont

envisageables :

Comme, par exemple ; l’allongement et la randomisation de la clé : Une

clé plus longue ou générée aléatoirement à chaque session pourrait
considérablement augmenter la résistance aux attaques.

De plus l’ajout d’un système de vérification d’intégrité serait efficace : Par

exemple, un hachage du message d’origine pour détecter toute
modification.

L’implémentation d’autres algorithmes pourraient aussi permettre une

sécurité plus renforcée : Pour rendre l’outil plus complet, des algorithmes
comme AES ou RSA pourraient être proposés en option.

CONCLUSION :

Pour conclure : Ce projet a permis de concevoir et de développer une

application de chiffrement et de déchiffrement basée sur l’algorithme de
Vigenère, intégrée à une interface graphique simple et fonctionnelle grâce
à la bibliothèque Tkinter. En combinant des notions de cryptographie, de
programmation Python et de conception d’interface utilisateur, nous avons
pu mettre en œuvre une solution concrète illustrant les principes
fondamentaux de la sécurité de l’information.

Ce travail nous a permis de mieux comprendre le fonctionnement des

systèmes de chiffrement classiques, ainsi que les limites inhérentes à ce
type de méthode. Bien que le système réalisé soit fonctionnel et intuitif, il
reste vulnérable à certaines attaques et ne saurait être utilisé dans un
contexte nécessitant un haut niveau de sécurité. Toutefois, il constitue une
base solide pour des évolutions futures, tant sur le plan technique qu’en
termes de sécurité.

Ce projet nous a aussi permis d’apprendre et de renforcer plusieurs

compétences utiles, comme savoir organiser un programme, résoudre des
problèmes techniques, créer une interface facile à utiliser, et bien
comprendre le fonctionnement des algorithmes. Grâce à ce travail, nous
avons maintenant une bonne base pour aller plus loin, en améliorant notre
application avec des méthodes de chiffrement plus sécurisées et une
interface encore plus complète.

13
LABROT / BENHAIDA / SALGUEIRO GP-121 1PI

BIBLIOGRAPHIE :
[Link]

[Link]

[Link]
list=PLjrnnc4BZaRCR5eOXSTAgKJpBl62Y7o45

[Link]

14