Sommaire: Vérification de code pour plates-formes embarqués

Table de matières
Liste des figures
Liste des tables
Chapitre I : Introduction générale
1. CONTEXTE
2. OBJECTIFS
3. STRUCTURE DU MEMOIRE
Chapitre II : La sécurité informatique
1. INTRODUCTION
2. QUELQUES DEFINITONS
2.1. Sécurité informatique
2.2. Menace
2.3. Attaque
2.4. Vulnérabilité
2.5. Contre-mesure
2.6. Risque
3. PROPRIETES DE LA SECURITE INFORMATIQUE
3.1. La confidentialité
3.2. L’intégrité
3.3. La disponibilité
3.4. L’authentification
3.5. La non-répudiation
4. POLITIQUE DE SECURITE
5. DOMAINES D’APPLICATION DE LA SECURITE INFORMATIQUE
5.1. Sécurité physique
5.2. Sécurité de l’exploitation
5.3. Sécurité logique
5.4. Sécurité applicative
5.5. Sécurité des télécommunications
6. ATTAQUES LOGIQUES
6.1. Chevaux de Troie
6.2. Virus
6.3. Vers
6.4. Bombe logique
6.5. Spyware
6.6. Spam
6.7. Hoax
7. MECANISMES DE PROTECTION
7.1. L’authentification
7.2. Le contrôle d’accès
7.3. Le chiffrement de l’information (cryptographie)
7.3.1. Quelques définitions
7.3.2. Chiffrement symétrique
7.3.3. Chiffrement asymétrique
7.3.4. Fonction de hachage (Signature numérique) 7.4. Anti-Virus
7.5. Pare-feu (Firewall)
7.6. Anti-spyware
7.7. Autres mesures de protection
8. CONCLUSION
Chapitre III : La sécurité des systèmes embarqués
1. INTRODUCTION
2. LES SYSTEMES EMBARQUES
2.1. Définition
2.2. Domaines d’application
2.3. Importance du marché de l’embarqué
2.4. Les caractéristiques des systèmes embarqués
2.4.1. Fiabilité
2.4.2. Faible coût
2.4.3. Limités en ressources
2.4.4. Faible consommation
2.4.5. Fonctionnement en temps-réel
2.4.6. Sûreté de fonctionnement
2.4.7. Sécurité
2.5. Architecture générale d’un système embarqué
3. LA SECURITE DANS LES SYSTEMES EMBARQUES
3.1. Exigences de sécurité
3.2. Défis de conception d’un système embarqué sécurisé
3.3. Attaques sur les systèmes embarqués
3.3.1. Attaques physiques et side-channel
3.3.2. Attaques logiques
3.4. La sécurité contre les attaques logiques
4. CONCLUSION
Chapitre IV : Java Card
1. INTRODUCTION
2. LES CARTES A PUCES
2.1. Types de base
2.2. Architecture des Smart Cards
2.2.1. Composants physiques
2.2.1.1. CPU
2.2.1.2. Mémoires
2.2.1.3. Points de contact
2.2.2. Dispositif d’acceptation de cartes « Card Acceptance Device (CAD) »
2.2.3. Système d’exploitation
2.2.4. Applications
3. JAVA CARD
3.1. Le langage Java Card
3.2. Architecure d’une Java Card
3.2.1. La machine virtuelle Java Card
3.2.1.1. Le convertisseur
3.2.1.2. L’interpréteur
3.2.2. Installeur Java Card et programme d’installation hors-carte
3.2.3. L’environnement d’exécution Java Card
3.2.3.1. Cycle de vie d’un JCRE
3.2.3.2. Comment fonctionne le JCRE durant une transaction ?
3.2.4. Les APIs Java Card
3.2.4.1. Le package java.lang
3.2.4.2. Le package javacard.framework
3.2.4.3. Le package javacard.security
3.2.4.4. Le package javacardx.crypto
3.3. Les Applets Java Card
3.3.1. Identificateur d’application (AID)
3.3.2. Processus de développement d’une Applet
3.3.3. Installation et exécution d’une applet
3.3.4. Structure d’une Applet
4. LA SECURITE DANS JAVA CARD
4.1. Les Risques
4.1.1. Motivations
4.1.2. Cible d’attaques
4.2. Attaques sur les Java Cards
4.2.1. Attaques physiques
4.2.2. Attaques logiques
4.3. Eléments de sécurité disponibles dans Java Card
4.3.1. Sécurité du langage
4.3.2. Vérification du sous-ensemble des fichiers classes
4.3.3. Vérification du fichier CAP et du fichier d’exportation
4.3.4. Chargement d’applet
4.3.5. Pare-feu et contextes
4.3.6. Points d’entrée et tableaux globaux
4.3.7. Partage d’objets
4.3.8. Atomicité des transactions
4.3.9. Cryptographie
4.4. Obtenir un code mal typé sur une Java Card
4.4.1. Manipulation du fichier CAP
4.4.2. Abusant des objets d’interface partageable
4.4.3. Abuser le mécanisme de transaction
5. CONCLUSION
Chapitre V : Vérification de fichier CAP
1. INTROCUTION
2. VUE D’ENSEMBLE DE LA JVM ET DU BYTECODE
2.1. Définition du bytecode
2.2. Format du fichier class
2.3. Bytecode et instructions d’une méthode
2.4. Des instructions typées
2.5. Contraintes sur les instructions
2.6. Bytecode et sécurité
2.7. Approche de vérification
3. DIFFERENCE ENTRE JAVA ET JAVA CARD
3.1. Machine virtuelle
3.2. Structure du fichier exécutable
3.3. Vérifieur de bytecode
4. VERIFIEUR DE FICHIER CAP
4.1. Description du vérifieur
4.2. Processus de vérification
4.2.1. Vérification de la cohérence interne
4.2.2. Etapes de la vérification
4.2.3. Vérification du fichier d’exportation
4.2.4. Vérification de la compatibilité
4.2.5. Considérations sécuritaires
5. CONCLUSION
Chapitre VI : Contribution « Introduction d’un nouveau module de vérification dans le vérifieur de fichier CAP »
1. INTROCUTION
2. ENVIRONNEMENT DE DEVELOPPEMENT
2.1. Description de l’environnement
2.2. Ensemble d’outils
2.2.1. L’outil « jcwde » (Java Card Workstation Development Environment)
2.2.2. L’outil « cref »
2.2.3. L’outil « apdutool »
2.2.4. L’outil « Converter »
2.2.5. L’outil « offcardverifier »
2.2.6. L’outil « scriptgen »
2.2.7. L’outil « Installer »
2.2.8. L’outil « capgen »
2.2.9. L’outil « capdump »
2.2.10. L’outil « exp2text »
2.3. Ensemble de transformations de fichiers
2.4. Exemple d’utilisation du kit
2.4.1. Développement et compilation de l’applet
2.4.2. Conversion en fichier CAP
2.4.3. Vérification du fichier CAP
2.4.4. Installation du fichier CAP
2.4.5. Exécution de l’applet
2.4.6. Utilisation d’une application cliente
3. ATTAQUE D’ACCES A LA MEMOIRE COMPLETE SUR UNE JAVA JARD
3.1. Description de l’attaque
3.1.1. Travaux connexes
3.1.2. Confusion de type
3.1.3. La vulnérabilité dans le mécanisme de transaction
3.1.4. Réalisation de l’attaque
3.1.5. Exploitation de l’attaque
3.1.6. Résultats de l’attaque
3.2. Réalisation de l’attaque sur l’applet « MonApplet »
3.2.1. Cible d’attaque
3.2.2. Réalisation de l’attaque
3.2.3. Résultats de l’attaque
4. CONTRIBUTION
4.1. Cause de l’attaque
4.2. Le problème avec les mécanismes de protection
4.3. Solution proposée
4.4. Réalisation du nouveau vérifieur
4.4.1. Accéder au code source du vérifieur
4.4.2. Ajouter le nouveau module de vérification
4.4.3. Reproduire le vérifieur
4.4.4. Résultats de l’utilisation du nouveau vérifieur
5. DISCUSSION
6. CONCLUSION
Conclusion et perspectives
Bibliographie
Annexe : Le concept Java
1. INTRODUCTION
2. LE LANGAGE JAVA
3. LA PLATE-FORME JAVA
3.1. La machine virtuelle Java
3.2. Les APIs de Java
4. CYCLE DE VIE D’UN PROGRAMME JAVA
4.1. Structure d’un programme Java
4.2. Exécution d’une application
4.3. Exécution d’une applet
4.4. Exécution d’une servlet
5. LE MODELE DE SECURITE DE JAVA
5.1. Le vérifieur Java
5.2. Le gestionnaire de sécurité
5.3. Le chargeur de classe
5.4. Sécurité du langage
6. CONCLUSION

