RAPPOR FINAL DE PROJET DE DUT INFORMATIQUE :

Un petit SSL
Réalisé sous Eclipse Platform

Développé par : Thomas BENEZET/Nicolas CHARDON

Sous la direction de Mr BAJARD

Année universitaire : 2008/2009

2
3
Sommaire

Introduction

I. Fonctionnement du SSL

1. Aspect global .................................................................................................................... 8

2. Les algorithmes de cryptage ............................................................................................. 9
a. L’échange de clés Diffie Hellman ...................................................................................... 9
b. L’algorithme RSA.............................................................................................................. 10
c. L’algorithme AES .............................................................................................................. 12
d. Le hachage : l’algorithme SHA1 ....................................................................................... 14
II. Recherche

1. Objectifs ........................................................................................................................... 15
2. Langage ............................................................................................................................ 16
3. Librairies ........................................................................................................................... 16
4. Outil.................................................................................................................................. 16
5. Cahier des charges ........................................................................................................... 16
III. Analyse

1. Diagramme de classe du SSL ............................................................................................ 18

2. Use-Case du SSL ............................................................................................................... 18
3. Les diagrammes de séquence du SSL ............................................................................... 19
4. Les diagrammes de séquences des cas d’exceptions....................................................... 22
IV. Développement

1. Authentification : Diffie Hellman ..................................................................................... 23

2. Confidentialité : RSA et AES .............................................................................................. 23
3. Intégrité : SHA1 ................................................................................................................ 25
4. Développer l’interface ..................................................................................................... 28
5. Problèmes rencontrés ...................................................................................................... 30
Conclusion

4
Table des figures

(Figure 1) Schéma global SSL ...........................................................9

(Figure 2) Aperçu RSA ....................................................................11

(Figure 3) AES taille de clé ..............................................................12

(Figure 4) AES subByte() ................................................................13

(Figure 5) AES shiftRow() ...............................................................13

(Figure 6) AES addRoundKey() ........................................................14

(Figure 7) Diagramme de classe SSL ...............................................18

(Figure 8) Diagramme Use Case ................................................. ....18

(Figure 9) Diagramme de séquence cas nominal : Connexion .............19

(Figure 10) Diagramme de séquence cas nominal : Déconnexion .........20

(Figure 11) Diagramme de séquence cas nominal : Envoi message ......20

(Figure 12) Diagramme de séquence cas nominal : envoie sécurisé ......21

(Figure 13) Diagramme de séquence cas d’exception : connexion .........22

(Figure 14) Diagramme de séquence cas d’exception : authentification .22

(Figure 15) Aperçu fenêtre client et fenêtre serveur ............................29

(Figure 16) Aperçu fenêtre client et fenêtre serveur ............................29

5
Remerciements

Nous tenons tout d’abord à remercier monsieur Mr Bajard, pour la

proposition du sujet de notre projet, et pour ses indications lors de nos
réunions.

Nous remercions aussi Mme Boya pour ses indications fournis lors de
notre entretient durant la semaine au ski, qui nous as beaucoup aidé.

6
 Introduction
Afin de parfaire notre apprentissage et d’appliquer les différentes
notions enseignées, nous devons choisir et mener a bien un projet
informatique durant le 3ème semestre de notre DUT. Ceci nous permet
d’une part d’appliquer les connaissances acquises, et d’autres part
d’avoir une expérience se rapprochant du domaine professionnel où il
nous sera demandé de gérer un travail de groupe, sur une durée
déterminée.

Le projet que nous devions réaliser correspond à un protocole de

sécurisation des échanges appelé SSL (Secure Sockets Layers, que l'on
pourrait traduire par couche de sockets sécurisée). Ce système est un
procédé de sécurisation des transactions effectuées via Internet. Le
standard SSL a été mis au point par Netscape, en collaboration avec
Mastercard, Bank of America, MCI et Silicon Graphics. Il repose sur un
procédé de cryptographie par clef publique afin de garantir la sécurité
de la transmission de données sur internet. Son principe consiste à
établir un canal de communication sécurisé (chiffré) entre deux
machines (un client et un serveur) après une étape d'authentification.

Tout d'abord, nous présenterons le cadre général de notre projet.

