Building certified libraries for PCC: dynamic storage allocation

Authors:
Dachuan Yu;Nadeem A. Hamid;Zhong Shao
Affiliations:
Department of Computer Science, Yale University, New Haven, CT;Department of Computer Science, Yale University, New Haven, CT;Department of Computer Science, Yale University, New Haven, CT
Venue:
Science of Computer Programming - Special issue on 12th European symposium on programming (ESOP 2003)
Year:
2004

Citing 16
Cited 13

The calculus of constructions

Information and Computation - Semantics of Data Types
The C programming language

The C programming language
A syntactic approach to type soundness

Information and Computation
Safe kernel extensions without run-time checking

OSDI '96 Proceedings of the second USENIX symposium on Operating systems design and implementation
Proof-carrying code

Proceedings of the 24th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
From system F to typed assembly language

POPL '98 Proceedings of the 25th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
The design and implementation of a certifying compiler

PLDI '98 Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation
A certifying compiler for Java

PLDI '00 Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation
Proof of a program: FIND

Communications of the ACM
An axiomatic basis for computer programming

Communications of the ACM
Separation Logic: A Logic for Shared Mutable Data Structures

LICS '02 Proceedings of the 17th Annual IEEE Symposium on Logic in Computer Science
Dynamic Storage Allocation: A Survey and Critical Review

IWMM '95 Proceedings of the International Workshop on Memory Management
Inductive Definitions in the system Coq - Rules and Properties

TLCA '93 Proceedings of the International Conference on Typed Lambda Calculi and Applications
Foundational Proof-Carrying Code

LICS '01 Proceedings of the 16th Annual IEEE Symposium on Logic in Computer Science
Compiling with proofs

Compiling with proofs
Verification of non-functional programs using interpretations in type theory

Journal of Functional Programming

Verification of safety properties for concurrent assembly code

Proceedings of the ninth ACM SIGPLAN international conference on Functional programming
Certified assembly programming with embedded code pointers

Conference record of the 33rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Certified memory management for proof-carrying code: a region-based type system and runtime library

Proceedings of the 43rd annual Southeast regional conference - Volume 2
Integrating a certified memory management runtime with proof-carrying code

Proceedings of the 2007 ACM symposium on Applied computing
Certified self-modifying code

Proceedings of the 2007 ACM SIGPLAN conference on Programming language design and implementation
An Overview of Separation Logic

Verified Software: Theories, Tools, Experiments
Compiling functional types to relational specifications for low level imperative code

Proceedings of the 4th international workshop on Types in language design and implementation
Certifying concurrent programs using transactional memory

Journal of Computer Science and Technology
Verified just-in-time compiler on x86

Proceedings of the 37th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Formally certified stable marriages

Proceedings of the 48th Annual Southeast Regional Conference
CertiKOS: a certified kernel for secure cloud computing

Proceedings of the Second Asia-Pacific Workshop on Systems
Formal verification of the heap manager of an operating system using separation logic

ICFEM'06 Proceedings of the 8th international conference on Formal Methods and Software Engineering
Abstracting allocation

CSL'06 Proceedings of the 20th international conference on Computer Science Logic

Quantified Score

Hi-index	0.01

Visualization

Abstract

Proof-carrying code (PCC) allows a code producer to provide to a host a program along with its formal safety proof. The proof attests to a certain safety policy enforced by the code, and can be mechanically checked by the host. While this language-based approach to code certification is very general in principle, existing PCC systems have only focused on programs whose safety proofs can be automatically generated. As a result, many low-level system libraries (e.g., memory management) have not yet been handled. In this paper, we explore a complementary approach in which general properties and program correctness are semi-automatically certified. In particular, we introduce a low-level language, CAP, for building certified programs and present a certified library for dynamic storage allocation.