Exploring Robust Property Preservation for Secure Compilation

Good programming languages provide helpful abstractions for writing more secure code (types, modules, interfaces, procedures, structured control flow), but the security properties from the source language are generally not preserved when compiling a program and linking it with adversarial low-level code (e.g., a library or a legacy application). Linked low-level code that is malicious or compromised can for instance read and write the compiled program’s data and code, jump to arbitrary instructions, or smash the stack, blatantly violating any source-level abstraction. By contrast, a secure compilation chain protects source-level abstractions all the way down, ensuring that even an adversarial target-level context cannot break the security properties of a compiled program any more than some source-level context could. However, the precise class of security properties one chooses to preserve crucially impacts not only the supported security goals and the strength of the attacker model, but also the kind of protections the compilation chain has to introduce and the kind of proof techniques one can use to make sure that the protections are watertight. Since efficiently achieving and proving secure compilation at scale are challenging open problems, designers of secure compilation chains have to strike a pragmatic balance between security and efficiency that matches their application domain. To inform this difficult design decision, we thoroughly explore a large space of formal secure compilation criteria based on the preservation of properties that are robustly satisfied against arbitrary adversarial contexts. We study robustly preserving various classes of trace properties such as safety, of hyperproperties such as noninterference, and of relational hyperproperties such as trace equivalence. For each of the studied classes we propose an equivalent "property-free" characterization of secure compilation that is generally better tailored for proofs. We, moreover, order the secure compilation criteria by their relative strength, discover a collapse between preserving hyperliveness and preserving all hyperproperties, and prove several separation results. Finally, we show that even the strongest of our secure compilation criteria, the robust preservation of all relational hyperproperties, is achievable for a simple translation from a statically typed to a dynamically typed language. We prove this using a universal embedding, a context back-translation technique previously developed for fully abstract compilation. We also illustrate that for proving the robust preservation of most relational safety properties including safety, noninterference, and sometimes trace equivalence, a less powerful but more generic technique can back-translate a finite set of finite execution prefixes into a source context.