Puis dans une seconde partie, nous définirons le cahier des charges.
Ensuite nous expliquerons comment nous avons développé ce
programme. Enfin, dans la dernière partie, nous discutons de la
concordance de nos résultats avec nos objectifs initiaux.

7
I. Fonctionnement du SSL
1. Aspect global

L’objectif de SSL est de vérifier l’identité des parties impliquées dans une
transaction sécurisée et de s’assurer que les données échangées sont
protégées de toute interception ou modification. Les principales fonctions
assurées par SSL sont décrites ci-dessous.

 Authentification : Elle a lieu à l’ouverture de la session. Elle

emploie pour cela le passage par un algorithme d’authentification
basé sur un échange de Diffie Hellman. Cela permet au client de
s’assurer de l’identité du serveur avant tout échange de données.
Dans la version actuelle de SSL l’authentification du client reste
facultative.

 Confidentialité : Elle est assurée par des algorithmes de

chiffrement symétriques. Bien que le même algorithme soit utilisé
par les deux parties chacune possède sa propre clé secrète qu’elle
partage avec l’autre. Il existe deux algorithmes utilisé : le premier à
clés asymétriques RSA et le second à clés symétriques AES.

 Intégrité : Elle est assurée par l’application d’un algorithme de

hachage aux données (SHA1) transmises. L’algorithme génère à
partir des données et d’une clé secrète appelée code
d’authentification de message, une suite de bits codés. Cette suite
sert de signature pour les données. Ainsi tout changement appliqué
aux données implique un changement de la suite de bits générée
par l’algorithme de hachage et en conséquence provoquera la
génération d’un message d’erreur côté récepteur du fait que les
deux suites sont différentes.

8
  Schéma global du SSL :

(Figure 1) Schéma global SSL

2. Les algorithmes de cryptage

a. L’échange de clés Diffie Hellman

Cet algorithme est un algorithme de chiffrement développé par les

américains Whitfield Diffie et Martin Hellman utilisant une paire de clefs,
l'une publique et l'autre privée.

Cette algorithme est très simple pour l'échange des clefs et le voici décrit:
Soient 2 personnes A et B désirant communiquer sans utiliser une clef
secrète. Pour cela ils se mettent d'accord sur 2 nombres g et n tels que n
soit supérieur à g et g supérieur à 1, et cela sur un canal non sécurisé (il
faut que n soit grand: de l'ordre de 512 ou 1024 bits pour que l'échange
des clefs soit sécurisé). Ils prennent chacun chez eux un nombre
aléatoire:

-A choisit x, calcule X=g^x mod n et l'envoie à B.

-B choisit y, calcule Y=g^y mod n et l'envoie à A.

Ainsi le pirate peut intercepter X, et Y mais il lui est très difficile d'en

