Formal Validation of Pattern Matching code

When addressing the formal validation of generated software, two main alternatives consist either to prove the correctness of compilers or to directly validate the generated code. Here, we focus on directly proving the correctness of compiled code issued from powerful pattern matching constructions typical of ML like languages or rewrite based languages such as ELAN, MAUDE or Tom. In this context, our first contribution is to define a general framework for anchoring algebraic pattern-matching capabilities in existing languages like C, Java or ML. Then, using a just enough powerful intermediate language, we formalize the behavior of compiled code and define the correctness of compiled code with respect to pattern-matching behavior. This allows us to prove the equivalence of compiled code correctness with a generic first-order proposition whose proof could be achieved via a proof assistant or an automated theorem prover. We then extend these results to the multi-match situation characteristic of the ML like languages. The whole approach has been implemented on top of the Tom compiler and used to validate the syntactic matching code of the Tom compiler itself

Compiler verification in the context of pervasive system verification

This thesis presents the formal verification of the compiling specification for a simple, non-optimizing compiler from the C-like programming language C0 to VAMP assembly code. The main result is a step-by-step simulation theorem between C0 programs and the compiled code (which is specified by the compiling specification). Additionally, a C0 small-step semantics and a verification methodology for VAMP assembly have been developed. This work is part of the Verisoft project which aims at the pervasive formal verification of an entire computer system. The key concept in Verisoft';s methodology is to prove properties of computer systems at the relatively abstract C0 layer and to transfer them via several intermediate layers down to the concrete hardware layer. After successful transfer of a property to the hardware layer, we can be sure that no oversimplifications have been done in the formalizations of the more abstract layers. This context of pervasive system verification imposes several special requirements to our compiler correctness theorem. In particular, the simulation theorem had to be formulated based on small-step semantics to allow for reasoning about non-terminating and interleaving programs. Another important feature is that our result incorporates resource restrictions at the hardware layer and allows to discharge them at the C0 layer. All results presented in this thesis have been formalized in the theorem prover Isabelle / HOL.Die vorliegende Arbeit befasst sich mit der formalen Verifikation des Codegenerierungsalgorithmus eines nicht optimierenden Compilers von der C-ähnlichen Sprache C0 nach VAMP Assembler. Das Hauptergebnis ist ein Schritt-für- Schritt Simulationssatz zwischen C0 Programmen und dem compilierten Code. Die Arbeit umfasst zus¨atzlich die Entwicklung einer Small-Step Semantik für C0 sowie einer Verifikationsmethodik für VAMP Assemblerprogramme. Diese Arbeit ist Teil des Verisoft Projekts, das auf die durchgängige formale Verifikation von Computersystemen abzielt. Die Methodik von Verisoft basiert auf der Verifikation von Eigenschaften eines Computersystems auf der relativ abstrakten C0 Ebene und deren anschließendem Transfer auf die konkrete Hardwareebene. Ein solcher erfolgreicher Eigenschaftstransfer garantiert, dass auf den abstrakten Ebenen keine zu starken Vereinfachungen vorgenommen worden sind. Die Einbettung in die durchgängige Verifikation von Systemen stellt zahlreiche speziellen Anforderungen an den Compilerkorrektheitssatz. Insbesondere muss der Simulationssatz auf einer Small-Step Semantik basieren, um die Behandlung von nebenläufigen und von nicht terminierenden Programmen zu ermöglichen. Eine weitere Eigenschaft ist, dass unser Resultat Ressourcenbeschränkungen auf der Hardwareebene einbezieht und deren Entlastung auf der C0 Ebene erlaubt. Alle Resultate dieser Arbeit sind im Theorembeweiser Isabelle / HOL formalisiert worden

Verification of the C0 compiler implementation on the source code level

