Conclusion

Transcription

Conclusion

TPE 2004 - Khemiri Taxu George - « Quels sont les différents moyens de sécuriser une information »
TPE 2003-2004
« Quels sont les différents
moyens de sécuriser une
information ? »
La Cryptographie
Khemiri Karim, Taxu Clément, George Kévin,
TS1 au Lycée Georges-Baumont de Saint-Dié
- Page 1 -
Sommaire
Page 3
Introduction
• Choix de la problématique
• Intérêt de la cryptographie
• Historique de la cryptographie
Page 3
Page 3
Page 4
Les Différents systèmes de cryptographie
1.) Les systèmes a clé symétrique
•
•
•
•
Le chiffrement de César
Le chiffrement de Vigenère
L’algorithme DES
Conclusion
2.) Les systèmes à clé asymétrique
• Le chiffrement RSA
• Conclusion
Page 5
Page 6
Page 8
Page 10
Page 10
Page 11
Page 12
La Production : Le programme de Cryptage :
•
•
•
•
•
•
•
•
•
•
Page 5
Diagramme FAST du programme
Avant Propos : Le Codage des lettres en ASCII
Fonctions récurrentes en C++
Partie Clé Privée : Fonction XOR
Partie Clé Publique :Algorithme RSA
Acquisitions et Menus
Sauvegardes des Textes
Le générateur de Clés
Mode d’emplois du programme
Code Source du programme
Conclusion Générale :
• Les Limites de la Cryptographies : La Cryptanalyse
• L’avenir de la Cryptographie : Les Photons
- Page 2 -
Page 13
Page 14
Page 15
Page 16
Page 16
Page 17
Page 17
Page 17
Page 18
Page 18
Page 19
Page 25
Page 25
Page 25
Introduction
Choix de la problématique :
Parmi les thèmes nationaux proposés pour les TPE, entre L’Europe, Espaces et Mouvements,
Formes et Structures, Information et Communication et Cybernétique Robotique et Energies,
notre choix s’est porté vers Informations et Communications ce qui nous a conduit à nous
intéresser à la sécurité du transfert d’informations.
Le moyen le plus courant, selon nous, pour sécuriser une information étant de crypter le
message, nous avons décider de réaliser un TPE parlant des différentes méthodes de
cryptographie et donc notre problématique sera « Quels sont les différent moyens de sécuriser
le transfert d’une information a travers la cryptographie ? ».
Pour répondre à cette problématique, nous étudierons tout d’abord les systèmes existant, puis
pour la production servant à illustrer notre sujet, l’informatique étant omniprésent en ce qui
concerne l’information et la communication nous avons décidé de réaliser un programme
permettant d’encrypter et de décrypter un message d’une manière sure, en nous basant sur
cette étude.
• Qu’est ce que la cryptographie ?
La cryptographie est la science du chiffrement des messages afin de rendre ce message
incompréhensible sans clé. Le nombre d’algorithmes chiffrant le message est illimité.
L’intérêt de la cryptographie :
De l’antiquité à de nos jours la cryptographie a intérêt important sur des domaines variés, en
effet l’homme a toujours eu besoin de garder certaines informations a l’abris des regards
indiscrets. Il faut pouvoir envoyer un message que seul la personne de notre choix puisse lire.
Les enjeux sont multiples et peuvent être très importants, par exemple si durant une guerre un
message est intercepté par l’ennemi cela peut changer l’issue de toute une guerre. Mais cela
n’empêche que l’ont puisse vouloir tout simplement préserver la confidentialité d’une
conversation anodine.
Le simple fait d’envoyer un message est donc très dangereux si l’ont veut garder ce message
secret, car dans ce cas de nombreux intrus pourront lire le message en tout liberté, la
cryptographie joue donc ce rôle de gardien de la sécurité conversation et doit donc être le plus
fiable possible.
• Dans quels domaines s’applique la cryptographie ?
Aujourd’hui la cryptographie ne s’applique plus essentiellement au domaine militaire
mais est ouverte au grand public tout en garantissant la sécurité d’informations à forts
enjeux, comme dans le réseau bancaire où toutes les transactions sont sécurisées au
maximum, ou à la télévision où certaines chaînes encryptent des émissions que seuls les
abonnés peuvent décrypter, les conversations téléphoniques peuvent également être
encryptées. On retrouve cela également dans de nombreux biens de consommation : CD
audio, clé de logiciel, puces de téléphones portables,… mais surtout dans des envois
d’information par internet.
- Page 3 -
L’histoire de la cryptographie :
Quelques exemples de systèmes utilisés dans l’histoire ;
•
La Scytale
Comme dit précédemment l’homme a toujours ressentit le besoin de sécuriser l’envois d’un
message, on retrouve donc des systèmes de cryptographie dès l’antiquité car on se rendit
compte de son importance stratégique, le plus anciens des systèmes connus étant la Scytale
qui permettait a l’armée grecque au Veme siècle avant JC de communiquer sans que l’ennemis
ne puisse comprendre le message si il l’intercepte.
La scytale est un exemple basique de stéganographie, il s’agit d’une bandelette que l’ont enroule autour d’un
cylindre d’un diamètre défini pour lire et écrire le message, le diamètre du cylindre joue donc le rôle de clé, sans
le cylindre et le bon diamètre le message est inintelligible. Mais il est évident que la sécurité de se système est
très faible.
•
Le Carré de Polybe
Un autre exemple encore une fois appliqué au domaine militaire mais cette fois-ci vers 150
avant JC pour l’empire romain, est le cryptosystème inventé par le grec Polybe appelé Carré
de Polybe, celui-ci marque une étape important dans l’histoire de la cryptographie car c’est à
partir de là que l’ont commence à chiffrer les messages plutôt que de mélanger ses lettres
comme le faisait le carré de Polybe.
1
2
3
4
5
1
2
3
4
5
A
F
K
P
U
B
G
L
Q
V
C
H
M
R
X
D
I
N
S
Y
E
J
O
T
Z
Le Carré de Polybe : l’alphabet est transposé dans un tableau et pour enchiffrer on remplace chaque lettre du
message à crypter par ses coordonnées dans le tableau.
- Page 4 -
•
La cryptographie au début du XXème siècle lors des Guerres Mondiales
Au fil de l’histoire, la cryptographie comprends de nouveaux systèmes mais la plupart reste
toutefois assez proche du système du carré de Polybe et du Code de César (dont nous
parlerons dans la partie suivante), ainsi on retrouve 20 siècles plus tard le Carré de Polybe
utilisé lors de la première guerre mondiale par les allemands qui lui ajoutent des chiffres et le
suivent d’une transposition afin de brouiller les pistes des cryptanalyses, il est appelé code
ADFGVX (lettres remplaçant 1,2,3,4,5 en colonne et en ligne du tableau).
Ce code sera tout de même cassé par Painvain, cryptanaliste français ce qui permit a l’armée
française d’être au courant d’une grande offensive allemande le 9 juin 1918 et de la stopper.
Lors de la seconde guerre mondiale c’est cette fois sur le Code de César que les allemands se
basent. Les allemands chiffraient leurs messages à l’aide de la machine à coder Enigma, cette
machine enchiffrait donc les lettres d’une manière analogue au Code de César mais cela était
suivit d’une multitude de transposition qui varient à chaque lettre selon la matrices utilisée.
La machine à coder Enigma se présente comme une machine a écrire mais a l’intérieur le système est complexe,
selon la clé utilisé, l’utilisateur choisit les matrices (comme celles posées à gauche de l’image) puis il appuis sur
les touches des lettres à coder ou décoder, puis une lumière s’allume sur la lettre correspondante.
Lors de la seconde guerre mondiale près de 12000 scientifiques et mathématiciens anglais,
français et polonais travaillaient à Bletchley Park à casser ce code, 18 000 messages par jours
furent décryptés, et permirent aux forces Alliées d’anticiper les actions de l’Allemagne, mais
ce système n’en restait pas moins difficile à briser notamment concernant les messages de la
marine qui utilisait une variante plus sure du système Enigma.
La cryptographie et la cryptanalyse jouaient donc un rôle clé et extrêmement important lors
des guerres.
- Page 5 -
Les Principaux Systèmes de Cryptographie
Il est possible de classer les cryptosystèmes les plus courants sous deux catégories les
systèmes asymétriques et les systèmes symétriques.
1.) Les systèmes symétriques ou à clé privée
Le système a clefs secrète est le plus simple et évident, il s’agit de l’ensemble des
cryptosystèmes qui utilisent la même clef pour encoder et pour décoder le message.
L’algorithme utilisé est donc forcément réversible.
Diagramme des systèmes a clef privée.
Dans un système asymétrique la clé doit être à la fois connue par le codeur et par le décodeur.
Pour une meilleure sécurité il est préférable que l’algorithme ne soit également connu que des
gens envoyant ou recevant l’information.
Le nombre de système à clé privée est illimité car un algorithme est facile à inventer, nous
allons donc exposer les principaux systèmes à clé asymétrique.
Le chiffrement de César
Ce code était utilisé par César pour envoyer des messages codés, il s’agit simplement d’un
décalage des lettres de l’alphabet.
ABCDEFGHIJKLMNOPQRSTUVWXYZ
CDEFGHIJKLMNOPQRSTUVWXYZAB
Exemple d’un chiffrement avec la clé de César avec décalage de l’alphabet de 2 lettres.
- Page 6 -
Il suffit ensuite de remplacer dans le texte les lettres par celles qui leur correspondent X rang
plus tard, X jouant éventuellement le rôle de clef.
Avantages :
• Code simple, textes rapide à crypter et décrypter
Inconvénients :
• Le Code de César ne permet que 25 manières différentes de crypter
• A combiner avec des transpositions complexes (cf. Enigma)
• Système « trop » classique
• Brute forçable aisément.
Bien que ce code ait encore été utilisé par les Sudistes durant la guerre de Sécession Etatsunienne et même par l’armée russe lors de la première Guerre Mondiale, ce système est
aujourd’hui obsolète si il est nécessaire de préserver une sécurité efficace sur le transit de ses
informations.
Aujourd’hui ce système est utilisé essentiellement sur les forums de discussion Internet où
l’on fait passer des informations qui ne doivent être lues que volontairement et non par
inadvertance (comme par exemple la fin d’un film), avec une clé de 13, sous le nom de
ROT13.
Le carré de Vigenère (ou carré de Trithème)
En 1586 Blaise de Vigenère crée cet algorithme de cryptage à partir du carré de Trithème, il
s’agit en quelque sorte d’un mélange entre le carré de Polybe et le code de César.
Carré de Trithème qui permet d’exécuter le l’algorithme de Vigenère, comme vous pouvez le constater il s’agit
en quelques sortes d’un carré de Polybe où les coordonnées des lettres sont des lettres, chaque ligne reprends
l’alphabet avec un décalage d’une lettre (à la manière du code de César)
- Page 7 -
Pour crypter un mot selon l’algorithme de Vigenère, l’axe des abscisses correspond aux lettres
du texte clair l’axe des ordonnées correspond aux lettres de la clef (la clef peut être un mot ou
un texte), il suffit ensuite de lire la lettre qui est a l’intersection de la colonne de la lettre du
texte clair et de la ligne de la clef, et ce pour chaque lettre successive du texte et de la clé, on
obtient ainsi un texte crypté.
Si la clef est plus courte que le texte alors il faut la répéter.
Par exemple prenons la clef « CLE » et le texte à crypter « CLAIR », en prenant les
intersections successives on obtient « EWEKC ».
Il est a remarquer que l’ont obtient d’abord E avec C et C puis avec E et A, cela constitue un
des principaux intérêts du code de Vigenère qui permet d’éviter la redondance de lettres qui
correspondent à la même lettre (nous en reparlerons dans la partie sur la cryptanalyse)
Avantages :
• Les lettres ne se répètent pas sous la même forme
• Beaucoup plus sûr que le Code de César, difficile à casser sans ordinateur
Inconvénients :
• Célèbre
• Fastidieux « à la main » (bien qu’un ordinateur fait cela rapidement)
• Code cassable facilement a l’aide d’un ordinateur (détection de la longueur de la clé)
Ce système a par exemple beaucoup servit pour les lignes de télégraphe (qui étaient
facilement espionnable), il peut être très efficace si la clé est très longue.
Le Data Encryption Standard, DES
L’algorithme DES est très récent contrairement à ceux présentés précédemment, puisqu’il a
été développé par la société d’informatique IBM en 1976, il s’agit d’un algorithme prévu pour
être exécuté par des ordinateurs (en effet l’appliquer par un homme serait plus que long et
fastidieux), c’est un algorithme public.
Il agit sur le texte a crypter par blocs de 64bits (soit 8 octets et sachant qu’en ASCII une lettre
tient dans un octet cela représente donc 8 lettres) utilisant une clef de 56bits en enchaînant des
substitutions et des permutations rendent l’algorithme complexe, on appel cela un chiffrement
Feistel.
La dernière version du DES date de 2000 (Rijndael qui de vient l’AES).
Son fonctionnement simplifié est :
Tout d’abord il fractionne le texte en blocs de 64bits, il effectue la permutation initiale, puis
sépare les blocs en 2 parties et il répète 16 fois des opérations de substitution et de
permutation (appelés Rounds) et réunifie le bloc séparé en deux et effectue enfin l’inverse de
la permutation initiale.
- Page 8 -
Diagramme de fonctionnement de l’algorithme DES, enchaînement de permutations transpositions substitutions
avec utilisation de fonctions XOR.
Avantages :
• Nécessite une clef courte avec 256 combinaisons de clés différentes (car clé de 56bits
utiles sur les 64)
• Efficace
• La confidentialité de l’algorithme n’est pas nécessaire, contrairement aux systèmes
précédents, celui-ci reste sûr même si un intrus sait qu’il est utilisé
Inconvénients :
• Compliqué, il nécessite l’emplois d’un ordinateur pour encrypter et décrypter
• Commence à être dépassé
• Pas infaillible, un organisme tel qu’un état peut disposer de moyens informatiques
assez importants pour casser le code très aisément (méthode de Brute Force)
Une solution donnée en 1990 pour améliorée le DES est le Triple-DES qui consiste a utiliser
le DES trois fois de suite avec une clé de 112bit au lieu de 54.
Le fonctionnement de précis de cet algorithme est compliqué, il serait donc long à expliquer
et à comprendre totalement c’est pourquoi nous n’utiliserons pas cet algorithme pour notre
production.
- Page 9 -
Conclusion :
Il existe donc une infinité de cryptosystèmes plus ou moins efficaces et plus ou moins aisés a
mettre en œuvre, l’idéal serait un système utilisant une clé courte et qui est très sûr, car
comme le démontre Kerckhoffs dans « La Cryptographie Militaire » le système idéal est celui
ne nécessitant pas d’être gardé confidentiel lors d’un échange de donné, ainsi il serait possible
avec un bon système d’envoyer l’algorithme avec le message crypté, puis la clef séparément.
Un problème évident se pose au sujet des systèmes à clé symétrique concernant la clé, en effet
le problème auquel répond la cryptographie se repose « Comment partager une clé de manière
sûre ? », l’intérêt peut sembler limité si on crypte un message de manière efficace alors que la
clé est envoyée sans précautions, cela serait donc inutile puisque la clé permet d’avoir le texte
clair, il pourrait également être possible de changer a chaque fois de clé (masques jetables).
La première solution, la plus évidente mais qui reste risquée est le Tiers de confiance, qui
serait par exemple un messager qui donnerait la clé a l’interlocuteur sans être intéressé au
message, cela demeure risqué car l’espion peut mettre la main sur ce Tiers, celui-ci doit être
incorruptible.
L’autre méthode est le cryptage par clé asymétrique.
2.) Les systèmes asymétriques ou à clé publique
Ces systèmes sont tous plutôt récent puisque ce concept est apparut dans le dernier quart du
20eme siècle, ce système a été conçu pour éviter les problèmes d’échange de clés dont nous
parlions a la fin de la partie précédente.
L’idée est que le système soit utilisé avec deux clés, une clé publique et une clé privée,
l’intérêt étant que la clé publique peut être connue de tous et la clé privée n’a à être connue
uniquement par une personne, l’ensemble de clé publique et privée est propre a chaque
personne.
Le fonctionnement théorique de ce système est le suivant, une personne choisit sa clé privée,
qu’il est donc le seul a connaître et qui lui servira a décrypter le message, de cette clé privée il
déduit une clé publique qui servira à son correspondant à crypter le message, et il déclare
publiquement cette clé publique, par exemple à l’aide d’un annuaire.
L’algorithme doit permettre a n’importe quelle personne de crypter un message à l’aide de la
clé publique qui ne peut être décrypté uniquement par la personne possédant la clé privée
correspondant.
Diagramme du fonctionnement des systèmes a clé publique.
- Page 10 -
Deux difficultés se présentent donc en pratique, il faut trouver un algorithme permettant de
trouver une clé publique à l’aide d’une clé privée choisie sans que l’inverse ne soit possible
(si on peut retrouver la clé privée a l’aide de la clé publique cela n’a plus d’intérêt), et un
algorithme qui doit permettre de crypter un message avec une clé publique mais pas de le
décrypter avec cette clé, le texte doit uniquement être décryptable avec la clé privée.
Un exemple de système à clé asymétrique, le Chiffrement RSA
RSA est un algorithme conçu par Ronald L. Rivest, Adi Shamir et Leonard M. Adleman (d’où
le nom RSA) en 1978, il s’agit de l’algorithme le plus célèbre concernant les systèmes à clé
publique.
L’algorithme :
•
Il faut tout d’abord calculer les clés :
On choisit deux entiers premiers p et q étant supérieurs à 10100 et on
calcule l’entier n qui est le produit de produit de q et de p
Il faut ensuite choisir un entier aléatoire e tel que e et ((p-1).(q-1))
soient premiers entre eux
Enfin il faut trouver l’unique entier d tel que : ed ≡ 1[(p-1).(q-1)].
On obtient la clé publique qui est n et e et la clé privée n et d
•
Cryptage et Décryptage :
Soient le texte clair m et le texte crypté c.
Pour crypter :
c = me mod(n), (n,e) étant la clé publique du destinataire.
Pour décrypter :
m = cd mod(n), (n,d) étant la clé privée du destinataire.
Un problème se pose, si la clé publique peut être connue de tous, comment être certains que
l’on reçoit bien le message d’une personne attendue et non d’un usurpateur d’identité ?
La solution est simple, il suffit à l’expéditeur d’envoyer sa signature qui certifiera
l’authenticité de son message, cela est simple à faire, étant donné qu’une clé privée et
publique sont liées et propres à chaque personne.
Il suffit à l’expéditeur de crypter un message m à l’aide de sa propre clé privée ce message
crypté sera la signature s, de telle manière :
s = md mod(n), où (n,d) est la clé privée de l'expéditeur.
Le destinataire peut ensuite décrypter cette signature à l’aide de la clé publique de
l’expéditeur il vérifie ainsi l’authenticité du message :
m = se mod(n), où (n,e) est la clé publique de l'expéditeur.
Cet algorithme est très souvent utilisé pour crypter la clé de systèmes à clé privée.
Il servirait notamment à protéger les codes nucléaires confidentiels de grandes nations (USA,
Russie…), il repose essentiellement sur la difficulté à décomposer n.
- Page 11 -
Cet algorithme crypte également les Clés pour SSL qui est très souvent utilisé pour les
transactions en ligne (page Web commencent par HTTPS://...)
Avantages :
•
•
•
•
Très sûr, parfois même considéré comme étant le plus sûr
Plus de problèmes de communication de clé
Idéal pour renforcer la sécurité d’un système a clé privé
Quasiment impossible de retrouver une clé privée) l’aide d’une clé publique
Inconvénients :
•
Lenteur, RSA est 1500 fois plus lent que DES
Conclusion :
L’idéal semble donc être de faire un système a clé privée qui serait renforcé par un système a
clé publique afin de garantir une forte sécurité.
Contrairement aux systèmes a clé privée, le nombre de systèmes a clé publiques est très limité,
le principal systèmes autres que RSA étant PGP qui est interdit en France (citons également
les systèmes Diffie-Hellman et DSA).
- Page 12 -
Production de notre TPE
En nous basant donc sur l’étude précédente, ses conclusions, et sur les connaissances
personnelles des membres de notre groupe, nous avons donc décider de faire une « maquette »
d’un programme informatique cryptant à l’aide d’un système clé privée et clé publique, la
partie clé publique servant a crypter la clé, et la partie clé privée a crypter le message en luimême.
Pour ce faire nous avons donc choisit l’algorithme RSA en ce qui concerne le chiffrement
asymétrique et la fonction OU-EXCLUSIF –XOR- en ce qui concerne le chiffrement
symétrique.
Le programme simple sera réalisé à l’aide du langage C++, il n’aura pas pour but d’être
infaillible ou commercialisable, mais simplement de servir d’exemple pour mettre en scène
une communication sécurisée (de plus nos connaissances en C++ étant très limitées il nous
serait impossible pour le moment de gérer des entiers premiers de plus de 100 chiffres).
Selon nos exigences et celles que son susceptibles d’avoir les utilisateurs d’un tel programme,
nous avons donc conçus le diagramme FAST suivant, représentant les fonctions du système et
leurs solutions concrètes.
Nous reviendrons ensuite en détail sur les différentes fonctions du programme
- Page 13 -
- Page 14 -
Avant propos : Le codage des lettres :
Pour tout algorithme il faut convertir les lettres afin de pouvoir leur appliquer des fonctions
mathématiques, la solution la plus simple étant d’affecter à chaque lettre son rang dans
l’alphabet.
Etant donné qu’il s’agit d’un programme informatique, le moyen le plus rapide et que nous
avons choisit d’utiliser est le codage ASCII de base (American Standard Code for Information
Interchange), il s’agit d’une table de valeur standard que la grande majorité des ordinateurs
utilisent pour les caractères.
Table des codes ASCII de base
Les caractères de la table ASCII de base sont codés sur 7bits, ce qui fait donc qu’il y a 128
caractères possibles (ceux de la table ASCII étendue sont codés sur 8bits).
Nous associerons donc directement un caractère a sa valeur ASCII dans notre programme,
l’avantage étant qu’une fois codé il devrait y avoir 128 possibilités de caractères au lieu de 26
lettres + 11 chiffres.
Il est à constater que l’inconvénient majeur est que la première colonne de cette table
représente des caractères non imprimables (donc impossible à écrire pour décoder si ils
résultent du cryptage). L’autre inconvénient et qu’il peut aussi résulter des caractères
imprimables mais difficiles d’accès (le seul moyen de les afficher étant par exemple une
combinaison de touches), pour pallier à ce problème nous avons décider d’intégrer un lecteur
et un éditeur de texte qui évitera donc d’avoir a retaper des caractères incongrus.
- Page 15 -
C++ : Les fonctions les plus utilisées dans le programme :
Dans le programme les fonctions qui reviendront le plus souvent seront :
• Les opérateurs cout << et cin>>, permettant respectivement d’afficher du texte
et d’acquérir du texte
• Les variables entières sont définies par ‘int NomVariable = initialisation’
• Les accolades représentent des parties, des blocs de fonction
• If est une condition SI (entre parenthèse la condition puis l’application entre
accolade) ELSE correspond a SINON
• WHILE est une boucle, tant que la condition entre parenthèse n’est pas vraie
on exécute ce qui se trouve entre accolades
• ‘%’ désigne l’instruction modulo.
Partie clé symétrique - La fonction OU-EXCLUSIF ou XOR :
Il s’agit de la fonction que nous allons utiliser pour notre système a clé privée.
C’est une fonction assez connue, utilisée en logique électronique, qui agit sur les nombres en
binaire.
Le symbole de cette fonction est ⊕ .
A
0
0
1
1
B
0
1
0
1
C
0
1
1
1
Tableau logique de la fonction XOR, tel que A ⊕ B=C.
Cette fonction est donc évidemment réversible, elle est également utilisée dans des
cryptosystèmes (comme le DES).
Sa fonction sera donc de comparer chaque bit d’octet du code ASCII de chaque lettre du mot
à crypter avec la clé. Ainsi par exemple on aura :
a ⊕ G= 97 ⊕ 71 = 01100001 ⊕ 01000111 = 00100110= 38 =&
La fonction étant réversible on aura également :
a ⊕ & =G et & ⊕ G = a
En C++ l’opérateur pour la fonction XOR est le symbole ‘^’, il nous suffira donc de déclarer,
LettreCryptée = LettreMot ⊕ LettreCle, pour effectuer la fonction.
Pour notre programme nous avons décidé d’utiliser une clé numérique de 4 caractères
(analogue aux clés de cartes bancaires)..
Le texte étant plus long qu’une clé de 4 caractères, celle-ci interviendra en boucle.
- Page 16 -
La partie clé asymétrique - L’algorithme RSA :
Nous avons retranscrit l’algorithme RSA en C++, pour ce faire nous avons dû utiliser
quelques méthodes spécifiques.
En C++ il nous était apparemment impossible d’effectuer une puissance d’entier.
Nous avons donc dû repenser cette fonction, pour ab la boucle WHILE multiplie a par luimême le même nombre de fois qu’il divise b par 2, lorsque sa partie entière vaut 0 alors a a
été multiplié b fois par lui-même.
Nous avons réaliser 2 parties, une pour le cryptage et une pour le décryptage, mais leur
fonctionnement est très similaire (seules les variables changent).
Le programme demande donc les 2 nombres de la clé, puis le mot a traité et effectue le travail
instantanément.
Il est préférable de choisir un nombre de 4 chiffres comme mot-clé.
L’Acquisition de Données et Menus :
L’acquisition de données est très simple en C++, il suffit de déclarer une variable puis
d’afficher à l’écran un texte demandant la variable (à l’aide de « cout << ‘TEXTE’ ») puis de
placer ce que l’utilisateur valide avec Entrer dans cette variable (à l’aide de « cin >>
Variable »).
Pour gérer un menu, nous avons d’abord repris la procédure d’acquisition de donnée dite
précédemment et nous plaçons là valeur dans une variable « Choix », puis affecté un nombre
entier à chaque sous-programme, ensuite la fonction SWITCH gère cela.
Dans le bloc de cette fonction on attribue le numéro grâce à l’affecteur « CASE », ensuite en
fonction de la valeur de choix, SWITCH appel le sous-programme désiré (voir code source).
L’enregistrement et lecture des fichiers :
Cette fonction est donc là pour rendre plus agréable et efficace l’utilisation du programme, en
effet, recopier certains caractères spéciaux du code ASCII aurait été long et laborieux, sujet a
de nombreuses erreurs.
Dans le programme les textes sont donc gérés en tant que chaînes de caractères STRING.
Pour affecter une lettre en particulier de cette chaîne de caractères il suffit de donner le nom
de cette chaîne en spécifiant le rang de la lettre concernée, de telle manière : NomChaîne[n],
n représentant le rang de la lettre, ce qui nous facilite les cryptages lettre à lettre.
Comme par exemple dans notre programme : CléCryptée[n] = Mot[n]^Clé[n] pour la
fonction ou exclusif. Pour afficher le texte en son intégralité il suffit simplement d’écrire :
« cout << NomChaîne ; », pour l’acquisition il faut utiliser getline au lieu de cin.
Pour enregistrer un fichier il suffit d’écrire
ofstream f("c:\\CHEMINDACCES/texte.txt",ios::binary|ios::out|ios::app);
f << NomChaîne << "\r\n";
Pour l’ouvrir :
ifstream File("c:/Chemind’Acces/fichier.txt");
getline(File, NomChaineOuPlacerTexte);
- Page 17 -
La Partie Générateur De Clé :
Nous avons pensé à cette fonction car la recherche de clé prend souvent du temps, et nous
avons voulu faire une production permettant une présentation dynamique et non dirigiste
comme cela aurait été le cas si nous avions simplement édité un annuaire de clés.
L’idée est simple, l’utilisateur n’a qu’à choisir ses valeurs de p et q, nombres premiers de
l’algorithme de clés RSA, et le programme se charge d’en déduire la clé privée et publique
correspondante.
• Tout d’abord le programme vérifie si ces nombres sont bien premiers,a l’aide d’une
division successive : avec FOR on incrémente une valeur d et a chaque incrément on
vérifie si le nombre modulo d vaut 0, si ce n’est pas le cas jusqu'à ce que d atteigne la
moitié de la valeur du nombre, alors ce nombre est premier, sinon le programme émet
un bip (grâce à \a) et signal une erreur d’entrée de données.
• Le programme calcule ensuite n produit de p et q
• Puis (p-1)(q-1) qui est appelé ici valmod
• Puis la fonction WHILE permet de trouver e en incrémentant e a partir de 1 jusqu'à ce
que PGCD(e, valmod) soit égal à 1, donc que e est premier avec valmod.
• La seconde fonction WHILE fait de même pour e en l’incrémentant jusqu’à ce que le
produit de e et d soit congru à 1 modulo valmod.
• Le programme récapitule en indiquant la valeur des clés.
Remarque : pour le calcul du PGCD, la bibliothèque de fonction concernant le PGCD en C++
nous étant inconnus nous avons donc fait appel a un sous-programme pour le calculer, celui-ci
calcule les modulos de a et b entre eux en les intervertissant jusqu'à ce que l’un d’entre eux ne
vaille 0 l’autre membre sera le PGCD.
Utilisation du programme, présentation :
Pour lancer le programme il faut d’abord lancer « l’invite de commande » qui en général se
trouve dans « Démarrer/Programmes/Accessoires » puis il suffit de glisser+déposer le fichier
exécutable TPECRYPTOKTG.EXE.
Le menu propose de choisir une action, tout d’abord choisir 1 pour générer une clé, le
programme demander 2 nombres premiers, les entrer, le programme vérifie ensuite si ils sont
premiers, et il affiche automatiquement la valeur de la clé publique et de la clé privée.
Il lui faut ensuite publier sa clé publique et garder la clé privée dans un endroit sûr.
L’expéditeur relève ensuite la clé publique, lance à son tours le programme, il choisit l’option
2 pour crypter avec RSA, entre la clé publique, puis une clé principale de 4 chiffres. Le
programme retourne la clé principale cryptée. Cet utilisateur relance le programme et choisit
maintenant l’option 4 pour crypter en XOR, il choisit ensuite l’option 2 pour taper un texte
directement, il entre la clé principale non cryptée et le programme enregistre le message
crypté dans C:/, il envois ensuite le fichier texte crypter et la clé principale cryptée a son
correspondant.
Le destinataire place le fichier texte dans C:/ et lance le programme, il choisit l’option 2
décrypter avec RSA, entre sa clé privée, puis la clé principale cryptée, il obtient la clé
principale non cryptée, puis il relance le programme choisit l’option 4 puis 1 le programme lit
directement le message crypté, il entre la clé principale et peut enfin lire le message qui aura
été totalement sécurisé.
- Page 18 -
Code Source du Programme :
Le code couleur permet de distinguer les fonctions, en vert entêtes, en rouge texte affiché…
Ce programme a été intégralement et uniquement conçu par les membres de notre groupe à
l’aide du logiciel libre, DEV-C++ de BloodShed.
/*================TPE 2003-2004 Baumont==== KHEMIRI=TAXU=GEORGE============
===========Comment sécuriser un transfert d'information, La Cryptographie=====
=====Code source de notre programme, les annotations sont grisées comme ici====*/
//fichiers d'entêtes déclarant au compilateurs les fonctions que l'ont veut utiliser
#include <math.h>
#include <iostream>
#include <stdlib.h>
#include <string>
#include <iterator>
#include <fstream>
#include <stdio.h>
#include <conio.c>
//gestion des flux d'entrer sortie cin et cout
//pour la gestion de textes
//pour la sauvegarde du fichier
//idem
//purge fflush evite les bugs
//pour Clrsc
using namespace std;
int xorfichied();
int xorentred();
int crypt();
int keygen();
int decrypt();
int xormain();
int pgcd(int a, int b);
//déclarations des différents sous programmes
//l’ordre et les noms n’ont pas d’importance
int main()
// programme principal (menu)
{
int choix;
//déclaration d'un entier qui servira a choisir le menu
clrscr();
//efface l'écran
cout << "\n \t \t ::TPE TS1 LYCEE G.BAUMONT 2003-2004 KHEMIRI-TAXU-GEORGE GROUPE 5::: \n
<< "\n \t TPECRYPT v1 par Khemiri Karim, \n \n \n"
<< "\t Bienvenus dans notre programme de cryptographie \n"
<< "Tapez: \n \t 1 Pour utiliser le generateur de cle RSA \n \t 2 Pour Crypter une Cle
<< "RSA"
<< "\n \t 3 Pour decrypter une cle RSA \n \t 4 Pour acceder au menu de la fonction de
<< "cryptage XOR \n";
cin >> choix;
//ci dessus affichage du message dans la fenetre du
//programme, ici affectation d'une valeur dans l'entier choix par l'utilisateur
switch(choix)
{
case 1 : keygen();
break;
//gestion du menu
case 2 : crypt();
break;
case 3 : decrypt();
break;
- Page 19 -
case 4 : xormain();
break;
}
}
////////////////////////////////////////////////////////////////////////////////
int crypt()
//partie encrypton RSA
{
int n,e;
int motcle;
int clecrypt;
int part = 1;
//déclaration des variables
cout << "CRYPTAGE :: ENTREZ LA CLE PUBLIQUE n,e"; //propose d'entrer la cle publique
cin >> n
//entrée des cles
>> e;
//idem pour le mot
cout << "ENTREZ LE MOT CLE CRYPTER:";
cin >> motcle;
while (e > 0)
//ceci est une boucle while, la
//fonction permet ici de realiser une fonction puissance
{
//on réalise part = motclee
if (e % 2 != 0)
part = part * motcle;
motcle = motcle * motcle;
e = e / 2;
}
//% représente modulo on a bien la fonction
//d'encryption
// crypté = mot^e mod(n)
//affiche le mot crypté
clecrypt = part % n;
cout << clecrypt << endl;
}
//////////////////////////////////////////////////////////////////////////////
//Partie décryptage fonctionne de la meme
//maniere que la precedente
int decrypt()
{
int motcle, clecrypt, n, d, part = 1;
cout << "DECRYPTAGE :: ENTREZ LA CLE PRIVEE n,d";
cin >> n >> d;
cout << "ENTREZ LE MOT CLE A DECRYPTER";
cin >> clecrypt;
while (d > 0)
{
if (d % 2 != 0)
part = part * clecrypt;
clecrypt = clecrypt * clecrypt;
d = d / 2;
}
- Page 20 -
motcle = part % n;
cout << motcle << endl;
}
//////////////////////////////////////////////////////////////////////////////
int xormain()
{
//Partie Menu de la partie XOR
int menu;
//choix du menu idem menu principal
cout << "Veuillez: \n \t Entrer 1 pour Crypter/Décrypter un message a partir d'un fichier
<< "*.txt"
<< "\n \t Entrer 2 pour crypter entrer manuelement un texte a crypter puis
<< "l'enregistrer";
cin >> menu ;
fflush(stdin);
//purge permet de pourvoir utiliser un getline
//apres cin
switch(menu)
{
case 1 : xorfichied();
break;
case 2 : xorentred();
break;
}
}
//////////////////////////////////////////////////////////////////////////////
int xorentred()
{
string mot;
string cle;
cout << "mot?";
getline(cin, mot);
//Partie Xor "manuel"
//declaration des variables "string" gerant du texte
//aquisition de texte
cout << "cle?";
getline(cin, cle);
for(int i=0; i<mot.size(); i=i+4 )
//boucle For permettant de faire un roulement des 4 chiffre
de la clé
{
mot[i] = mot[i] ^ cle[0];
mot[i+1] = mot[i+1] ^ cle[1];
mot[i+2] = mot[i+2] ^ cle[2];
mot[i+3] = mot[i+3] ^ cle[3];
//Fonction XOR
//le symbole ^ permet de realiser la fonction
//Ou exclusif
}
cout << "\n Le message traite est \t" << mot
<< "\n le message est enregistre sous le nom Message.txt a la racine C:/"<< endl;
ofstream f("c:\\Message.txt",ios::binary|ios::out|ios::app); //Enregistrement du fichier
f << mot << "\r\n";
}
///////////////////////////////////////////////////////////////////////////////
int xorfichied()
//Partie XOR "automatique
- Page 21 -
{
string cle;
string mot;
cout << "cle?";
getline(cin, cle);
//ouvre directement le fichier message.txt
//place le contenu de ce fichier dans la
//variable mot
ifstream File("c:/Message.txt");
string Mot = "";
if (File.is_open())
{
getline(File, mot);
File.close();
cout << "Le messssage etait: \t" << mot;
//affichage du mesage initial
for(int j=0; j<mot.size(); j=j+4 )
//fonction XOR idem a la precedente
{
mot[j] = mot[j] ^ cle[0];
mot[j+1] = mot[j+1] ^ cle[1];
mot[j+2] = mot[j+2] ^ cle[2];
mot[j+3] = mot[j+3] ^ cle[3];
}
cout << "\n Le message traite est \t" << mot
//affichage du message codé/décodé
<< "\n le message est enregistre sous le nom Messagetraite.txt a la racine C:/"<< endl;
ofstream f("c:\\Messagetraite.txt",ios::binary|ios::out|ios::app); //enregistre le message
f << mot << "\r\n";
}
else
{
cout << "Impossible d'ouvrir le fichier" << endl; //gestion du message d'erreur si le fichier n'est
pas trouvé
}
}
///////////////////////////////////////////////////////////////////////////////
int keygen()
//partie Generation de Cle
{
int p;
int q;
int verif = 512;
//constante qi permettra de gere l'affichage des messages
cout << "Veuillez entrer les entiers premiers (p;q)";
cin >> p >> q;
if (( p==2) || (p==3))
{cout << "p OK"<< endl;
verif= 32;}
else {
for(int d = 2; (d <= p/2) && (p%d !=0); d++)
//vérification si les nombres son premiers
//ou pas
//par divisions successives
{
if (d == p/2)
{
if (p == 0)
{
cout << "ERREUR \a p n'est pas premier! Veuillez recommencer"<< endl;
}
- Page 22 -
else
{
cout << "p OK"<< endl;
verif= 32;
}
}
}
}
if(verif == 512)
//vérif permet ainsi de ne pas afficher p/2 fois ERREUR
{cout << "ERREUR \a p n'est pas premier! Veuillez recommencer" << endl;}
verif = 512;
if (( q==2) || (q==3))
//Meme procédé pour q
{cout << "q OK"<< endl;
verif= 32;}
else {
for(int d = 2; (d <= q/2) && (q%d !=0); d++)
{
if ( d == q/2)
{
if (q == 0)
{
cout << "ERREUR \a q n'est pas premier! Veuillez recommencer"<< endl;
}
else
{
cout << "q OK"<< endl;
verif= 32;
}
}
}
}
if(verif == 512)
{cout << "ERREUR \a q n'est pas premier! Veuillez recommencer" << endl;}
int n = p*q;
//n produit de p et de q
int e=2;
int valmod = ((p-1)*(q-1));
cout << "n = \t" << n
<< "\n \n Valmod \t" << valmod;
//initialisation de e a 2
//valmod représente (p-1)(q-1)
while(pgcd(e, valmod) != 1)
{
//boucle while, incrémente e de 1
//tant que le pgcd de e et valmod
//est inégal a 1
e++;
}
cout <<"\n e = \t" << e << "\n" << endl;
int d=1;
while((e*d)%valmod != 1%valmod)
//incrémentation de valmode jusqu'a
//ce qu'il remplice la condition
//ed congru a 1 modulo valmod
{
d++;
}
cout << "\n d = \t" << d << "\n" << endl;
cout << " \n \n \t \t :::GENERATION DE CLE TERMINEE::: \n \n"
<< "RECAPITULATIF: \n \n \t"
<< "Cle publique (n,e): (" << n << ", " << e << ") \n \t"
- Page 23 -
<< "Cle privee (n,d): (" << n << ", " << d << ") \n \n"
<< "Vous pouvez maintenant publier votre clee publique dans un annuaire, \n"
<< "et conserver la cle privee a l'abris des regards indiscrets" << endl;
}
////////////////////////////////////////////////////////////////////////////////
//algo de la fonction PGCD
int pgcd(int a,int b)
{
if (b==0) {return a;}
//qui nous permet de vérifier si
//e et valmod son premier entre eux
else {return pgcd(b,a%b);}
}
//================================FIN DU CODE===============================\\
- Page 24 -
Conclusion Générale
La Cryptanalyse et les limites de la cryptographie
Comme montré dans notre historique dans l’introduction, le fait d’avoir des systèmes plus ou
moins sûr ne permet pas d’être totalement étanche aux attaques. Il a toujours existé des
personnes chargées de trouver des failles pour casser des systèmes, que ce soit chez l’ennemis
pour intercepter et rendre intelligible des messages ou chez les personnes utilisant ou créant
un système afin d’évaluer sa sécurité. Analyser un cryptosystème pour casser un code s’appel
la cryptanalyse
Les méthodes les plus fréquentes sont :
• L’analyse de l’algorithme : il faut être bon mathématicien et trouver par quel moyen
on peut remonter jusqu’à la clé de codage
• L’analyse de lettres redondantes : il s’agit d’analyser quelles lettres reviennent le plus
souvent, en double… par exemple trouver une lettre en double équivalente à un l ou t
qui son le plus souvent doublées dans des mots. Les lettres apparaissant souvent
permettent de les identifier, par exemple le E est fréquent alors que le K est rare dans
un texte en Français.
Ce système fonctionne très bien avec des systèmes a clé simple, mais si la clé à
plusieurs caractères il est rendu obsolète a moins de connaître ce nombre de caractères.
• Le Brute Force : cette méthode est longue mais est parfois efficace, il s’agit d’utiliser
un programme testant un grand nombre de clés (système utilisé en dernier recours)
Selon Rivest (un des créateurs du RSA) il faudrait environ 107 millions d'années à
ordinateur équipé d’un processeur à 1Ghz pour retrouver une clé RSA codée de
1024Bits.
• Le Social Engineering (mot à mot Ingénierie Sociale) est un système redoutable qui
peut être très efficace car la complexité d’un algorithme ne l’atteint pas. Il s’agit de
persuader l’ennemi de donner la clé, sans qu’il s’en rende compte, par exemple en se
faisant passer pour un allié, imposture téléphonique… (C’est une méthode souvent
employée pour les piratages de banques)
L’avenir de la Cryptographie ? La cryptographie Quantique :
La cryptographie quantique est un système utilisant la propriété des photons à changer
d’aspect à chaque fois qu’ils sont observés.
Il s’agit d’un envoi de photon (un par un) d’un point de l’expéditeur au destinataire, suivit
d’une étude statistique.
Ce système serait totalement inviolable, et permet de détecter directement toute tentative
d’intrusion.
En 2002 le système aurait été exécuté avec succès par une société suisse, cela représente un
point tournant dans l’histoire de la cryptographie
Ce système pourrait être commercialisé dans quelques mois à un prix avoisinant les 100 000€.
- Page 25 -
Références
Sites Internet et ouvrages ayant servit de référence pour notre dossier :
• www.uqtr.ca/~delisle/Crypto
• www.commentcamarche.com
• www.developpez.com
• www.clubic.com
• www.01net.com
• http://casteyde.christian.free.fr/cpp/cours/online/book1.html
• http://perso.wanadoo.fr/jpq/
• Hors Série Science et Vie Junior de Juillet-Août 2003
• Science Avenir Spécial Cryptographie
- Page 26 -

Conclusion

Transcription

Documents pareils

fiche action n° 15 bellestre internet

Tome 2 : Mathématiques, espionnage et piratage - e

TPE 2004 / 2005 Carnet de bord

rédaction synthèse TPE - Lycée Pierre Mendès France

ANNEXE CONVENTION DE FORMATION DIF LICENCIEMENT

7 recommandations clés pour préserver la sécurité de votre réseau

Synthèse personnelle du TPE

TPE : LA FICHE DE SYNTHESE

TPE – SYNTHESE ECRITE INDIVIDUELLE ET PRESENTATION

Exercices corrigés routage IP - e