9
déduire x et y (c'est sur ce principe que repose la sécurité de
l'algorithme).

Une fois dans son coin, A calcule k=Y^x mod n et B calcule k'=X^y mod
n.

Si l'on regarde de plus près on voie quelque chose de très intéressant:

k=k'=g^xy mod n. Ainsi, A et B ont réussi à créer une clef privée dont ils
sont les seuls détenteurs et le pirate malgré la vision qu'il a eut de
l'échange ne peut calculer la clef privée. L'échange des clefs ayant
fonctionné A et B peuvent communiquer. C’est sur ce principe de calcul
que l’authentification repose.

b. L’algorithme RSA

La méthode de cryptographie RSA a été inventée en 1977 par Ron Rivest,

Adi Shamir et Len Adleman, à la suite de la découverte de la
cryptographie à clé publique par Diffie et Hellman. Le RSA est encore le
système cryptographique à clé publique le plus utilisé de nos jours. Il est
intéressant de remarquer que son invention est fortuite : au départ,
Rivest, Shamir et Adleman voulaient prouver que tout système à clé
publique possède une faille.

Principe de fonctionnement : Si A souhaite recevoir des messages en

utilisant le RSA, il procède de la façon suivante :

1. Création des clés :

A crée 4 nombres p, q, e et d :

o p et q sont deux grands nombres premiers distincts. Leur

génération se fait au hasard, en utilisant un algorithme de test
de primalité probabiliste.
o e est un entier premier avec le produit (p-1)(q-1).
o d est tel que e*d=1 modulo (p-1)(q-1). Autrement dit, e*d-1
est un multiple de (p-1)(q-1).

10
2. Distribution des clés :

Le couple (n,e) constitue la clé publique de A. Il la rend disponible

par exemple en la mettant dans un annuaire. Le couple (n,d)
constitue sa clé privée. Il la garde secrète.

3. Envoi du message codé :

B veut envoyer un message codé à A. Elle le représente sous la

forme d'un ou plusieurs entiers M compris entre 0 et n-1. B possède
la clé publique (n,e) de A. Elle calcule C=Me mod n. C'est ce dernier
nombre qu'elle envoie à A.

4. Réception du message codé :

A reçoit C, et il calcule grâce à sa clé privée D=Cd (mod n). D'après

un théorème du mathématicien Euler, D=Mde=M (mod n). Il a donc
reconstitué le message initial.

5. Représentation

Les différentes données utiles lors de l’utilisation sont stockées de

cette manière (pour des clés de 128 bits) :

(Figure 2) Aperçu RSA

11
 c. L’algorithme AES

AES est un algorithme de chiffrement symétrique. Son fonctionnement est

simple. Il découpe les messages en tableau d’octet et effectuer plusieurs
transformations. Le résultat est alors un bloc crypté.
Il existe 3 types d’AES : 128, 192, 256 définissants la longueur de la clé.
La longueur de cette clé à une influence sur le nombre de tour de boucle a
effectué et la taille des blocs.

(Figure 3) AES taille de clé

Voici la liste des transformations réalisées. Ces transformations sont

réalisées selon l’algorithme suivant.

 Expansion de la clé secrète : keyExpansion ()

Cette opération consiste à construire à partir de la clé secrète un
gestionnaire de clé (une matrice) qui sera utilisé plus tard lors de la
fabrication de la clé de tour par la fonction addRoundKey ().

12
  Transformation non linéaire d'octets : subBytes
()
L’opération subByte () effectue une substitution d’octet utilisant une table
S-Box. On substitue chaque octet ci du bloc courant avec l’octet contenu
dans la S-Box indexé par les 4bits de poids fort et les 4bits de poids faible
de ci.
La S-Box étant une table constante.

(Figure 4) AES subByte()

 Décalage de lignes : shiftRow ()

Les 3 dernières lignes du bloc courant sont décalées cycliquement

vers la gauche : la 2ème ligne est décalée d'une colonne, la 3ème
ligne de 2 colonnes, et la 4ème ligne de 3 colonnes.

(Figure 5) AES shiftRow()

13
  Brouillage des colonnes : mixColumns ()

Chaque colonne est transformée par combinaisons linéaires des

différents éléments de la colonne (ce qui revient à multiplier la
matrice 4×4 par une autre matrice 4×4).

 Addition de la clé de tour

A chaque tour, une clé de tour est additionnée au bloc courant.

Cette clé est issue de la matrice générée lors de l’expansion de la
clé. L’addition se fait par un ou exclusif.

(Figure 6) AES addRoundKey()

d. Le hachage : l’algorithme SHA1

SHA-1 (Secure Hash Algorithm) est une fonction de hachage

cryptographique conçue par la National Security Agency des États-Unis
(NSA), et publiée par le gouvernement des États-Unis comme un standard
fédéral de traitement de l'information (Federal Information Processing
Standard du National Institute of Standards and Technology (NIST)). Elle
produit un résultat (appelé « hash » ou condensat) de 160 bits. Ce
condensat sert de signature aux messages envoyés.

Fonctionnement :

L’algorithme SHA-1 peut se découper en deux parties :

 Une phase de prétraitement.

14
  Une phase de calcul du condensat

 Le prétraitement

Il faut d’abord compléter le message pour qu’il ait une taille compatible
avec les spécifications de l’algorithme SHA-1, soit un multiple de 512 bits.
Il faut ensuite découper le message en bloc de 512 bits. Enfin il faut
initialiser les variables de travail.

 Le calcul de haché

On découpe d’abord un bloc de 512bits en mots de 32bits. Puis on utilise