This thesis concerns practical application of two methods for program verification. The programming language we consider is a C dialect, called C0, which supports dynamic memory allocation, recursion, pointer types, etc. First, we verify a program using a formalization of small-step semantics of C0. The example we study is a small loop program, which allocates a linked list of the given length on the heap. Second, we describe the verification of a compiler implementation in a Hoare Logic in the sense of partial correctness. The source and implementation language of the compiler is C0. The correctness statement is divided into independent parts: i) the correctness of the compilation algorithm with respect to the target machine and ii) the correctness of the implementation with respect to the specified algorithm. This thesis considers the second task. We give the formal specification of the compilation algorithm and develop the connection of the implementation data structures to the abstract types used in the specification. Finally, we show the correctness of the compiler implementation with respect to the specification.Die vorliegende Arbeit befasst sich mit der praktischen Anwendung von zwei Methoden zur Programmverifikation. Die Programmiersprache, die dabei betrachtet wird, ist C0, ein C Dialekt, der unter anderem dynamische Allokation von Speicher, Rekursion und Pointer unterstützt. Zuerst beweisen wir die Korrektheit eines Programms mit Hilfe der formalen Small-Step Semantik von C0. Das Beispiel, das wir untersuchen, ist ein kleines Programm, das in einer Schleife eine gelinkte Liste gegebener Länge auf dem Heap alloziert. Danach beschreiben wir die Verifikation einer Compiler-Implementierung mittels einer Hoare Logik für partielle Korrektheit. Die Quell- und Implementierungssprache des Compilers ist C0. Die Korrektheitsaussage ist in unabhängige Aufgaben aufgeteilt: i) die Korrektheit des Compileralgorithmus bezüglich der Zielarchitektur und ii) die Korrektheit der Implementierung bezüglich dieses Algorithmus. Die vorliegende Arbeit beschäftigt sich mit der zweiten Aufgabe. Wir beschreiben die formale Spezifikation des Compileralgorithmus und entwickeln eine Verbindung zwischen den Datenstrukturen der Implementierung und den abstrakten Typen, die in der Spezifikation benutzt werden. Schließlich zeigen wir die Korrektheit der Compilerimplementierung bezüglich der Spezifikation

Compilación y certificación de código mediante análisis estático de flujo de control y de datos

