Verification of Shell Scripts Performing File Hierarchy Transformations - TEL - Thèses en ligne Accéder directement au contenu
Thèse Année : 2021

Verification of Shell Scripts Performing File Hierarchy Transformations

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

Résumé

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 Σ₁-formulas of FTS and defining a system of rules R₁ that transforms Σ₁-formulas. We show that we can use R₁ to decide the satisfiability of Σ₁-formulas as well as some other properties. We then extend the reasoning from Σ₁-formulas to first-order formulas of FTS using properties of R₁ 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 R₁. This results in a system R₂ 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 R₂ can be implemented efficiently and that it can be extended without loss of efficiency to support specific forms of Σ₁-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.
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'arbres 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étail 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 Σ₁ de FTS et par la définition d'un système de règles R₁ qui transforme les formules Σ₁. Nous montrons que nous pouvons utiliser R₁ pour décider de la satisfiabilité de formules Σ₁, parmi d'autres propriétés. Nous étendons ensuite le raisonnement des formules Σ₁ vers les formules du premier ordre de FTS à l'aide de propriétés de R₁ et d'une élimination 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 R₁. Le résultat est un système R₂ 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 R₂ peut être implémenté efficacement et comment il peut être étendu pour supporter des formes spécifiques de formules de Σ₁ 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és 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.
Fichier principal
Vignette du fichier
phd-thesis-jeannerod-v1.1.pdf (2.49 Mo) Télécharger le fichier
Origine : Fichiers produits par l'(les) auteur(s)

Dates et versions

tel-03369452 , version 1 (07-10-2021)

Identifiants

  • HAL Id : tel-03369452 , version 1

Citer

Nicolas Jeannerod. Verification of Shell Scripts Performing File Hierarchy Transformations. Logic in Computer Science [cs.LO]. Université de Paris, 2021. English. ⟨NNT : ⟩. ⟨tel-03369452⟩
103 Consultations
109 Téléchargements

Partager

Gmail Facebook X LinkedIn More