Results 1 
7 of
7
Integrating ProofTransforming Compilation into EiffelStudio
, 2008
"... Compilation from Eiffel to CIL 6 2.1 Background on the logic for Eiffel and the logic for CIL Bytecode.. 6 ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
Compilation from Eiffel to CIL 6 2.1 Background on the logic for Eiffel and the logic for CIL Bytecode.. 6
Certificates and Separation Logic
"... Abstract. Modular and local reasoning about objectoriented programs has been widely studied for programing languages such as C # and Java. Once source programs have been proven, the next verification challenge is to ensure that the code produced by the compiler is correct. Since verifying a compile ..."
Abstract
 Add to MetaCart
Abstract. Modular and local reasoning about objectoriented programs has been widely studied for programing languages such as C # and Java. Once source programs have been proven, the next verification challenge is to ensure that the code produced by the compiler is correct. Since verifying a compiler can be extremely complex, this paper uses prooftransforming compilation, an alternative approach which automatically generates certificates, a bytecode proof, from proofs in the source language. The paper develops a bytecode logic using separation logic, and proof translation from proofs of objectoriented programs to bytecode. The translation also handles proofs for concurrent programs. The bytecode logic and the proof transformation are proven sound.
Overview
"... ProofCarrying Components (PCC) are a form of trusted components, for which the guarantee of quality is perhaps the strongest one possible: a mathematical proof, machinecheckable, that the component satisfies specific properties, known as the contract for the component. These properties can be more ..."
Abstract
 Add to MetaCart
ProofCarrying Components (PCC) are a form of trusted components, for which the guarantee of quality is perhaps the strongest one possible: a mathematical proof, machinecheckable, that the component satisfies specific properties, known as the contract for the component. These properties can be more or less extensive: they might characterize all that's interesting about the component's behavior, or just some specific aspects, such as absence of "nullpointer dereferencing " or other runtime failures. ProofCarrying Components can be automatically generated using ProofTransforming Compilers [4, 5, 6]. PTCs are similar to certifying compilers in PCC, but take a source proof as input and produce the bytecode proof. An important property of ProofTransforming Compilers is that they do not have to be trusted. If the compiler produces a wrong specification or a wrong proof for a component, the proof checker will reject the component. To show the feasibility of ProofTransforming Compilers, Nordio, Karahan, Guex and Hess [7,8,9] have implemented a PTC for a subset of Eiffel. The compiler takes a proof of an Eiffel program in XML format and produces the bytecode proof. However, the bytecode proof produced as result is not embedded in any theorem prover. This project consists of embedding the ProofCarrying Components into Isabelle. The components are automatically generated by the PTC. The compiler produces an AST of the component. The goal of this project is embedding the component into Isabelle. Scope of the work This project will develop a translator for ProofCarrying Components to Isabelle. The task consists of embedding boolean expressions and CIL instruction into Isabelle. Boolean expressions are used to express both contracts and prepostcondition of the proof. The formal grammar is the following: datatype EiffelContract = Requires boolExpr  ensures boolExpr datatype boolExpr = Const bool  Neg boolExpr  And boolExpr boolExpr  Or boolExpr boolExpr  AndThen boolExpr boolExpr  OrElse boolExpr boolExpr
Embedding ProofCarrying . . .
"... The execution of mobile code can produce unexpected behaviour which may compromise security and correctness of a software system. ProofCarrying Components are a way to overcome this problem. ProofCarrying Components carry a mathematical proof showing that the component satisfies certain properties ..."
Abstract
 Add to MetaCart
The execution of mobile code can produce unexpected behaviour which may compromise security and correctness of a software system. ProofCarrying Components are a way to overcome this problem. ProofCarrying Components carry a mathematical proof showing that the component satisfies certain properties, known as the contract of the component. A code consumer can check the mathematical proof attached to the component before executing the mobile code. In this way, the consumer can make sure in advance that the mobile code will be executed in a safe way. ProofCarrying Components can be automatically generated using ProofTransforming Compilers. ProofTransforming Compilers are compilers that take a source proof with contracts as input and produce a bytecode proof and its contract as output. An important property of ProofTransforming Compilers is that they do not have to be trusted. If a ProofTransforming Compiler produces a wrong specification or a wrong proof for a component, the proof checker of the code consumer will reject the component. In this Master thesis, we show how a bytecode proof produced as output of a ProofTransforming Compiler can be embedded in a theorem prover. We have embedded the ProofCarrying Components into Isabelle, using shallow embedding for the component contracts and a deep embedding for the bytecode instructions. To show that a component satisfies its contract, the generator produces a proof script. We have optimized this proof script and the measurements show that proofs are checked at least twice as fast compared to the nonoptimized proof script. The embedding has been integrated into a Proof
Overview
"... ProofCarrying Code [6] is a technique that allows one to execute mobile code in a safe way. To produce the proof automatically, Certifying Compilers [7] cab be used. However, proof can only be generated automatically for a restricted set of properties (e.g type safe properties). A prooftransformin ..."
Abstract
 Add to MetaCart
ProofCarrying Code [6] is a technique that allows one to execute mobile code in a safe way. To produce the proof automatically, Certifying Compilers [7] cab be used. However, proof can only be generated automatically for a restricted set of properties (e.g type safe properties). A prooftransforming compiler (PTC) is a compiler that takes a source proof as input and produces a bytecode proof. Using this approach, we can generate a proof in the source language (which is simpler than generating the proof in the bytecode level) and translate it to bytecode. This project consists of the integration of a prooftransforming compiler for Eiffel into Eiffel Studio. The compiler takes a source proof in XML format and produces the bytecode proof. The source proofs are generated automatically using Ballet. The project will investigate the integration of the prooftransforming compiler with Ballet. Scope of the work This project will develop a proof translator for Eiffel proof and it will be integrated into EiffelStudio. The compiler will translate the following rules: • assignment, conditional, compositional instructions • loops, rescue rule, remove