En la última década el uso de las TIC ha irrumpido en forma explosiva en todas las áreas de actividad humana y han sido incorporadas a una, cada vez más, amplia gama de aplicaciones y artefactos. Paralelamente ha crecido de la misma forma el uso de Código Móvil; esto es, de código que es generado por un productor y usado por uno o numerosos consumidores. La distribución de software por Internet es el ejemplo más evidente, pero el uso de código móvil para la transmisión de actualizaciones o de nuevas versiones de código se extiende a la telefonía celular, a las tarjetas inteligentes y a todas las áreas donde pueda resultar importante la incorporación de nuevas funcionalidades a dispositivos controlados por software. La migración de código brinda una manera automática, de costo mínimo, para resolver la distribución o substitución de código para enormes cantidades de destinatarios. Sin embargo esta técnica también entraña graves riesgos, ya que el software migrado puede comprometer la seguridad de sus numerosos destinatarios, tanto por fallas de programación, como por maliciosas intenciones. La búsqueda de soluciones para este problema ha dado origen a activas líneas de investigación, dentro de las que se cuentan las referidas a la producción de Compiladores Certificantes, iniciadas con la introducción del Proof-Carrying Code (PCC) por G. Necula y P. Lee en 1996. Un Compilador Certificante genera, además del código ejecutable, una prueba o demostración de que dicho código no puede violar la política de seguridad preestablecida para su consumidor. Al consumidor le basta entonces someter exitosamente al código recibido a su prueba, para poder asegurar que su ejecución le resultara segura. Algunas líneas de investigación sobre compilación certificante se basan en frameworks lógicos y utilizan demostradores de teoremas, otras en modelar la seguridad mediante un sistema de tipos. Las primeras tienen la dificultad de que las pruebas son de alta complejidad, generalmente exponenciales, y muchas veces necesitan asistencia humana; mientras que las últimas, aún, sólo pueden aplicarse a políticas seguridad sumamente restringidas. Esta tesis se desarrolló dentro de un proyecto destinado a experimentar la construcción de compiladores certificantes basados en las técnicas de Análisis Estático de Flujo de Control y Datos, de difundido uso en la construcción de compiladores optimizantes. Se esperaba que este enfoque permitiera obtener soluciones lineales respecto de la longitud del programa fuente, tanto para la verificación de las pruebas obtenidas como para su generación. En dicho proyecto se definió un marco para el desarrollo de compiladores certificantes y sus correspondientes entornos de ejecución segura, al que se denominó Proof-Carrying Code based-on Static Analysis (PCC-SA). La definición, prototipación y evaluación de PCC-SA se dividió en dos tesis de maestría del INCO, Universidad de la República, Uruguay. Ambas tesis compartieron el relevamiento del Estado del Arte, el diseño general, la definición del lenguaje fuente y la evaluación global del framework, ientras que una se ocupó específicamente del diseño y la prototipación de las componentes del productor de código y la otra de las componentes del consumidor. La presente es la primera de dichas tesis (dirigida al entorno del productor). En ella se presenta a CCMini (Certifying Compiler for Mini), un compilador certificante para un subconjunto del lenguaje C, que garantiza que los programas que acepta no pueden leer variables no inicializadas y que en ellos no hay accesos a arreglos fuera de rango. Como lenguaje de código intermedio de CCMini se introducen los ´arboles sintácticos abstractos (ASA). Los ASA tiene una semántica clara que facilita la realización de los diversos análisis estáticos requeridos para generar la prueba de seguridad. Sobre el ASA del programa fuente, CCMini realiza el análisis estático, introduce anotaciones y verifica la seguridad del programa. Luego, si el programa es seguro, genera la información para el consumidor; información que consiste en el ASA anotado y en el esquema de la prueba. En los casos en que no se pueda determinar la seguridad de una computación especificada dentro del ASA (problema que no es decidible en general) CCMini anotar a una indicación de verificación en tiempo de ejecución. Con esta información el receptor correr a la prueba y si esta es exitosa generara código objeto y podrá ejecutarlo en forma segura. En la otra tesis del proyecto, que ya fue defendida, se mostraban varios casos de estudio que corroboraban la hipótesis de que tanto el proceso de generación de las pruebas como el de su verificación tenían un comportamiento lineal respecto de la longitud de los programas fuente. En esta tesis se demuestra que en el peor caso las técnicas usadas tienen un comportamiento cuadrático. Además se demuestra que la complejidad en casos reales (tanto del proceso de generación de la prueba, como el de verificación) es lineal respecto de la longitud del programa fuente. Esta demostración esta basada en la definición de una familia de programas C, a los que se llama linealmente acotables, y los cuales satisfacen algunas propiedades que se demostraron. Finalmente se inspecciona una conjunto de programas C de bibliotecas de uso universal, conjunto que comprende más de 4.000.000 de líneas de código y más de 90.000 funciones, convalidándose la hipótesis del comportamiento lineal de PCC-SA en la práctica ya que esta inspección permitió observar que estos programas pertenecen a la familia definida

A verified compiler for VLISP PreScheme

This paper describes a verified compiler for PreScheme, the implementation language for the vlisp run-time system. The compiler and proof were divided into three parts: A transformational front end that translates source text into a core language, a syntax-directed compiler that translates the core language into combinator-based tree-manipulation language, and a linearizer that translates combinator code into code for an abstract stored-program machine with linear memory for both data and code. This factorization enabled dierent proof techniques to be used for the dierent phases of the compiler, and also allowed the generation of good code. Finally, the whole process was made possible by carefully defining the semantics of vlisp PreScheme rather than just adopting Scheme's. We believe that the architecture of the compiler and its correctness proof can easily be applied to compilers for languages other than PreScheme