Vérification de scripts Shell effectuant des transformations de système de fichiers hiérarchiques

Verification of Shell scripts performing file hierarchy transformations

• Auteur / Autrice : Nicolas Jeannerod
• Direction : Ralf Treinen, Yann Régis-Gianas
• Type : Thèse de doctorat
• Discipline(s) : Informatique
• Date : Soutenance le 30/03/2021
• Etablissement(s) : Université Paris Cité
• Ecole(s) doctorale(s) : École doctorale Sciences mathématiques de Paris centre (Paris ; 2000-....)
• Partenaire(s) de recherche : Laboratoire : Institut de recherche en informatique fondamentale (Paris ; 2016-....)
• Jury : Président / Présidente : Roberto Di Cosmo
• Jury : Examinateurs / Examinatrices : Yann Régis-Gianas, Roberto Di Cosmo, Julia L. Lawall, Michael Greenberg
• Jury : Rapporteurs / Rapporteuses : Andreas Podelski, Stéphane P. Demri

Mots clés

Mots clés contrôlés

Logique du premier ordre

Décidabilité (logique mathématique)

Vérification de modèles (informatique)

Utilitaires (logiciels)

Fichiers (informatique) -- Organisation

POSIX (norme)

Mots clés libres

POSIX Shell

Système de fichiers

Utilitaires Unix

Modélisation

Logiques d’arbres de traits

Résolution efficace de contraintes

Installation de paquet logiciel

Debian Linux

POSIX Shell

Unix Filesystems

Unix Utilities

Modelisation

Feature tree logics

Efficient Constraints Solving

Software Package Installation

Résumé

Cette thèse vise à appliquer des techniques de vérification déductive de programmes et d’analyse de transformations d’arbres au problème de l’analyse de scripts Shell. En particulier, nous visons à analyser les scripts Shell utilisés pendant l’installation de logiciels de la distribution Debian GNU/Linux. Le but final est de démontrer la faisabilité de notre analyse en développant un outil capable de lire des paquets Debian – le format dans lequel Debian distribue des logiciels – et de fournir un rapport sur leur qualité et sur les bogues potentiels qu’on pourrait y trouver.Shell est un langage de script qui fournit des structures de contrôle autour d’appels d’utilitaires Unix. Les utilitaires Unix sont des objets qui peuvent effectuer toutes sortes de transformations sur des systèmes de fichiers Unix. Nous modélisons les systèmes de fichiers Unix à l’aide d’arbre de traits et les transformations de tels systèmes de fichiers à l’aide de formules dans une logique d’arbres de traits nommée FTS. Nous décrivons ces modélisations en détails et discutons leur validité. Les structures de contrôle des scripts Shell sont converties en des structures de contrôle d’un langage intermédiaire avec une sémantique clairement définie. Cela implique la définition du langage intermédiaire en question et le développement d’un parseur statique pour les scripts Shell et d’une conversion qui respecte les sémantiques des deux langages. La sémantique d’un script Shell est ensuite calculée par exécution symbolique sur le langage intermédiaire susmentionné en utilisant une base de spécifications des utilitaires Unix comme des formules de FTS. Pour chaque trace d’exécution d’un script Shell, le résultat est une formule de FTS décrivant la transformation de système de fichiers qu’effectue cette trace.La partie principale de cette thèse s’intéresse à la décidabilité de formules de FTS. L’objectif est d’être capable de détecter des traces d’exécution de scripts Shell qui ne peuvent pas arriver et de vérifier des propriétés sur les scripts Shell, comme par exemple le fait que « si le script échoue, alors il ne doit pas avoir effectué de transformation. » Une première approche théorique vise à montrer que la théorie du premier ordre de FTS est décidable. Cela se fait par un raisonnement sur les formules Σ1 de FTS et par la définition d’un système de règles R1 qui transforme les formules Σ1. Nous montrons que nous pouvons utiliser R1 pour décider de la satisfiabilité de formules Σ1, parmi d’autres propriétés. Nous étendons ensuite le raisonnement des formules Σ1 vers les formules du premier ordre de FTS à l’aide de propriétés de R1 et d’éliminations faible des quantificateurs. Nous concluons en disant que la théorie du premier ordre de FTS est bien décidable. Une seconde approche, plus pratique, vise à créer des procédures de décision efficaces pour un sous-ensemble de FTS assez riche pour exprimer les sémantiques des utilitaires Unix et des scripts Shell. Nous faisons cela en nous intéressant en particulier aux formules conjonctives et en améliorant R1. Le résultat est un système R2 qui est plus efficace sur les formules conjonctives mais qui n’a pas les propriétés nécessaires pour prouver la décidabilité du premier ordre. Nous montrons ensuite comment R2 peut être implémenté efficacement et comment il peut être étendu pour supporter des formes spécifiques de formules de Σ1 sans pertes d’efficacité.Enfin, cette thèse décrit les applications de ce travail théorique à l’implémentation d’un groupe d’outils capable d’analyser tous les paquets logiciels de la distribution Debian et de fournir un rapport. Nous décrivons notre analyse et les bogues que nous avons trouvé au long du projet. Cette thèse s’inscrit dans le projet CoLiS, ANR-15-CE25-0001, se déroulant entre octobre 2015 et mars 2021.

