Soutenance mémoire
Structure du chiffrement par bloc
Un algorithme de chiffrement par bloc est divisé en deux parties : le générateur de clés (key schedule) et le chemin de données (figure 1.5). Le chemin de données inclut deux opérations de base introduites par Shannon [8] qui sont la confusion (c’est-à-dire rendre la relation entre la clé et le texte chiffré le plus complexe possible) et la diffusion (c’est-à-dire permettre à chaque bit de texte clair d’avoir une influence sur une grande partie du texte chiffré). Ce chemin de données est le plus souvent composé d’une fonction (ou un ensemble de fonctions) appelée un tour (round) qui se répète un nombre fixe de fois. Il prend le texte en clair en entrée, et délivre en sortie le texte chiffré après le nombre fixe de tours. Le générateur de clés traite une clé secrète et en déduit les sous-clés de tours utilisées à chaque tour du chemin de données. La dérivation de la clé est nécessaire pour ajouter de la confusion : elle augmente la dépendance de chaque bit du texte chiffré sur tous les bits de la clé secrète. Le premier tour du chemin de données prend le texte en clair et la clé du premier tour comme entrées, puis les tours suivants prennent la sortie du tour précédent et la clé du tour correspondant comme entrées.
Chiffrement asymétrique
Contrairement aux algorithmes de chiffrement symétriques, les algorithmes de chiffrement asymétrique utilisent deux clés différentes : la clé de chiffrement Ke, appelée clé publique car elle peut être transmise sur un canal non sécurisé et ne nécessite pas d’être gardée secrète, et la clé de déchiffrement Kd, appelée clé privée puisque qu’elle permet le déchiffrement et donc ne doit être connue que du destinataire du message chiffré (figure 1.2). La notion du chiffrement asymétrique (ou cryptosystème à clé publique) a été introduite par Wilfred Diffie et Martin Hellman en 1976 [14]. Ces algorithmes sont basés sur la difficulté à résoudre certains problèmes mathématiques complexes et en particulier sur des fonctions à sens unique à trappe. Une fonction f(x) = y est considérée comme une fonction à sens unique si pour tout x appartenant à l’ensemble de définition de la fonction, il est simple de calculer f(x), alors qu’en pratique, connaissant y, il est difficile de trouver x tel que y = f(x) sans connaître une information supplémentaire : la trappe (secret). Un exemple de problème mathématique complexe utilisé est la factorisation de grands nombres : il est facile de calculer la multiplication de deux grands nombres, mais la fonction inverse, la factorisation est très difficile. L’algorithme à clé publique le plus célèbre est RSA [15] (pour Rivest Shamir Adleman, les noms de ses inventeurs). Il est basée sur ce problème de factorisation. Le principal avantage du chiffrement asymétrique par rapport au chiffrement symétrique est le fait qu’il n’a pas besoin de partager un secret avant d’établir la communication, la clé de chiffrement pouvant être publique. Néanmoins, il est nécessaire d’assurer l’authenticité de cette clé de chiffrement sinon une attaque de l’homme du milieu (man-in-the-middle) est réalisable. Dans une telle attaque, un adversaire qui surveille un canal non sécurisé, intercepte un message (M) et éventuellement certaines données (X) utiles à des fins de sécurité, les analyse et les échange par des données choisies (M0 , X0).
Sécurité des techniques de chiffrement
Les attaques menées contre un système de chiffrement peuvent avoir deux objectifs : la récupération de clé ou du message en clair. L’objectif de la première attaque est de récupérer la clé secrète ou la clé privée utilisée respectivement dans un algorithme de chiffrement symétrique ou dans un chiffrement asymétrique. L’attaque la plus pratique est l’attaque par force brute. Elle consiste à essayer toutes les clés possibles jusqu’à trouver la bonne clé permettant de récupérer le texte en clair à partir de n’importe quel texte chiffré. Par conséquent, plus la taille de la clé est longue, plus la complexité de cette attaque est grande. Le but des attaques de récupération de message est d’obtenir des informations sur les textes clairs en observant les textes chiffrés. Un cryptosystème est à l’abri contre la récupération du message s’il est sémantiquement sécurisé, ce qui signifie qu’un adversaire n’est pas en mesure de savoir si un texte chiffré donné est le chiffrement d’un texte clair ou d’un autre. Les objectifs de l’adversaire, définis plus haut, sont pratiquement basés sur les attaques passives qui pourraient être classées en considérant les informations dont l’adversaire dispose. Les définitions suivantes sont issues de [4] :
1. Attaque par texte chiffré seul (ciphertext-only attack) : l’attaquant ne dispose que de messages chiffrés.
2. Attaque par texte clair connu (known-plaintext attack) : l’attaquant dispose d’une série de messages clairs et des chiffrés correspondants.
3. Attaque par texte clair choisi (chosen-plaintext attack) : l’attaquant peut obtenir les chiffrés des messages en clair qu’il veut.
4. Attaque par texte clair choisi adaptative (adaptative chosen-plaintext attack) : identique à une attaque par texte clair choisi sauf que le choix des textes clairs par l’attaquant peut dépendre des textes chiffrés reçus précédemment.
5. Attaque par texte chiffré choisi (chosen-ciphertext attack) : l’attaquant a accès à une machine de déchiffrement. Il peut obtenir les messages en clair correspondants aux messages chiffrés qu’il veut (excepté le message qu’il essaie de déchiffrer).
6. Attaque par texte chiffré choisi adaptative (adaptative chosen ciphertext attack) : identique à une attaque par texte chiffré choisi sauf que le choix des messages chiffrés soumis à l’oracle de déchiffrement par l’attaquant peut dépendre des messages en clair qu’il a reçus précédemment. La robustesse d’un système de chiffrement est évaluée en respectant le premier et le deuxième principe de Kerckhoffs qui indiquent qu’un algorithme doit être incassable en pratique (sinon en théorie est incassable) et qu’il doit être connu du public. Bien utilisé, le chiffrement permet de garantir la confidentialité d’informations contre des attaques passives. Néanmoins, le chiffrement seul ne peut pas garantir l’intégrité et l’authentification des données. Il est donc insuffisant dès que l’adversaire est en mesure d’altérer les messages, notamment via des attaques actives.
Méthodes de protection contre l’attaque par injection
Pour protéger l’intégrité d’une donnée, il est nécessaire de stocker une information supplémentaire permettant de s’assurer que la donnée n’a pas été modifiée. Le condensé cryptographique est un choix naturel : il est facile à calculer et il prend moins de place que la donnée initiale. Néanmoins, les fonctions de hachage sont publiques. Il ne servirait donc à rien de stocker les condensés dans la mémoire non fiable : si un adversaire désire remplacer dans la mémoire une donnée par une autre, il peut librement calculer le nouveau condensé et le substituer également à celui de la donnée manipulée. L’attaque ce sera pas détectée. Par conséquent, la protection d’intégrité avec les fonctions de hachage nécessite le stockage des condensés à l’intérieur de la zone fiable (SoC) dans une mémoire locale (figure 2.6). Ainsi, si un attaquant veut modifier une donnée D0, comme il ne peut plus modifier hash0 = H(D0),il doit trouver D00 6= D0 tel que H(D00) = hash0 = H(D0), c’est-à-dire casser la propriété de résistance à la seconde préimage de la fonction de hachage. Pour chaque opération d’écriture, le hash calculé sur un groupe de données cible est mis à jour dans la mémoire locale du SoC. La vérification d’intégrité (pendant les opérations de lecture) est effectuée en calculant le hash du groupe de données cible et le comparant avec le hash stocké dans la mémoire locale. Cette solution de stockage interne n’est malheureusement pas extensible du fait de la taille nécessairement limitée de la mémoire locale du SoC utilisée pour stocker les condensés. Elle n’est applicable que dans les situations où la taille de la zone mémoire à protéger est limitée et connue lors de la conception du SoC.
|
Table des matières
Remerciements
Introduction
1 Éléments de cryptographie
1.1 Définitions
1.2 Techniques de chiffrement
1.2.1 Chiffrement symétrique
1.2.1.1 Chiffrement de flux
1.2.1.1.1 Masque jetable (One Time Pad, OTP)
1.2.1.1.2 Chiffrement de flux synchrone
1.2.1.1.3 Chiffrement de flux auto-synchrone
1.2.1.2 Chiffrement par bloc
1.2.1.2.1 Structure du chiffrement par bloc
1.2.1.2.2 Exemple : AES
1.2.1.2.3 Modes d’opération
Electronic CodeBook (ECB)
Cipher-Block Chaining (CBC)
Cipher FeedBack (CFB)
Output FeedBack (OFB)
Mode compteur
1.2.1.3 Conclusion
1.2.2 Chiffrement asymétrique
1.2.3 Sécurité des techniques de chiffrement
1.3 Techniques de vérification d’intégrité
1.3.1 Fonctions de hachage
1.3.1.1 Code de détection de modification
1.3.1.1.1 Exemple : SHA
1.3.1.2 Code d’authentification de message
1.3.1.2.1 Exemple : CBC-MAC
1.3.2 Paradoxe des anniversaires
1.3.3 Conclusion
2 Panorama des techniques de protection
2.1 Modèle de menace
2.2 Méthodes de protection
2.2.1 Confidentialité
2.2.2 Intégrité
2.2.2.1 Méthodes de protection contre l’attaque par injection
2.2.2.2 Méthodes de protection contre l’attaque par permutation spatiale
2.2.2.3 Méthodes de protection contre l’attaque par rejeu
2.3 Les arbres de Merkle réguliers
2.3.1 Opérations
2.3.1.1 Initialisation
2.3.1.2 Vérification
2.3.1.3 Mise à jour
2.3.2 Évaluation des performances
2.3.2.1 Notations
2.3.2.2 Initialisation
2.3.2.3 Lecture vérifiée
2.3.2.4 Écriture vérifiée
2.3.3 Variantes des arbres de Merkle
2.3.3.1 Parallelizable Authentication Tree
2.3.3.2 TEC-Tree
ReadAndCheck
WriteAndUpdate
2.3.4 Comparaison des différents arbres
2.4 Plates-formes de calcul sécurisées
2.4.1 Best
2.4.2 Dallas DS5002FP
2.4.3 XOM
2.4.4 AEGIS
2.4.5 CryptoPage
2.4.6 MESA
2.4.7 PE-ICE
2.5 Conclusion
3 Les arbres de Merkle creux et la gestion de la mémoire
3.1 Les arbres creux initialisés
3.1.1 Opérations
3.1.1.1 Initialisation
3.1.1.2 Vérification
3.1.1.3 Mise à jour
3.1.2 Évaluation des performances
3.1.2.1 Initialisation
3.1.2.2 Lecture vérifiée
3.1.2.3 Écriture vérifiée
3.2 Les arbres creux non initialisés
3.2.1 Opérations
3.2.1.1 Initialisation
3.2.1.2 Vérification
3.2.1.3 Mise à jour
3.2.2 Évaluation des performances
3.2.2.1 Initialisation
3.2.2.2 Lecture vérifiée
3.2.2.3 Écriture vérifiée
3.3 Utilisation d’un cache d’arbres de Merkle
3.3.1 Stratégie ASAP
3.3.2 Stratégie ALAP
3.3.3 Cache d’arbre de Merkle ALAP et Write-Through
3.3.4 Cache d’arbre de Merkle ALAP et Write-Back-Allocate
3.3.4.1 Les opérations élémentaires du cache
3.3.4.2 Cohérence interne partielle
3.3.4.3 Gestion du cache
3.3.4.4 Correction fonctionnelle de la gestion du cache proposée
3.3.5 Combinaison des arbres creux et du cache d’arbre
3.4 Conclusion
4 Cas d’étude : projet SecBus
4.1 Introduction
4.1.1 Modèle de menace
4.1.2 Objectifs de sécurité
4.1.2.1 Confidentialité
4.1.2.1.1 Pages RO
4.1.2.1.2 Pages RW
4.1.2.2 Intégrité
4.1.2.2.1 Pages RO
4.1.2.2.2 Pages RW
4.1.3 Architecture et structures de données
4.1.3.1 Politiques de sécurité
4.1.3.2 Paramètres de sécurité de page
4.1.3.3 Arbre de MAC Maître (MMT)
4.2 Architecture logicielle
4.2.1 Bootloader
4.2.2 SSM
4.2.2.1 Interface d’applications
4.2.2.2 Chargeur d’applications
4.2.2.3 Mémoire dynamique
4.3 Architecture matérielle
4.3.1 Modules d’interface
4.3.1.1 Split Module
4.3.1.2 Merge Module
4.3.1.3 Input Controller
4.3.1.4 IO Registers Module
4.3.2 Modules de protection
4.3.2.1 Security Context Controller
4.3.2.2 Security Controller
4.3.2.3 Crypto Engine
4.3.2.4 MAC Set Controller
4.3.2.5 MAC Tree Controller
4.4 Conclusion
5 Simulations et validations
5.1 Tests de simulation des Arbres de Merkle
5.1.1 Environnement de simulation
5.1.1.1 Introduction de SoCLib
5.1.1.2 Plate-forme et application
5.1.1.2.1 Initialisation des arbres de Merkle
5.1.1.2.2 Configuration des paramètres de sécurité
5.1.1.2.3 Application
5.1.1.2.4 Paramètres de la simulation
5.1.2 Résultats
5.1.3 Conclusion
5.2 Validation fonctionnelle
5.2.1 Introduction
5.2.2 Ce que l’on prouve
5.2.3 Quelques précisions sur la preuve de raffinement avec la méthode
5.2.3.1 Des arbres abstraits aux arbres concrets
5.2.3.2 De l’algorithme abstrait (fonctionnel récursif) au concret (impératif itératif)
5.2.3.3 Preuve formelle
5.2.4 Quelques précisions sur la preuve d’équivalence avec EasyCrypt
5.2.4.1 Modèle
5.2.4.1.1 Formalisation des constructions
5.2.4.1.2 Modèle calculatoire
5.2.4.2 Preuve
5.2.5 Conclusion
5.3 Évaluation des performance du module matériel HSM
5.3.1 Introduction
5.3.2 Coûts matériels
5.3.3 Augmentation de l’empreinte mémoire
5.3.4 Configurations et résultats
5.3.4.1 Configurations
5.3.4.2 Résultats
5.3.5 Conclusion
Conclusions et perspectives
Appendices
Télécharger le rapport complet
