Évaluation par prototypage virtuel et analyse statique de la sécurité des systèmes matériels et logiciels face aux attaques laser

par Johan Laurent

Projet de thèse en Nano electronique et nano technologies

Sous la direction de Vincent Beroulle.

Thèses en préparation à l'Université Grenoble Alpes (ComUE) , dans le cadre de École doctorale électronique, électrotechnique, automatique, traitement du signal (Grenoble) , en partenariat avec Laboratoire de conception et d'intégration des systèmes (laboratoire) depuis le 02-10-2017 .


  • Résumé

    Les attaques laser permettent de réaliser des attaques en faute très puissantes qui menacent la sécurité des systèmes numériques. Ces attaques consistent à utiliser un laser afin d'injecter des erreurs à des instants précis et sur des composants ciblés dans les systèmes numériques. Un système numérique est composé d'une architecture matérielle qui exécute une application logicielle. Les erreurs injectées peuvent se propager ou être masquées, à la fois par le matériel et le logiciel. Les erreurs en se propageant peuvent créer des failles de sécurité. Les certifications de sécurité vérifient expérimentalement l'immunité des systèmes physiques et des applications qu'ils exécutent face à différents types d'attaques dont les attaques laser. Pour obtenir ces certifications, prévoir dès la conception des contremesures (matérielles et/ou logicielles) contre ces attaques est une nécessité. En effet, les corrections tardives ont un coût très important et engendrent des retards lors de la mise sur le marché des produits. L'objectif de cette thèse est de proposer une approche permettant d'évaluer et donc d'améliorer la sécurité des systèmes embarqués face aux attaques laser, en considérant très tôt dans le flot de développement conjointement l'architecture matérielle et l'application. Pour réaliser ce travail tôt dans le flot de développement, il est nécessaire de considérer des prototypes virtuels plutôt que des prototypes physiques des systèmes. L'utilisation de prototypes virtuels pour l'injection de fautes implique des temps de simulation prohibitifs. En conséquence, les analyses de la propagation des fautes ou de leur masquage au niveau matériel et logiciel seront réalisées avec des méthodes d'analyse statique. Le travail s'articule autour de deux étapes principales : (1) l'inférence d'un modèle de fautes de haut niveau pour une description RTL de l'architecture matérielle et pour une application donnée et (2) l'utilisation de ce modèle de fautes couplé à des assertions de sécurité pour déterminer par une analyse statique les failles potentielles du système. Une fois ces failles identifiées (et un très grand nombre de fautes filtrées), il sera possible de simuler au niveau RTL les attaques à l'origine de ces failles, afin d'en observer précisément les effets et de proposer des protections efficaces et à faibles coûts. L'étape 1 vise à produire un modèle de fautes multi-niveaux (ou « cross-layer »). En effet, les modèles de fautes logiciel (e.g. saut d'instructions, modification du flot de données), qui ne reposent sur aucune information provenant du matériel, sont généralement peu réalistes. Ils conduisent alors à sur-dimensionner ou sous-dimensionner les protections mises en oeuvre. Les simulations de fautes au niveau RTL, qui injectent des erreurs plus représentatives, sont trop chronophages pour permettre la simulation d'une application complète. L'objectif de l'étape 1 est de fournir au développeur du système un modèle de fautes de haut niveau prenant en compte à la fois les spécificités du laser (i.e. localité de l'attaque), de l'architecture matérielle (i.e. origine des fautes, propagation et masquage de ces fautes directement dans le matériel), et de l'application exécutée. Les modèles de fautes transitoires RTL classiques (single et multi bit-flips, etc.) ne prennent pas en compte le caractère localisé des attaques lasers. L'étape 1 s'appuiera sur le modèle de fautes RTL spécifique aux attaques laser récemment proposé par A. Papadimitriou qui prend en compte la localisation de l'attaque laser. À partir de ce modèle, il s'agira de déterminer par simulation les effets des fautes sur une architecture de processeur donnée et pour un exécutable donné. Ces effets simulés au niveau RTL sur chaque instruction ou partie de l'exécutable seront modélisés par des fautes au niveau du code source (par exemple sous la forme de mutations et de saboteurs). L'objectif de l'étape 2 est de déterminer les failles de sécurité potentielles correspondant au modèle de fautes issu de l'étape 1. Pour cela il sera nécessaire tout d'abord d'exprimer les besoins de sécurité. Ces besoins peuvent prendre la forme d'assertions de sécurité insérées dans le code source. Elles formalisent alors les conditions que l'état du programme doit vérifier pour ne pas être susceptible d'ouvrir une faille. Il faudra ensuite déterminer quelles fautes sont susceptibles d'invalider ces assertions de sécurité. Le nombre de configurations d'exécution possibles du programme, correspondant à toutes les valeurs possibles des paramètres, combinées avec toutes les fautes possibles du modèle, rend irréaliste une approche de type test, i.e. une couverture exhaustive des exécutions erronées. On se tournera donc vers des techniques d'analyse statique qui permettent, au prix d'approximations contrôlées, de raisonner sur des ensembles d'exécutions avec des paramètres et des fautes variables. Les techniques d'analyse statique sont étudiées depuis longtemps et sont de plus en plus utilisées pour prouver des propriétés de programme telles que l'absence de certains types de bugs. Des outils matures existent [frama-C]. Plus récemment, des travaux mettent en avant l'usage de ces techniques dans le contexte de l'étude de la résistance des systèmes/programmes aux attaques par fautes.

  • Titre traduit

    Evaluation with Virtual Prototyping and Static Analysis of the Security of Hardware and Software Systems against Laser Attacks


  • Résumé

    Laser allows attackers to realize very efficient attacks which threaten the security of digital systems. These attacks consist in using a laser to inject errors at specific times targeting specific components in the digital system. This digital system is a hardware architecture which executes a software application. The injected errors can then be propagated or masked, both by the hardware and the software parts of the system. The errors which are propagated can generate security breaches. Security certifications experimentally verify the vulnerabilities of the hardware part and of the application the system executes against different types of attacks (including the laser ones). To pass these certifications it is necessary to anticipate from the early design step the design of countermeasures (hardware and/or software) against these attacks. In fact, late modifications increase the system costs and its time to market. The thesis goal is to propose a new approach to evaluate and enhance the security of embedded systems against laser attacks, considering very early in the development flow conjointly the hardware architecture and its application. To achieve this work early in the development flow, it is necessary to consider virtual prototypes rather than hardware prototypes. However, the use of virtual prototypes to inject faults implies high simulation times. Thus, the analyses of the fault propagations or fault masking in the hardware and software parts will be done using static analysis methods. The work will be divided in two main steps: (1) the inference of a high level fault model for a RTL description of a hardware architecture and for a given application and (2) the use of this fault model coupled with security assertions to determine by static analysis the potential breaches of the system. Once the errors potentially generating breaches will be known (and a high number of faults filtered by the static analyses), it will be possible to accurately simulate these faults. This RTL simulation will allow us to observe the error effects and then to propose efficient and low cost countermeasures. The first step consists in creating a fault model using several abstraction levels (i.e. “cross layer fault model”). Indeed, the software fault models (e.g. instruction jump, data flow modifications, etc.) which do not rely on any hardware information, are generally not realistic. These unrealistic models drive designers to under or over-estimate their countermeasures. But fault simulation at the RTL level, which injects more representative errors, is too time consuming to allow a complete application simulation. Thus, the objective of this first step is to give to the system developer a high level fault model taking into account both the characteristics of the laser, the hardware architecture, and the executed application. The classical RTL transient fault models (single or multi bit-flips, etc.) do not take into account the laser locality characteristic. So, the step 1 will reuse the RTL fault model proposed by A. Papadimitriou which takes into account the laser locality characteristic. Using this model, we will determine (by RTL simulation) the effects of the faults on the processor architecture for a given executable. These effects simulated at the RTL level for each instruction or sequence of instructions will be modelled by software faults at the level of the source code (e.g. mutations and saboteurs). The second step aims at finding out what security breaches the faults can create. Firstly, it is necessary to express the security needs of the application. These can be expressed as security assertions inserted in the application source code. Such an assertion formalize, at a given program point, a property of the program state ensuring the absence of security breaches. Secondly, one has to identify, among all the faults from the model, which faults may violate at least one security assertion. Due to combinatorial explosion, it is not realistic to "test" the program for each possible parameter value and each possible fault (or combination of faults). Based on careful approximations, static analysis techniques allow reasoning on sets of executions including various parameter values and fault occurrences. Such techniques have been studied for a long time. Their usage is growing to prove program properties such as the absence of certain kinds of bugs. Mature tools such as [frama-C] have been developed. More recently, they have started to be used in the context of the analysis of fault attack effects on a system or program.