This thesis aims at applying techniques from deductive program verification and analysis of tree transformations to the problem of analysing Shell scripts. In particular, we aim at analysing Shell scripts that are used in software installation in the Debian GNU/Linux distribution. The final goal is to build a proof-of-concept tool able to read Debian packages – the way Debian has to distribute software – and report on their quality and on the potential bugs they might have.Shell is a scripting language providing control structures around Unix utility calls. Unix utilities are objects that can perform all kind of transformation on Unix filesystems. We model Unix filesystems using feature trees and transformations of Unix filesystems using formulas in a feature tree logic named FTS. We describe these modelisations extensively and discuss their validity. The control structures of Shell scripts are converted to control structures in an intermediary language that has clearly defined semantics. This involves the definition of this intermediary language, the design of a static parser for Shell scripts and of a conversion that respects the semantics of both languages. The semantics of Shell scripts is then computed using symbolic execution of the aforementioned intermediary language, using a database of specifications of Unix utility calls as formulas of FTS. The result is, for each potential trace of execution of a Shell script, a formula of FTS describing the filesystem transformation this trace performs.The main part of the thesis then focuses on decidability of formulas of FTS. The goal is to be able to detect traces of execution of Shell scripts that cannot happen and to check properties on the Shell scripts, such as “if the script fails, then it must not have performed any transformation”. A first, theoretical, part aims at showing that the full first-order theory of FTS is decidable. This goes by first reasoning only on Σ1-formulas of FTS and defining a system of rules R1 that transforms Σ1-formulas. We show that we can use R1 to decide the satisfiability of Σ1-formulas as well as some other properties. We then extend the reasoning from Σ1-formulas to first-order formulas of FTS using properties of R1 and weak quantifier eliminations. We conclude by stating that the first-order theory of FTS is indeed decidable. A second, more practical, part aims at designing efficient decision procedures for a subset of FTS rich enough to express the semantics of Unix utilities and Shell scripts. This goes by focusing on conjunctive formulas and improving on R1. This results in a system R2 which is more efficient on conjunctive formulas but would not have the required properties to prove decidability of the first-order. We then show how R2 can be implemented efficiently and that it can be extended without loss of efficiency to support specific forms of Σ1-formulas.Finally, this thesis describes the applications of the theoretical work to the implementation of a toolchain able to analyse all software packages in the Debian distribution and report on them. We describe our analysis and the bugs that we have found during the whole project. This thesis takes place within the CoLiS project, ANR-15-CE25-0001, taking place from October 2015 to March 2021.