chacun de ces mots, aux travers de diverses transformations, pour
calculer des valeurs de hachage.
Le condensat s’obtient en répétant l’opération pour tous les blocs
constituant le message et en sommant à chaque fois les valeurs de
hachages.

II. Recherche
1. Objectifs
L’objectif de notre projet est d’implémenter une connexion client serveur
en utilisé un flux de donnée sécurisé par le système SSL.

Tout d’abord nous nous attelé à bien comprendre l’aspect mathématiques

des différents algorithmes de cryptographie mis en place dans le SSL. Puis
dans un second temps développé une interface valide pour ce type
d’échange.

Cette interface se décrira en deux taches principales. Dans un premier

temps sera développée une application client serveur sous-forme de chat
ou un nombre indéfini de d’utilisateur pourra se connecté au chat et
discuter entre eux. A ceci viendra s’ajouter un système de discussion
privée mis en place entre deux utilisateurs ou les deux clients pourront
choisir d’envoyer des données selon un échange sécurisé SSL.

Et enfin nous avons du toujours réfléchir au problème de sécurité des

données dans les différents algorithmes de l’application.

15
 2. Langage
Le langage qui a été utilisé pour le développement de cette application est
le JAVA car il nous a été imposé. Ce langage n’est pas le mieux adapté
pour les opérations sur les octets, mais il nous a permis d’implémenté très
facilement notre interface client-serveur.

3. Librairies
Les librairies utilisées sont les librairies de base de Java. Plus précisément
Swing et Awt pour l’interface, Net et Utils pour la connexion client serveur,
Io pour les exceptions d’erreur et les flux de données et enfin Math et
Security pour le SSL.

4. Outil
Pour le développement, nous avons utilisé la plateforme Eclipse, open-
source et gratuit.

5. Cahier des charges

 Le client pourra :

o Choisir son pseudo

o Se connecter au serveur
o Parler avec les autres connectés sur le chat public.
o Parler avec un des clients connectés en privée.
o Lors d’une conversation privée, envoyer des données sécurisées
par SSL
o Lors d’une conversation privée, envoyer des données non
sécurisé

 L’interface graphique comprendra :

 Une interface client:

 Un champ d’affichage de l’adresse IP du client connecté.

 Un champ de saisie pour le pseudo.

 Un bouton de connexion au serveur.

 Un bouton de déconnexion au serveur.

16
  Une zone d’affichage de la conversation publique du
chat.

 Une zone d’affichage de la liste des connectés au chat

 Un champ de saisie de texte pour les messages à

envoyer

 Une interface serveur :

Une table correspondant à la liste des connectés au serveur. Celle-ci

est composé de 30 ligne et de 3 colonnes ou sont affichés les
informations permettant d’identifier un client :

 Adresse

 Pseudo

 Forum

17
III. Analyse
1. Diagramme de classe du SSL

(Figure 7) Diagramme de classe SSL

2. Use-Case du SSL

(Figure 8)Diagramme Use Case

18
 3. Les diagrammes de séquence du SSL
 Connexion au serveur

On choisit que lorsque le client se connecte au serveur, il soit

immédiatement enregistré dans une table avec sa clé publique RSA
pour éviter que le client ai à renvoyer sa clé publique à chaque
demande d’envoi sécurisé.

(Figure 9) Diagramme de séquence cas nominal : Connexion

19
  Déconnexion au server

Le client clique sur le bouton de déconnexion ou ferme la fenêtre et il est

automatiquement déconnecté.

(Figure 10) Diagramme de séquence cas nominal : Déconnexion

 Parler sur le chat public

Cela correspond à écrire un message qui sera affiché dans la zone

publique et donc visible par tous.

(Figure 11) Diagramme de séquence cas nominal : Envoi message

20
  Envoi de sécurisé de données sécurisé SSL

(Figure 12) Diagramme de séquence cas nominal : envoie sécurisé

21
 4. Les diagrammes de séquences des cas d’exceptions

 Erreur lors de la connexion

(Figure 13) Diagramme de séquence cas d’exception : connexion

 Erreur lors de l’envoi de données sécurisée au serveur

(Figure 14) Diagramme de séquence cas d’exception : authentification

