Results

**1 - 6**of**6**### unknown title

"... The execution of mobile code can produce unexpected behaviour which may compromise security and correctness of a software system. Proof-Carrying Components are a way to overcome this problem. Proof-Carrying 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. Proof-Carrying Components are a way to overcome this problem. Proof-Carrying 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. Proof-Carrying Components can be automatically generated using Proof-Transforming Compilers. Proof-Transforming 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 Proof-Transforming Compilers is that they do not have to be trusted. If a Proof-Transforming 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 Proof-Transforming Compiler can be embedded in a theorem prover. We have embedded the Proof-Carrying 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 non-optimized proof script. The embedding has been integrated into a Proof-

### Overview

"... Proof-Carrying Components (PCC) are a form of trusted components, for which the guarantee of quality is perhaps the strongest one possible: a mathematical proof, machine-checkable, that the component satisfies specific properties, known as the contract for the component. These properties can be more ..."

Abstract
- Add to MetaCart

Proof-Carrying Components (PCC) are a form of trusted components, for which the guarantee of quality is perhaps the strongest one possible: a mathematical proof, machine-checkable, 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 "null-pointer dereferencing " or other run-time failures. Proof-Carrying Components can be automatically generated using Proof-Transforming 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 Proof-Transforming 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 Proof-Transforming 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 Proof-Carrying 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 Proof-Carrying Components to Isabelle. The task consists of embedding boolean expressions and CIL instruction into Isabelle. Boolean expressions are used to express both contracts and pre-postcondition 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

### PRÉSERVATION DES PREUVES ET TRANSFORMATION DE PROGRAMMES

"... 84: Sciences et technologies de l'information et de la communication N ° attribué par la bibliothèque ..."

Abstract
- Add to MetaCart

84: Sciences et technologies de l'information et de la communication N ° attribué par la bibliothèque

### Certificates and Separation Logic

"... Abstract. Modular and local reasoning about object-oriented 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 object-oriented 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 proof-transforming 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 object-oriented programs to bytecode. The translation also handles proofs for concurrent programs. The bytecode logic and the proof transformation are proven sound.

### Overview

"... Proof-Carrying 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 proof-transformin ..."

Abstract
- Add to MetaCart

Proof-Carrying 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 proof-transforming 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 proof-transforming 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 proof-transforming 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