A Verified Information-Flow Architecture

SAFE is a clean-slate design for a highly secure computer system, with pervasive mechanisms for tracking and limiting information flows. At the lowest level, the SAFE hardware supports fine-grained programmable tags, with efficient and flexible propagation and combination of tags as instructions are executed. The operating system virtualizes these generic facilities to present an information-flow abstract machine that allows user programs to label sensitive data with rich confidentiality policies. We present a formal, machine-checked model of the key hardware and software mechanisms used to dynamically control information flow in SAFE and an end-to-end proof of noninterference for this model. We use a refinement proof methodology to propagate the noninterference property of the abstract machine down to the concrete machine level. We use an intermediate layer in the refinement chain that factors out the details of the information-flow control policy and devise a code generator for compiling such information-flow policies into low-level monitor code. Finally, we verify the correctness of this generator using a dedicated Hoare logic that abstracts from low-level machine instructions into a reusable set of verified structured code generators

Be My Guest: Normalizing and Compiling Programs using a Host Language

In programming language research, normalization is a process of fundamental importance to the theory of computing and reasoning about programs.In practice, on the other hand, compilation is a process that transforms programs in a language to machine code, and thus makes the programminglanguage a usable one. In this thesis, we investigate means of normalizing and compiling programs in a language using another language as the "host".Leveraging a host to work with programs of a "guest" language enables reuse of the host\u27s features that would otherwise be strenuous to develop.The specific tools of interest are Normalization by Evaluation and Embedded Domain-Specific Languages, both of which rely on a host language for their purposes. These tools are applied to solve problems in three different domains: to show that exponentials (or closures) can be eliminated from a categorical combinatory calculus, to propose a new proof technique based on normalization for showing noninterference, and to enable the programming of resource-constrained IoT devices from Haskell

Flexible Information-Flow Control

As more and more sensitive data is handled by software, its trustworthinessbecomes an increasingly important concern. This thesis presents work on ensuringthat information processed by computing systems is not disclosed to thirdparties without the user\u27s permission; i.e. to prevent unwanted flows ofinformation. While this problem is widely studied, proposed rigorousinformation-flow control approaches that enforce strong securityproperties like noninterference have yet to see widespread practical use.Conversely, lightweight techniques such as taint tracking are more prevalent inpractice, but lack formal underpinnings, making it unclear what guarantees theyprovide.This thesis aims to shrink the gap between heavyweight information-flow controlapproaches that have been proven sound and lightweight practical techniqueswithout formal guarantees such as taint tracking. This thesis attempts toreconcile these areas by (a) providing formal foundations to taint trackingapproaches, (b) extending information-flow control techniques to more realisticlanguages and settings, and (c) exploring security policies and mechanisms thatfall in between information-flow control and taint tracking and investigating whattrade-offs they incur

Securing Software in the Presence of Third-Party Modules

Modular programming is a key concept in software development where the program consists of code modules that are designed and implemented independently. This approach accelerates the development process and enhances scalability of the final product. Modules, however, are often written by third parties, aggravating security concerns such as stealing confidential information, tampering with sensitive data, and executing malicious code.Trigger-Action Platforms (TAPs) are concrete examples of employing modular programming. Any user can develop TAP applications by connecting trigger and action services, and publish them on public repositories. In the presence of malicious application makers, users cannot trust applications written by third parties, which can threaten users’ and platform’s security. We present SandTrap, a novel runtime monitor for JavaScript that can be used to securely integrate third-party applications. SandTrap enforces fine-grained access control policies at the levels of module, API, value, and context. We instantiate SandTrap to IFTTT, Zapier, and Node-RED, three popular JavaScript-driven TAPs, and illustrate how it enforces various policies on a set of benchmarks while incurring a tolerable runtime overhead. We also prove soundness and transparency of the monitoring framework on an essential model of Node-RED. Furthermore, nontransitive policies have been recently introduced as a natural fit for coarse-grained information-flow control where labels are specified at the level of modules. The flow relation does not need to be transitive, resulting in nonstandard noninterference and enforcement mechanism. We develop a lattice encoding to prove that nontransitive policies can be reduced to classical transitive policies. We also devise a lightweight program transformation that leverages standard flow-sensitive information-flow analyses to enforce nontransitive policies more permissively

Secure Compilation (Dagstuhl Seminar 18201)

Secure compilation is an emerging field that puts together advances in security, programming languages, verification, systems, and hardware architectures in order to devise secure compilation chains that eliminate many of today\u27s vulnerabilities. Secure compilation aims to protect a source language\u27s abstractions in compiled code, even against low-level attacks. For a concrete example, all modern languages provide a notion of structured control flow and an invoked procedure is expected to return to the right place. However, today\u27s compilation chains (compilers, linkers, loaders, runtime systems, hardware) cannot efficiently enforce this abstraction: linked low-level code can call and return to arbitrary instructions or smash the stack, blatantly violating the high-level abstraction. The emerging secure compilation community aims to address such problems by devising formal security criteria, efficient enforcement mechanisms, and effective proof techniques. This seminar strived to take a broad and inclusive view of secure compilation and to provide a forum for discussion on the topic. The goal was to identify interesting research directions and open challenges by bringing together people working on building secure compilation chains, on developing proof techniques and verification tools, and on designing security mechanisms

Foundations of Information-Flow Control and Effects