22
IV. Développement
Nous avons choisit dans la partie développement de ne pas mettre de
source car le code est très lourd. Nous allons donc entreprendre une
explication basé sur le coté programmation de ces algorithme.

1. Authentification : Diffie Hellman

Nous avons choisit d’utilisé la classe BigInteger qui correspond à la classe

permettant de définir les gros entier de type cryptogramme. Il détient
différentes fonctions très utile dans notre algorithme. Dans un premier
temps on trouve la fonction probablePrime() permettant de générer
aléatoirement de grand nombre premier, puis dans un second temps une
autre fonction modPow(int A, int B).

Tout d’abord on génère deux nombres communs au deux partie

aléatoirement à l’aide du probablePrime() de cette classe puis on utilise
modPow(A,B) pour construire le nombre que vont s’envoyé chacun des
deux utilisateurs. Chacun dans leur coin les deux parties vont effectuer
un nouveau modPow(A,B) sur la valeur d’arrivé donc déduire un résultat.
Si les deux parties ont le même résultat c’est que l’authentification est
réussit.

2. Confidentialité : RSA et AES

 Le cryptage RSA

De manière général un utilisateur qui souhaiterait crypter son message

avec RSA doit d’abord faire savoir à son intention. Ensuite si cet
interlocuteur accepte, il faut qu’il envoi sa clé publique au demandeur.
Une fois la clé publique de l’interlocuteur en main on code notre message
avec celle-ci et on lui renvoi le message codé. Et lui peut donc décodé le
message à l’aide de sa clé privée et de sa constante construite au
préalable.

L’algorithme RSA est basé sur la génération aléatoire de nombre premier,

la création de clés à partir des nombres générés, et enfin du cryptage et
du décryptage du message.

23
  La génération des clés

Tout d’abord il faut générer la clé publique car c’est elle et un autre
paramètre qui va nous permettre de créer la clé privée. Pour cela on doit
générer deux nombre premier (p et q) à l’aide de probablePrime() puis
ensuite construire deux autre constantes tel que ( phi = (p-1)*(q-1) et
n=p*q). Ensuite on doit générer un nombre premier tel qu’il ne doit avoir
aucun facteur en commun avec phi. Ce chiffre constituera la clé publique
du RSA. Pour trouver la clé publique on doit trouver un nombre tels que
ed mod phi=1 ce qui revient à faire d= e mod-1phi.
public BigInteger generer_clé_publique (BigInteger p,BigInteger q){
BigInteger e = BigInteger.probablePrime(1000,sr);
while (p.compareTo(e)==-1 && q.compareTo(e)==1) {
e = BigInteger.probablePrime(1000,sr);
}
return e;
}

public void generer_cles() {

//détermination des constante de construction des clés
BigInteger p = BigInteger.probablePrime(1000,sr);
BigInteger q = BigInteger.probablePrime(1000,sr);
BigInteger phi = (p.subtract(un)).multiply(q.subtract(un));
this.n = p.multiply(q);

//Génération de la clé publique

this.clé_publique = generer_clé_publique(p,q);
//Génération de la clé privée
this.cle_privee = clé_publique.modInverse(phi);
}

Le cryptage et le décryptage

Le cryptage se fait en effectuant messageclé_publiquemod n donc grâce à

la clé publique et le décryptage se fait grâce à la clé privée en
faisant message_cryptéclé_privée mod n.
public BigInteger cryptage(BigInteger message) {
return message.modPow(this.clé_publique,n);
}

