Program Logics for Certified Compilers

Appel, Andrew W.; Dockins, Robert; Hobor, Aquinas; Beringer, Lennart; Dodds, Josiah; Stewart, Gordon; Blazy, Sandrine; Leroy, Xavier

doi:10.1017/cbo9781107256552

Cited by 121 publications

(147 citation statements)

References 69 publications

Supporting

Mentioning

147

Contrasting

Order By: Relevance

“…Appel [5] uses VST (Verified Software Toolchain) [4] to prove the functional correctness of a machine-level implementation of SHA-256. In a companion effort, Beringer et al [17] connect VST with FCF (Foundational Cryptographic Framework) of Petcher and Morrisett [51], in order to provide a machine-checked proof of reductionist security for a realistic implementation of HMAC.…”

Section: High-assurance Cryptographymentioning

confidence: 99%

“…1 http://openssl.org 2 http://https://github.com/awslabs/s2n 3 https://www.bouncycastle.org/ over encrypted data stands out as one of the technologies with the highest potential to change the landscape of secure ITC, namely by improving cloud reliability and thus opening the way for new secure cloud-based applications. Projects that aim to bring secure computation over encrypted data to practice include FRESCO 4 [27], TASTY [38] and Sharemind [21].…”

Section: Introductionmentioning

confidence: 99%

“…The lowest-level component is FRESCO [27]; an existing, practical, open-source, framework for secure multi-party computation, which we use for communications and input/output. The correctness of this framework (but not its security) is part of our trusted computing base, as verifying the 4 https://github.com/aicis/fresco correctness of a Java-based communications infrastructure is out of the scope of high-assurance cryptography. The intermediate component of our stack is a verified implementation of Yao's secure function evaluation (SFE) protocol [57] based on garbled circuits and oblivious transfer.…”

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

A Fast and Verified Software Stack for Secure Function Evaluation

Almeida

Barbosa

Barthe

et al. 2017

Proceedings of the 2017 ACM SIGSAC Conference on Computer and Communications Security

View full text Add to dashboard Cite

We present a high-assurance software stack for secure function evaluation (SFE). Our stack consists of three components: i. a verified compiler (CircGen) that translates C programs into Boolean circuits; ii. a verified implementation of Yao's SFE protocol based on garbled circuits and oblivious transfer; and iii. transparent application integration and communications via FRESCO, an open-source framework for secure multiparty computation (MPC). CircGen is a general purpose tool that builds on CompCert, a verified optimizing compiler for C. It can be used in arbitrary Boolean circuit-based cryptography deployments. The security of our SFE protocol implementation is formally verified using EasyCrypt, a tool-assisted framework for building high-confidence cryptographic proofs, and it leverages a new formalization of garbled circuits based on the framework of Bellare, Hoang, and Rogaway (CCS 2012). We conduct a practical evaluation of our approach, and conclude that it is competitive with state-of-the-art (unverified) approaches. Our work provides concrete evidence of the feasibility of building efficient, verified, implementations of higher-level cryptographic systems. All our development is publicly available.

show abstract

Section: High-assurance Cryptographymentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

A Fast and Verified Software Stack for Secure Function Evaluation

Almeida

Barbosa

Barthe

et al. 2017

Proceedings of the 2017 ACM SIGSAC Conference on Computer and Communications Security

View full text Add to dashboard Cite

show abstract

“…For a program analysis tool such as Infer, integration with an organisation's programming culture and process is significant work (see O'Hearn (2015)). For proofs of properties closer to functional correctness or operating system or crypto code, effective integration within a powerful proof assistant is critical (Appel et al 2014). While these contextual questions are important, this paper will focus on the features of the logic and its model that contribute to its success, not on the additional contextual factors which are nonetheless important.…”

Section: Solving a Hard Problemmentioning

confidence: 99%

Why Separation Logic Works

2018

View full text Add to dashboard Cite

One might poetically muse that computers have the essence both of logic and machines. Through the case of the history of Separation Logic, we explore how this assertion is more than idle poetry. Separation Logic works because it merges the software engineer's conceptual model of a program's manipulation of computer memory with the logical model that interprets what sentences in the logic are true, and because it has a proof theory which aids in the crucial problem of scaling the reasoning task. Scalability is a central problem, and some would even say the central problem, in applications of logic in computer science. Separation Logic is an interesting case because of its widespread success in verification tools. For these two senses of model-the engineering/conceptual and the logical-to merge in a genuine sense, each must maintain their norms of use from their home disciplines. When this occurs, both the logic and engineering benefit greatly. Seeking this intersection of two different senses of model provides a strategy for how computer scientists and logicians may be successful. Furthermore, the history of Separation Logic for analysing programs provides a novel case for philosophers of science of how software engineers and computer scientists develop models and the components of such models. We provide three contributions: an exploration of the extent of models merging that is necessary for success in computer science; an introduction to the technical details of Separation Logic, which can be used for reasoning about other exhaustible resources; and an introduction to (a subset of) the problems, process, and results of computer scientists for those outside the field.

show abstract

“…Using the Coq proof assistant as a uniform platform for implementation of logic-based program verification tools is a well-established approach, which by now has been success-fully employed in a number of projects on certified compilers [Leroy 2006;Appel et al 2014] and verified lowlevel code [Shao 2010;Chlipala 2011;Jensen et al 2013], although, with no specific focus on abstractions for finegrained concurrency, such as protocols and auxiliary state.…”

Section: Related and Future Workmentioning

confidence: 99%

Mechanized verification of fine-grained concurrent programs

2015

View full text Add to dashboard Cite

Efficient concurrent programs and data structures rarely employ coarse-grained synchronization mechanisms (i.e., locks); instead, they implement custom synchronization patterns via fine-grained primitives, such as compare-and-swap. Due to sophisticated interference scenarios between threads, reasoning about such programs is challenging and error-prone, and can benefit from mechanization.In this paper, we present the first completely formalized framework for mechanized verification of full functional correctness of fine-grained concurrent programs. Our tool is based on the recently proposed program logic FCSL. It is implemented as an embedded domain-specific language in the dependently-typed language of the Coq proof assistant, and is powerful enough to reason about programming features such as higher-order functions and local thread spawning. By incorporating a uniform concurrency model, based on state-transition systems and partial commutative monoids, FCSL makes it possible to build proofs about concurrent libraries in a thread-local, compositional way, thus facilitating scalability and reuse: libraries are verified just once, and their specifications are used ubiquitously in client-side reasoning. We illustrate the proof layout in FCSL by example, and report on our experience of using FCSL to verify a number of concurrent algorithms and data structures.

show abstract

Program Logics for Certified Compilers

Cited by 121 publications

References 69 publications

A Fast and Verified Software Stack for Secure Function Evaluation

A Fast and Verified Software Stack for Secure Function Evaluation

Why Separation Logic Works

Mechanized verification of fine-grained concurrent programs

Contact Info

Product

Resources

About