SMSébastien Michelland

Sébastien Michelland

*This is an algorithmically generated author record based on publicly available information.

Current Organizations / Institutes

The organizations/institutes from the scholar's latest article

Previous Organizations / Institutes

The organizations / institutes from the scholar's other articles in the past ten years


Sébastien Michelland has a total of 3 co-authors. Here are the top co-authors by number of shared publications:


Latest Publications

  • Compilation beyond semantics for hardware security

    by Sébastien Michelland

    Compilation pour la sécurité matérielle : au-delà de la sémantique: Les systèmes informatiques sont construits par couches pour limiter leur complexité. Par exemple, le logiciel et le matériel sont principalement indépendants l'un de l'autre et communiquent via une interface très contrôlée, un type de langage de programmation appelé assembleur. Une fois accordés sur l'assembleur, le logiciel et le matériel peuvent chacun ignorer, ou s'abstraire, des détails internes de l'autre. Cette construction est omniprésente en informatique ; il y a probablement une dizaine de telles couches d'abstraction entre le logiciel utilisé pour visualiser ce document et les lois fondamentales de la physique.Une limitation de ce système est que les interfaces entre les couches n'isolent que les fonctionnalités. Pour tous les autres aspects, comme la performance ou la sécurité, on est obligés de considérer le système dans toute sa complexité. Par exemple, les attaques par injection de faute produisent des comportements anormaux dans le matériel en interférant volontairement avec le circuit (signaux, alimentation, émissions électromagnétiques, etc. tous les coups sont permis). Le langage assembleur n'a pas de mécanisme pour abstraire les fautes au niveau logiciel ; par conséquent, pour construire une protection logicielle il ne suffit plus de comprendre le langage assembleur, il faut comprendre l'effet des fautes sur tous les détails internes du matériel, une tâche hautement plus complexe.Ce problème se pose aussi à l'intérieur du logiciel. Les applications sont généralement codées dans un langage haut-niveau comme le C, et un compilateur se charge de produire un programme assembleur équivalent.Il est connu que ce processus de compilation peut détruire les protections. Par exemple, pour sécuriser on peut refaire les calculs sensibles en double pour vérifier qu'il n'y a pas eu d'erreur causée par une faute. Le compilateur, ignorant de la menace de sécurité, supprime le doublon, jugé inutile, pour optimiser les performances du programme. Pour produire un programme assembleur satisfaisant, les programmeurs sont donc forcés de comprendre les détails du compilateur. Cette tâche également complexe est fréquemment esquivée en désactivant les optimisations, une solution inélégante mais généralement efficace. L'argument central de cette thèse est que la complexité du compilateur cache d'autres menaces que juste les optimisations. En effet, la compilation se fait en plusieurs étapes dans lesquelles le programme est réécrit dans multiples langages intermédiaires, ce qui représente une descente à travers plusieurs couches d'abstraction logicielles. Contrairement aux optimisations, cette descente n'est pas optionnelle, et présente des menaces subtiles que les programmeurs doivent pouvoir anticiper. Ainsi, cette thèse s'intéresse à la relation entre les contremesures de sécurité contre les attaques matérielles (principalement les attaques en faute) et le processus de descente en abstraction durant la compilation. J'y caractérise les mécanismes de compilation qui menacent les contremesures et démontre qu'ils sont profondément incrustés dans le fonctionnement du compilateur. Je propose ensuite divers outils pour y remédier, notamment une méthode de « tracé » (nouveau dans cette thèse) pour maintenir des liens entre les programmes source et intermédiaires utiles à l'insertion des contremesures.La production centrale de la thèse est Tracing LLVM, une surcouche open-source légère pour LLVM (un compilateur de production) qui enrichit l'interface entre le code et le compilateur pour faciliter l'implémentation de contremesures de sécurité. Tracing LLVM élimine un certain nombre de problèmes courants liés aux optimisations et fournit au programmeur davantage de contrôle sur la compilation pour faciliter l'insertion et la préservation des contremesures. Cela constitue une étape importante dans le développement de compilateurs attentifs à la sécurité et la consolidation des défenses contre les attaques matérielles.

  • Open Access

    Abstract Interpreters: A Monadic Approach to Modular Verification

    by Sébastien Michelland, Yannick Zakowski, Laure Gonnord

    We argue that monadic interpreters built as layers of handlers stacked atop the free monad, as advocated notably by the ITree library, also constitute a promising way to implement and verify abstract interpreters in dependently-typed theories such as the one underlying the Coq proof assistant. The approach enables both code reuse across projects and modular proofs of soundness of the resulting interpreters. We provide generic abstract control flow combinators proven correct once and for all against their concrete counterpart. We demonstrate how to relate concrete handlers implementing effects to abstract variants of these handlers, essentially capturing the traditional soundness of transfer functions in the context of monadic interpreters. Finally, we provide generic results to lift soundness statements via the interpretation of stateful and failure effects. We formalize all the aforementioned combinators and theories into a Coq library, and demonstrate their benefits by implementing and proving correct two illustrative abstract interpreters respectively for a structured imperative language and a toy assembly.


  • Open Access

    From Low-Level Fault Modeling (of a Pipeline Attack) to a Proven Hardening Scheme

    by Sébastien Michelland, Christophe Deleuze, Laure Gonnord

    Fault attacks present unique safety and security challenges that require dedicated countermeasures, even for bug-free programs. Models of these complex attacks are made workable by approximating their effects to a suitable level of abstraction. The common practice of targeting the Instruction Set Architecture (ISA) level isn't ideal because it discards important micro-architectural information, leading to weaker security guarantees. Conversely, including micro-architectural details makes countermeasures harder to model and reason about, creating a new challenge in validating and trusting protections. We show that a semantic approach to modeling faults makes micro-architectural models workable, and enables precise cooperation between software and hardware in the design of countermeasures. We demonstrate the approach by designing and implementing a compiler/hardware countermeasure, which protects against a state-of-the-art pipeline fetch attack that generalizes multi-fault instruction skips. Crucially, we provide a formal security proof that guarantees faults are detected by the end of every basic block. This result shows that carefully embracing the complexity of low-level systems enables finer, more secure countermeasures.