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. III. IV. Recherche 1. Objectifs ........................................................................................................................... 15 2. Langage ............................................................................................................................ 16 3. Librairies ........................................................................................................................... 16 4. Outil.................................................................................................................................. 16 5. Cahier des charges ........................................................................................................... 16 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 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 o 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. e est un entier premier avec le produit (p-1)(q-1). 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, opensource et gratuit. 5. Cahier des charges Le client pourra : Choisir son pseudo Se connecter au serveur Parler avec les autres connectés sur le chat public. Parler avec un des clients connectés en privée. 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é o o o o o 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 Wt = Mt , selon 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 multiclient/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-12107.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