In programming language research, information-flow control (IFC) is a technique for enforcing a variety of security aspects, such as confidentiality of data,on programs. This Licenciate thesis makes novel contributions to the theory and foundations of IFC in the following ways: Chapter A presents a new proof method for showing the usual desired property of noninterference; Chapter B shows how to securely extend the concurrent IFC language MAC with asynchronous exceptions; and, Chapter C presents a new and simpler language for IFC with effects based on an explicit separation of pure and effectful computations

Enforcing information-flow policies by combining static and dynamic analyses

Tableau d'honneur de la Faculté des études supérieures et postdoctorales, 2018-2019Le contrôle de flot d’information est une approche prometteuse permettant aux utilisateurs decontrôler comment une application utilise leurs informations confidentielles. Il reste toutefois plusieurs défis à relever avant que cette approche ne puisse être utilisée par le grand public. Plus spécifiquement, il faut que ce soit efficace, facile à utiliser, que ça introduise peu de surcharge à l’exécution, et que ça fonctionne sur des applications et langages réels. Les contributions présentées dans cette thèse nous rapprochent de ces buts. Nous montrons qu’une combinaison d’analyse statique et dynamique permet d’augmenter l’efficacité d’un mécanisme de contrôle de flot d’information tout en minimisant la surcharge introduite. Notre méthode consiste en trois étapes : (1) à l’aide d’analyse statique, vérifier que le programme ne contient pas de fuites d’information évidentes; (2) instrumenter l’application (c.-à-d., insérer des commandes) pour prévenir les fuites d’information confidentielles à l’exécution; (3) évaluer partiellement le programme pour diminuer l’impact de l’instrumentation sur le temps d’exécution. Pour aider les utilisateurs à identifier les applications qui sont les plus susceptibles de faire fuirde l’information confidentielle (c.à.d., les applications malicieuses), nous avons développé un outil de détection de maliciel pour Android. Il a une précision de 94% et prend moins d’une seconde pour effectuer son analyse.Pour permettre aux utilisateurs de prioriser l’utilisation de ressources pour protéger l’information provenant de certaines sources, nous introduisons le concept defading labels. Pour permettre aux chercheurs de développer plus facilement et rapidement des mécanismes de contrôle de flot d’informations fiables, nous avons développé un outil permettant de générer automatiquement la spécification d’un mécanisme à partir de la spécification d’un langage de programmation. Pour permettre aux chercheurs de plus facilement communiquer leurs preuves écrites en Coq, nous avons développé un outil permettant de générer des versions en langue naturelle de preuves Coq.Information-flow control is a promising approach that enables users to track and control how applications use their sensitive information. However, there are still many challenges to be addressed before it can be used by mainstream users. Namely, it needs to be effective, easy to use, lightweight, and support real applications and languages. The contributions presented in this thesis aim to bring us closer to these goals. We show that a combination of static and dynamic analysis can increase the overall effectiveness of information-flow control without introducing too much overhead. Our method consists of three steps: (1) using static analysis, we verify that the program does not contain anyobvious information leaks; (2) we instrument the program to prevent less obvious leaks from occurring at runtime; (3) we partially evaluate the program to minimize the instrumentation’simpact on execution time. We present a static-based malware detection tool for Android that allows users to easily identify the applications that are most likely to leak sensitive information (i.e., maliciousapplications). It boasts an accuracy of 94% and takes less than a second to perform its analysis. We introduce the concept of fading-labels, which allows information-flow control mechanisms to prioritize the usage of resources to track information from certain sources. We present a tool that can, given a programming language’s specification, generate information-flow control mechanism specifications. This should allow researchers to more easily develop information-flow control mechanisms. Finally, we present a tool that can generate natural-language versions of Coq proofs so that researchers may more easily communicate their Coq proofs

Verifying Information Flow Control Libraries

Information Flow Control (IFC) is a principled approach to protecting the confidentiality and integrity of data in software systems. Intuitively, IFC sys- tems associate data with security labels that track and restrict flows of information throughout a program in order to enforce security. Most IFC techniques require developers to use specific programming languages and tools that require substantial efforts to develop or to adopt. To avoid redundant work and lower the threshold for adopting secure languages, IFC has been embedded in general-purpose languages through software libraries that promote security-by-construction with their API.This thesis makes several contributions to state-of-the-art static (MAC) and dynamic IFC libraries (LIO) in three areas: expressive power, theoretical IFC foundations and protection against covert channels. Firstly, the thesis gives a functor algebraic structure to sensitive data, in a way that it can be processed through classic functional programming patterns that do not incur in security checks. Then, it establishes the formal security guarantees of MAC, using the standard proof technique of term erasure, enriched with two-steps erasure, a novel idea that simplifies reasoning about advanced programming features, such as exceptions, mutable references and concurrency. Secondly, the thesis demonstrates that the lightweight, but coarse-grained, enforcement of dynamic IFC libraries (e.g., LIO) can be as precise and permissive as the fine-grained, but heavyweight, approach of fully-fledged IFC languages. Lastly, the thesis contributes to the design of secure runtime systems that protect IFC libraries, and IFC languages as well, against internal- and external-timing covert channels that leak information through certain runtime system resources and features, such as lazy evaluation and parallelism.The results of this thesis are supported with extensive machine-checked proof scripts, consisting of 12,000 lines of code developed in the Agda proof assistant