public BigInteger decryptage(BigInteger crypt) {

return crypt.modPow(this.cle_privee,n);

 Le cryptage AES

24
L’analyse mathématique ayant était bien réalisé nous n’avions plu qu’a
implémenté les différentes fonctions à exécuter et à les inclure dans une
boucle d’un nombre de tour défini par la taille de la clé.

Les différentes méthodes à implémentées était :

o La transformation SubBytes()

o La transformation ShiftRows()

o La transformation MixColumns()

o La transformation AddRoundKey()

o Gestion de la clé KeyExpansion()

3. Intégrité : SHA1
 Le remplissage :

Il s'agit ici d'ajouter des informations au message pour qu'il soit d'une
taille multiple de 512 bits.
Pour ce faire, on ajoute un bit "1" à la fin du message M, puis k zéros, où
k est la plus petite solution non négative de l'équation: l + 1 + k = 448
mod 512 où l est la taille en bit du message.
On ajoute alors un bloc de 64 bits correspondant à la représentation
binaire l.
Le tout est rangé dans un tableau d’octet.

 Le découpage :

Le message une fois complété est ensuite découpé en N blocs de 512bits.

Le tout est rangé dans 512/64*N tableaux de 32bits (ou 4 octets).

 L’initialisation des variables de travail :

Chaque haché est initialisé 0 une valeur constante de départ.

private int h0 = 0x6a09e667;
private int h1 = 0xbb67ae85;
private int h2 = 0x3c6ef372;
private int h3 = 0xa54ff53a;
private int h4 = 0x510e527f;
private int h5 = 0x9b05688c;

25
private int h6 = 0x1f83d9ab;
private int h7 = 0x5be0cd19;

0x désignant une écriture hexadécimale.

h0 = (6a09e667)16
h0 = (0110 1010 0000 1001 1101 0110 0110 0111)2
h0 = (1779029607)10

 Calcul du haché

Fonction utilisé :

 Ft(x,y,z) est fonction logique utilisant 3 mots de 32bits

Elle dépend de t qui est l’indice de boucle représentant le numéro

du mot en cour de traitement.

 ROTR n(x) // effectue un décalage circulaire à droite de n bits

sur le mot x.

ROTR n(x) = (x >> n) (x << w - n).

 Détail de l’algorithme

a, b, c, ..., h = variables de travail utilisées dans le calcul des hachés.

H(i) = la valeur de hachage n°i.

= le mot (w bits) n°j de la valeur de hachage n°i.

Kt = constantes itératives selon la valeur de t, utilisées dans le calcul de

hachage

26
M(i) = bloc n°i (m bits), du message M

= mot (w bits) n°j, du bloc (m bits) n°i, du message M

n = nombre de bits de décalage ou de rotation à appliquer au mot quand
associé à une fonction binaire
N = nombre de blocs de m bits contenus dans le message M après
complément
T = variable temporaire, mot de w bits, utilisée dans le calcul de condensé
w = nombre de bits contenus dans un mot, soit 32 bits.
Wt = le mot n°t du tableau déduit du message

Pour i = 1 à N
{

1. On remplit le tableau , selon

Wt = Mt 0 t 15
OU
Wt = ROTL1 (W t-3  W t-8 W t-14  W t-16) 16 t 79

2. On initialise a,b, c, d et e avec les valeurs de hachage du tour

précédent

3. Pour t = 0 à 79
{
( notée ci-après est la fonction logique, décrite plus haut)

}
4. Calcul des valeurs de hachage intermédiaires

27
 4. Développer l’interface

Pour développer l’interface nous avons choisit un chat comprenant une

zone privée et un zone publique. C’est en cliquant sur le nom d’un
connecté que le demandeur pourra établir une connexion privée avec
celui-ci et c’est alors que une des deux personne en communication privée
pourra envoyer des données en mode sécurisé SSL.

 Le client/serveur
Nous avons donc du dans un premier temps établir une connexion multi-
client/serveur cohérente, pour que les différents clients puissent discuter
entre eux. Pour cela, le serveur récupère un message posté dans la boite
au lettre par un client et le redistribue à tout les autres sous forme de
chaine de caractère composé du nom de l’expéditeur et du message
(thomas dit : message). Puis dans un second temps concevoir l’a
connexion privée car lorsque un utilisateur demande une connexion privée
le serveur crée un nouvelle tache spécifique entre les deux clients
concernés permettant d’exclure complètement les autres utilisateurs de
cette conversation.

 L’interface graphique
Les interfaces graphiques client et serveur devaient présentées certains
composants obligatoires. Pour cela nous avons du utilisé des classes
contenu dans les librairies java Awt et Swing tels que les JFrame, JPanel ,
JButton, JList, JTextArea, JTextField et JCheckBox.Ces composant
graphique ont été placé sur la frame à l’aide d’un BorderLayout
permettant de placer les composant sur la page en fonction d’un attribut
de placement (South, North, east, west).

28
(Figure 15 et 16) Aperçu fenêtre client et fenêtre serveur

29
 5. Problèmes rencontrés
Les différents problèmes que nous avons rencontrés sont :

 Les transformations sur les bits dans AES

 La génération des clés, le cryptage et le décryptage dans

RSA

 Le découpage du message en bloc de 512 bits dans

SHA1

 La concordance de l’utilisation de ces classes dans

l’application

 Comprendre l’algorithme d’authentification

 La sécurité de l’algorithme

30
Conclusion
Pour conclure, nous pouvons dire que la réalisation de ce projet nous
appris beaucoup de choses sur les problèmes de sécurité informatique, de
sécurité des données ainsi que sur l’échange de données sensible via une
communication client/serveur. Nous avons dut apprendre comment
résoudre ces problèmes et apporter des solutions fonctionnelles.

En termes de programmation nous avons aussi beaucoup appris sur les

systèmes client/serveur, avec notamment l’utilisation de protocole de
communication. Nous avons aussi appris à effectuer des manipulations
d’octets et à réaliser des opérations binaires sur ces octets en utilisant
l’algèbre de Boole.

Enfin ce projet nous a permis d’appliquer les connaissances qui nous ont
été inculquées au cours de ces deux années de DUT Informatique à l’IUT
de Montpellier. Nous avons été confrontés à de nombreux problèmes nous
forçant à trouver des solutions alternatives afin de les résoudre. Enfin ce
projet aura été l’occasion de nous faire tester et utiliser pleinement les
compétences acquises au cours de ces deux années.

31
 Références
 SSL :
o http://fr.wikipedia.org/wiki/Secure_Socket_Layer

 Java :
o http://java.developpez.com/faq/java/
o « La programmation objet en Java » par Michel Divay aux éditions
Dunod
 AES :
o http://csrc.nist.gov/publications/fips/fips197/fips-197.pdf
o http://dra13-1-82-229-12-
107.fbx.proxad.net/telechargements/fgc/annexes/fgc_annexe_1.
pdf
o http://crypto.freezee.org/aes/aes_report.html
 SHA1 :
o http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf
o http://fr.wikipedia.org/wiki/Sp%C3%A9cifications_SHA-256
 RSA :
o http://www.dma.ens.fr/culturemath/maths/pdf/nombres/RSA.pdf
o http://sebsauvage.net/comprendre/encryptage/crypto_rsa.html
 Diffie Hellman :
o http://mantis.free.fr/articles/diffie.htm
o http://en.wikipedia.org/wiki/Diffie-Hellman

32
Glossaire
 Mots : Ensemble de 4 octets rangés dans un tableau.

 Corps : En mathématiques, et plus précisément en algèbre, un corps est

une structure algébrique. De manière informelle, un corps est un ensemble dans lequel il est
possible d'effectuer des additions, des soustractions, des multiplications et des divisions.

 Anneau : On appelle anneau tout triplet constitué d'un ensemble non vide
et de deux lois de compositions internes et sur G qui vérifient :

 est un groupe commutatif;

 est associative ;
 admet un élément neutre dans ;
 distributive par rapport à quels que soient , , et , on la relation

33
Résumé
Dans ce dossier nous cherchons à expliquer le fonctionnement d’un
système sécurisé d’envoi de donnée de type SSL en détaillant clairement
les différents processus utilisé dans une telle cryptographie. Tout d’abord
nous expliquons indépendamment chacun des algorithmes de cryptage en
nous penchant sur leur aspect mathématique ,pour ensuite nous pencher
plus précisément sur l’analyse de type UML et le développement de
l’application et sur la mise en place de l’envoi sécurisé. Ce développement
est divisé en deux points : la création de l’algorithme de cryptage et la
conception de l’interface utilisateur permettant son utilisation. Enfin nous
proposons une solution d’application simple mettant en place ce type
d’échange.

Resume
In this case we seek to explain how a secure system for sending data type
SSL clearly detailing the various processes used in such as cryptography.
First we explain each regardless of encryption algorithms in focusing on
their mathematical aspect, and then turn our attention more specifically
on the type UML analysis and development of application and on the
establishment of the consignment Secure. This development is divided
into two areas: the creation of the encryption algorithm and user interface
design for use. Finally we propose a simple solution for setting up such
exchanges.

34