Vérification de programmes OCaml à l'exécution

Runtime verification of OCaml programs

• Auteur / Autrice : Clément Pascutto
• Direction : Jean-Christophe Filliâtre, Thomas Gazagnaire
• Type : Thèse de doctorat
• Discipline(s) : Informatique
• Date : Soutenance le 18/10/2023
• Etablissement(s) : université Paris-Saclay
• Ecole(s) doctorale(s) : École doctorale Sciences et technologies de l'information et de la communication (Orsay, Essonne ; 2015-....)
• Partenaire(s) de recherche : Laboratoire : Laboratoire Méthodes formelles (Gif-sur-Yvette, Essonne ; 2021-....)
• Partenaire(s) de recherche : Référent : Faculté des sciences d'Orsay
• Partenaire(s) de recherche : graduate school : Université Paris-Saclay. Graduate School Informatique et sciences du numérique (2020-….)
• Partenaire(s) de recherche : Entreprise : Tarides
• Partenaire(s) de recherche : Equipe de recherche : Toccata (Saclay)
• Jury : Président / Présidente : Ralf Treinen
• Jury : Examinateurs / Examinatrices : Antoine Rollet, Frédéric Loulergue, Delphine Longuet
• Jury : Rapporteur / Rapporteuse : Antoine Rollet, Frédéric Loulergue

Mots clés

Mots clés contrôlés

Logiciels -- Essais

Méthodes formelles (informatique)

Logiciels -- Vérification

Objective Caml (langage de programmation)

Mots clés libres

OCaml

Vérification de programmes

Méthodes formelles

Vérification dynamique

Spécification de programme

Test automatique

OCaml

Software verification

Formal methods

Runtime verification

Program specification

Automated testing

Résumé

Les outils de vérification formelle, en particulier dans le domaine de la vérification déductive, apportent des garanties statiques fortes de correction des systèmes logiciels, mais nécessitent un haut degré d'expertise et des durées de développement considérables. Ces obstacles compromettent parfois leur mise en place dans un contexte industriel, et presque toujours leur passage à l'échelle dans des systèmes complexes. Dans ce contexte, la vérification dynamique (comprendre : à l'exécution) permet une approche plus graduelle. Alors que les spécifications sont toujours exprimées en termes logiques précis, on s'assure de la correction de l'implémentation par des tests automatiques à mesure de son exécution, plutôt que par des preuves. L'expertise nécessaire est alors restreinte à la conception de spécifications et l'interprétation des résultats de test. La communauté du langage de programmation OCaml n'échappe pas à ce constat. Malgré le fait que le langage semble propice à la mise en place de méthodes formelles, aucun outil ne paraît connaître une adoption large pour la production de code OCaml spécifié ou vérifié. De surcroît, pour un outil prétendant répondre à cette question, il faut également prendre en compte les spécificités du langage, notamment les interactions avec le typage statique, l'influence de la représentation mémoire et du ramasse-miettes ou les idiomes liés à la programmation fonctionnelle. Dans ce travail, on propose des techniques de vérification dynamique de code OCaml applicables à des bases de code préexistantes et intégrables aux flux de travail des ingénieurs logiciels qui les maintiennent. En particulier, on présente brièvement Gospel, un langage de spécification accessible mais expressif pour OCaml. On décrit Ortac, un outil de vérification dynamique pour OCaml entièrement automatisé dont l'interface modulaire permet son utilisation dans une grande variété de scenarii (fuzzing, monitoring, test). Il entend supporter un sous-ensemble non trivial d'OCaml (e.g. foncteurs, exceptions, effets) avec l'appui du typage et dans un souci d'efficacité des vérifications effectuées (e.g. limitation des copies, gestion des entiers de précision arbitraire, vérification partielle des invariants de types). Enfin, on développe une famille d'optimisations de la mémoire pour la vérification de post-conditions faisant référence au pré-état. Elles prennent la forme de transformations de spécifications, généralisées pour être applicables dans d'autres langages, et prouvées correctes avec l'assistant de preuves Coq. Le travail entrepris permet d'envisager un écosystème de vérification automatisé, peu intrusif et adapté aux besoins des développeurs et développeuses de la communauté OCaml.

Formal verification methods, in particular when it comes to deductive verification, bring strong guarantees about the correctness of software systems. However, they require a high degree of expertise and tremendous development time. These pitfalls sometimes jeopardize their application in industrial-grade software, almost always preventing scaling to complex systems. In that respect, dynamic (read: runtime) verification allows for a more gradual approach. While the user still expresses specifications in a formal, precise language, one checks the correctness of the implementation via automatic testing at runtime rather than proofs. It narrows the required expertise to the specification design and the interpretation of test results. These observations also apply to the OCaml programming language community. Despite the suitability of the language for formal methods, broad adoption still seems out of reach for tools that produce specified or verified code. Moreover, such tools must account for details of the language: its type system, memory representation, garbage collector, and functional idioms. In this work, we propose runtime verification techniques for OCaml code that apply to preexisting codebases and engineers' workflows. In particular, we briefly introduce Gospel, an accessible yet expressive specification language for OCaml. We describe Ortac, an automated runtime assertion checker for OCaml with a modular interface that allows for multiple usage scenarii (fuzzing, monitoring, tests). Ortac aims to support a non-trivial subset of OCaml (e.g. functors, exceptions, effects). It uses typing information to produce efficient verifications (e.g. narrowing the copies, handling arbitrary precision integers, partially verifying type invariants). Lastly, we elaborate on memory optimizations for verifying postconditions referencing the prestate. They consist of specification transformations, generalized to apply to other languages, that have been proven correct using the Coq proof assistant. This work opens a way for an automated verification ecosystem that would be unintrusive and suitable for the developers' needs in the OCaml community.