Extrait du mémoire vérification de code pour plates-formes embarqués

Chapitre I : Introduction Générale
1. CONTEXTE
Le mot « sécurité » est très utilisé de nos jours, il s’applique dans des domaines très différents. Les systèmes informatiques constituent un de ces domaines. Ces systèmes sont nombreux (PC, cartes à puce, Internet, etc.) et de plus en plus utilisés.
Les exigences des utilisateurs en termes de sécurité sont de plus en plus importantes.
La sécurité informatique a pour but la protection des ressources matérielles et logicielles d’un  système informatique contre la révélation, la modification, ou la destruction accidentelle ou malintentionnée.

Plates-formes embarqués
Afin de pouvoir sécuriser un système, il est nécessaire de mettre en œuvre des mécanismes de protection au sein de ce système. La mise en œuvre de ces mécanismes se justifie par l’existence de menaces pouvant se concrétiser sous forme d’attaques. Il est donc essentiel d’identifier les menaces potentielles portant sur le système, de connaître et de prévoir la façon de procéder de ces menaces, pour pouvoir déterminer les mécanismes de protections qu’on doit mettre en œuvre au sein de ce système.
La menace est caractérisée par la possibilité et la probabilité d’attaque contre la sécurité.

Plates-formes embarqués
Elle engendre des risques et des coûts humains et financiers : perte de confidentialité de données sensibles, indisponibilité des infrastructures et des données, etc. Les attaques exploitent les vulnérabilités du système informatique, chaque système informatique est exposé à une famille d’attaques selon les vulnérabilités qu’il présente.

Plates-formes embarqués
Notre travail ne porte pas sur la sécurité des systèmes informatiques en général, mais sur les systèmes embarqués, en particulier les cartes à puce. Ces cartes sont de plus en plus utilisées à travers le monde et leurs capacités de calcul et de stockage leurs permettent de contenir plusieurs applications. Pour programmer ces applications, divers langages existent, dont celui qui nous intéresse, Java Card.
Java Card est l’adaptation de Java pour les cartes à puce et d’autres dispositifs à mémoire limitée. C’est l’une des dernières plates-formes pour carte à puce, et la plus populaire.
Aujourd’hui, une grande quantité de cartes à puces sont équipées avec une plate-forme Java Card. Elles sont largement utilisées dans les cartes SIM (utilisées dans les téléphones mobiles), les cartes de guichets automatiques, et les services financiers (cartes de crédit, porte-monnaie électroniques, etc.).
……….

Si le lien ne fonctionne pas correctement, veuillez nous contacter (mentionner le lien dans votre message)
Mémoire Online: Vérification de code pour plates-formes embarqués (2.1 MB) (Cours PDF)