A verified information-flow architecture

Abstract

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.

Keywords

Security clean-slate design tagged architecture information-flow control formal verification refinement

1. Introduction

The SAFE design is motivated by the conviction that the insecurity of present-day computer systems is due in large part to legacy design decisions left over from an era of scarce hardware resources. The time is ripe for a complete rethink of the entire system stack with security as the central focus. In particular, designers should be willing to spend more of the abundant processing power available on today’s chips to improve security.

A key feature of SAFE is that every piece of data, down to the word level, is annotated with a tag representing policies that govern its use. While the tagging mechanism is very general [9,34], one particularly interesting use of tags is for representing information-flow control (IFC) policies. For example, an individual record might be tagged “This information should only be seen by principals Alice or Bob,” a function pointer might be tagged “This code is trusted to work with Carol’s secrets,” or a string might be tagged “This came from the network and has not been sanitized yet.” Such tags representing IFC policies can involve arbitrary sets of principals, and principals themselves can be dynamically allocated to represent an unbounded number of entities within and outside the system.

At the programming-language level, rich IFC policies have been extensively explored, with many proposed designs for static [43,51,68,73,77,96] and dynamic [4–7,40,44,72,75,78,88] enforcement mechanisms and a huge literature on their formal properties [43,77, etc.]. Similarly, operating systems with information-flow tracking have been a staple of the OS literature for over a decade [36,55,56,66,97,97]. But progress at the hardware level has been more limited, with most proposals concentrating on hardware acceleration for taint-tracking schemes [19,25,26,31,32,89,92]. SAFE extends the state of the art in two significant ways. First, the SAFE machine offers hardware support for sound and efficient purely-dynamic tracking of both explicit and implicit flows (i.e., information leaks through both data and control flow) for arbitrary machine code programs – not just programs accepted by static analysis, or produced by translation or transformation. Moreover, rather than using just a few “taint bits,” SAFE associates a word-sized tag to every word of data in the machine – both memory and registers. In particular, SAFE tags can be pointers to arbitrary data structures in memory. The interpretation of these tags is left entirely to software: the hardware just propagates tags from operands to results as each instruction is executed, following software-defined rules. Second, the SAFE design has been informed from the start by an intensive effort to formalize critical properties of its key mechanisms and produce machine-checked proofs, in parallel with the design and implementation of its hardware and system software. Though some prior work (surveyed in Section 12) shares some of these aims, to the best of our knowledge no project has attempted this combination of innovations.

Abstractly, the tag propagation rules in SAFE can be viewed as a partial function from argument tuples of the form (opcode, pc tag, argument₁ tag, argument₂ tag, …) to result tuples of the form (new pc tag, result tag), meaning “if the next instruction to be executed is opcode, the current tag of the program counter (PC) is pc tag, and the arguments expected by this opcode are tagged argument₁ tag, etc., then executing the instruction is allowed and, in the new state of the machine, the PC should be tagged new pc tag and any new data created by the instruction should be tagged result tag.” (The individual argument-result pairs in this function’s graph are called rule instances, to distinguish them from the symbolic rules used at the software level.) In general, the graph of this function in extenso will be huge; so, concretely, the hardware maintains a cache of recently-used rule instances. On each instruction dispatch (in parallel with the logic implementing the usual behavior of the instruction – e.g., addition), the hardware forms an argument tuple as described above and looks it up in the rule cache. If the lookup is successful, the result tuple includes a new tag for the PC and a tag for the result of the instruction (if any); these are combined with the ordinary results of instruction execution to yield the next machine state. Otherwise, if the lookup is unsuccessful, the hardware invokes a cache fault handler – a trusted piece of system software with the job of checking whether the faulting combination of tags corresponds to a policy violation or whether it should be allowed. In the latter case, an appropriate rule instance specifying tags for the instruction’s results is added to the cache, and the faulting instruction is restarted. Thus, the hardware is generic and the interpretation of policies (e.g., IFC, memory safety or control flow integrity [9,34]) is programmed in software, with the results cached in hardware for common-case efficiency.

The first contribution of this paper is to explain and formalize, in the Coq proof assistant [90], the key ideas in this design via a simplified model of the SAFE machine, embodying its tagging mechanisms in a distilled form and focusing on enforcing IFC using these general mechanisms. In Section 2, we outline the features of the full SAFE system and enumerate the most significant simplifications in our model. In Section 3, we present the high-level programming interface of our model, embodied by an abstract IFC machine with a built-in, purely dynamic IFC enforcement mechanism and an abstract lattice of IFC labels. We then show, in three steps, how this abstract machine can be implemented using the low-level mechanisms we propose. The first step introduces a symbolic IFC rule machine that reorganizes the semantics of the abstract machine, splitting out the IFC enforcement mechanism into a separate judgment parameterized by a symbolic IFC rule table (Section 4). The second step defines a generic concrete machine (Section 5) that provides low-level support for efficiently implementing many different high-level policies (IFC and others) with a combination of a hardware rule cache and a software fault handler. The final step instantiates the concrete machine with a concrete fault handler enforcing IFC. We do this using an IFC fault handler generator (Section 6), which compiles the symbolic IFC rule table into a sequence of machine instructions implementing the IFC enforcement judgment.

Our second contribution is a machine-checked proof that this simplified SAFE system is correct and secure, in the sense that user code running on the concrete machine equipped with the IFC fault handler behaves the same way as on the abstract machine and enjoys the standard noninterference property that “high inputs do not influence low outputs.” The interplay of the concrete machine and fault handler is complex, so some proof abstraction is essential. (Previous projects such as the CompCert compiler [58], the seL4 [54,66] and CertiKOS [39,82] microkernels, and the RockSalt SFI checker [65] have demonstrated the need for significant attention to organization in similar proofs.) In our proof architecture, a first abstraction layer is based on refinement. This allows us to reason in terms of a high-level view of memory, ignoring the concrete implementation of IFC labels, while setting up the intricate indistinguishability relation used in the noninterference proof. A second layer of abstraction is required for reasoning about the correctness of the fault handler. Here, we rely on a verified custom Hoare logic that abstracts from low-level machine instructions into a reusable set of verified structured code generators.

In Section 7 we prove that the IFC fault handler generator correctly compiles a symbolic IFC rule table and a concrete representation of an abstract label lattice into an appropriate sequence of machine instructions. We then introduce a standard notion of refinement (Section 8) and show that the concrete machine running the generated IFC fault handler refines the abstract IFC machine and vice-versa, using the symbolic IFC rule machine as an intermediate refinement point in each direction of the proof (Section 9). In our deterministic setting, showing refinement in both directions guarantees that the concrete machine does not diverge or get stuck when handling a fault. We next introduce a standard termination-insensitive noninterference (TINI) property (Section 10) and show that it holds for the abstract machine. Since deterministic TINI is preserved by refinement, we conclude that the concrete machine running the generated IFC fault handler also satisfies TINI. In Section 11, we explain how the programming model and formal development of the first sections can be extended to accommodate two important features: dynamic memory allocation and tags representing sets of principals. This extension, carried out after the development of the basic model, gives us confidence in the robustness of our methodology. We close with a survey of related work (Section 12) and a discussion of future directions (Section 13). Our Coq formalization is available at https://github.com/micro-policies/verified-ifc.

A preliminary abridged version of this work appeared in the proceedings of the POPL 2014 conference [8]. This extended and improved version includes:

more examples and clarifying explanations in the formal sections;

a more detailed technical description of the formalization: the semantics of the abstract, symbolic and concrete machines, the language for expressing symbolic IFC rules, our verified structured code generators, and TINI-preserving refinements;

more details of the proofs;

a more extensive discussion of related work, including more recent work on transplanting the tagging mechanism of SAFE onto a mainstream RISC processor [29] and using it to enforce properties beyond IFC [9,34].

2. Overview of SAFE

To establish context, we begin with a brief overview of the full SAFE system, concentrating on its OS- and hardware-level features. More detailed descriptions can be found elsewhere [30,33–35,45,46,57,63]. SAFE’s system software performs process scheduling, stream-based interprocess communication, storage allocation and garbage collection, and management of the low-level tagging hardware (the focus of this paper). The goal is to organize these services as a collection of mutually suspicious compartments following the principle of least privilege (a zero-kernel OS [84]), so that an attacker would need to compromise multiple compartments to gain complete control of the machine. It is programmed in a combination of assembly and Tempest, a new low-level systems programming language.

The SAFE hardware integrates a number of mechanisms for eliminating common vulnerabilities and supporting higher-level security primitives. To begin with, SAFE is (dynamically) typed at the hardware level: each data word is indelibly marked as a number, an instruction, a pointer, etc. Next, the hardware is memory safe: every pointer consists of a triple of base, bounds, and offset (compactly encoded into 64 bits [35,57]), and every pointer operation includes a hardware bounds check [57]. Finally, the hardware associates each word in the registers and memory, as well as the PC, with a large (59-bit) tag. The hardware rule cache, enabling software-specified propagation of tags from operands to result on each machine step, is implemented using a combination of multiple hash functions to approximate a fully-associative cache [33].

An unusual feature of the SAFE design is that formal modeling and verification of its core mechanisms have played a central role in the design process since the beginning. The original goal – formally specifying and verifying the entire set of critical runtime services – proved to be too ambitious, but key security properties of simplified models have been verified both at the level of Breeze [45] (a mostly functional, security-oriented, dynamic language used for user-level programming on SAFE) and, in the present work, at the hardware and abstract machine level. We also used random testing of properties like noninterference as a means to speed the design process [46].

Our goal in this paper is to develop a clear, precise, and mathematically tractable model of one of the main innovations in the SAFE design: its scheme for efficiently supporting high-level data use policies using a combination of hardware and low-level system software. To make the model easy to work with, we simplify away many important facets of the real SAFE system. In particular, (i) we focus only on IFC and noninterference, although the tagging facilities of the SAFE machine are generic and can be applied to other policies (more recent work illustrates this point [8,34]; we return to it at the end of Section 12); (ii) we ignore the Breeze and Tempest programming languages and concentrate on the hardware and runtime services; (iii) we use a stack instead of registers, and we distill the instruction set to just a handful of opcodes; (iv) we drop SAFE’s fine-grained privilege separation in favor of a more conventional user-mode/kernel-mode dichotomy; (v) we shrink the rule cache to a single entry (avoiding issues of replacement and eviction) and maintain it in kernel memory, accessed by ordinary loads and stores, rather than in specialized cache hardware; (vi) we focus on termination-insensitive noninterference and omit a large number of more advanced IFC-related concepts that are supported by the real SAFE system (dynamic principals, downgrading, public labels, integrity, clearance, etc.); (vii) we handle exceptional conditions, including potential security violations, by simply halting the whole machine; and (viii) most importantly, we ignore concurrency, process scheduling, and interprocess communication, assuming instead that the whole machine has a single, deterministic thread of control. We believe that most of these restrictions can be lifted without fundamentally changing the structure of the model or of the proofs. For instance, recent follow-on work by some of the authors [47] discusses a mechanized proof of noninterference for a similar abstract machine featuring registers and a richer IFC policy. The absence of concurrency is a particularly significant simplification, given that we are talking about an operating system that offers IFC as a service. However, we conjecture that it may be possible to add concurrency to our formalization, while maintaining a high degree of determinism, by adapting the approach used in the proof of noninterference for the seL4 microkernel [66,67]. We return to this point in Section 13.

3. Abstract IFC machine

We begin the technical development by defining a very simple stack-and-pointer machine with “hard-wired” dynamic IFC. This machine concisely embodies the IFC mechanism we want to provide to higher-level software and serves as a specification for the symbolic IFC rule machine (Section 4) and for the concrete machine (Section 5) running our IFC fault handler (Section 6). The three machines share a tiny instruction set (Fig. 1) designed to be a convenient target for compiling the symbolic IFC rule table into machine instructions (the Coq development formalizes several other instructions, including $Sub$ , $Pop$ , a variant of $Call$ that takes a variable number of arguments and a variant of $Ret$ that allows returning a result on the stack). All three machines use a fixed instruction memory ι, a partial function from (non-negative) integer addresses to instructions.

Fig. 1.

Instruction set.

The machine manipulates integers (ranged over by n, m, and p); unlike the real SAFE machine, we make no distinction between raw integers and pointers (we re-introduce this distinction in Section 11). Each integer is marked with an individual IFC label (ranged over by L) that denotes its security level. We call a pair of an integer n and its corresponding label L an atom, written $n @ L$ and ranged over by a. We assume that IFC labels L form a set $L$ equipped with a partial order (⩽), a least upper bound operation (∨), and a bottom element (⊥), but do not place further requirements on them. This generality allows us to model many different kinds of labels present in existing IFC systems [63]. For instance we might take $L$ to be the set of levels ${⊥, ⊤}$ with $⊥ ⩽ ⊤$ and $⊥ \lor ⊤ = ⊤$ . Alternatively, we could consider a richer set of labels, such as finite sets of principals ordered by set inclusion, as discussed in Section 11.

An abstract machine state $⟨ μ [σ] pc ⟩$ consists of a data memory μ, a stack σ, and a program counter $pc$ . (We sometimes drop the outer brackets.) The data memory μ is a partial function from integer addresses to atoms. We write $μ (p) \leftarrow a$ for the memory that coincides with μ everywhere except at p, where its value is a. The stack σ is essentially a list of atoms, but we distinguish stacks beginning with return addresses (written $pc; σ$ ) from ones beginning with regular atoms (written $a, σ$ ). Formally, stacks are lists with two “cons” constructors, written “,” and “;”. This distinction is needed so that stack-manipulating instructions treat frame markers specially; for example, a program that $Push$ es an integer and then attempts to return to it is treated as erroneous by the operational semantics. The program counter (PC) $pc$ is an atom whose label is used to track implicit flows, as explained below.

Fig. 2.

Semantics of abstract IFC machine.

The step relation of the abstract machine, written $ι ⊢ μ_{1} [σ_{1}] p c_{1} \overset{α}{\to} μ_{2} [σ_{2}] p c_{2}$ , is a partial function taking a machine state to a machine state plus an output action α, which can be either an atom or the silent action τ. We generally omit the instruction memory ι from transitions because it is fixed. Throughout the paper we consistently refer to non-silent actions as events (ranged over by e).

The stepping rules in Fig. 2 adapt a standard purely dynamic IFC enforcement mechanism [4,75] to a low-level machine, following recent work by Hriţcu et al. [46]. (Readers less familiar with the intricacies of dynamic IFC may find some of these side conditions a bit mysterious. A longer explanation can be found in [46], but the details are not critical for present purposes.) The rule for $Add$ joins (∨) the labels of the two operands to produce the label of the result, which ensures that the result is at least as classified as each of the operands. For example, suppose $ι = [\dots, Add, \dots]$ and n is the index of this $Add$ instruction. Then $μ [7 @ ⊥, 5 @ ⊤] n @ ⊥ \overset{τ}{\to} μ [12 @ ⊤] (n + 1) @ ⊥$ . The rule for $Push$ labels the integer constant added to the stack as public (⊥). The rule for $Jump$ uses join to raise the label of the PC by the label of the target address of the jump. Similarly, $Bnz$ raises the label of the PC by the label of the tested integer. In both cases the value of the PC after the instruction depends on data that could be secret, and we use the label of the PC to track the label of data that has influenced control flow. In order to prevent implicit flows (leaks exploiting the control flow of the program), the $Store$ rule joins the PC label with the original label of the written integer and with the label of the pointer through which the write happens. Additionally, since the labels of memory locations are allowed to vary during execution, we prevent leaking information via labels using a “no-sensitive-upgrade” check [4,96] (the ⩽ precondition in the rule for $Store$ ).1

More recent work further improves precision compared to the no-sensitive-upgrades policy [5,15,44,46]. We adopted no-sensitive-upgrades in this work because it is simpler and requires less bookkeeping.

This check prevents memory locations labeled public from being overwritten when either the PC or the pointer through which the store happens has been influenced by secrets. The

Output

rule labels the emitted integer with the join of its original label and the current PC label.2

We assume the observer of the events generated by $Output$ is constrained by the rules of information flow – i.e., cannot freely “look inside” bare events. In the real SAFE machine, atoms being sent to the outside world need to be protected cryptographically; we are abstracting this away.

Finally, because of the structured control flow imposed by the stack discipline, the rule for

Ret

can soundly restore the PC label to whatever it was at the time of the

Call

. This feature allows programmers to avoid label creep – i.e., having the current PC label inadvertently go up when branching on secrets unknowingly – by making judicious use of

Call

and

Ret

, but may require careful thought to be used correctly. Many other solutions have been proposed to this problem, each with their own strengths and weaknesses. Some systems, such as LIO [86], prevent label creep by maintaining a clearance level that serves as an upper bound on the PC label; this, however, may lead to dynamic errors if a computation tries to inspect a secret above its clearance.

All data in the machine’s state are labelled, and this simple machine manages labels to ensure noninterference as defined and proved in Section 10. There are no instructions that dynamically raise the label (classification) of an atom. Such an instruction, joinP, is added to the machine in Section 11.

4. Symbolic IFC rule machine

In the abstract machine described above, IFC is tightly integrated into the step relation in the form of side conditions on each instruction. In contrast, the concrete machine (i.e., the “hardware”) described in Section 5 is generic, designed to support a wide range of software-defined policies (IFC and other). The machine introduced in this section serves as a bridge between these two models. It is closer to the abstract machine – indeed, its machine states and the behavior of the step relation are identical. The important difference lies in the definition of the step relation, where all the IFC-related aspects are factored out into a separate judgment. We can think of the IFC mechanism as being implemented in a separate “IFC rule processor” distinct from the main “CPU.” In the concrete machine, the CPU part will remain unchanged, but the IFC rule processor will be implemented mostly in software (by the fault handler), with the hardware only providing caching of rule instances. While factoring out IFC enforcement into a separate reference monitor [80] is commonplace [2,75,78], our approach goes further. We define a small DSL for describing symbolic IFC rules and obtain actual monitors by interpreting this DSL (in this section) and by compiling it into machine instructions using verified structured code generators (in Section 6 and Section 7). This architecture makes it easier to implement other IFC mechanisms (e.g., permissive upgrades [5]), beyond the simple one in Section 3. Since the DSL compilation is verified, we prove that the concrete machine of Section 5 is noninterfering when given any correct monitor written in the DSL. Showing that a monitor is correct, on the other hand, involves a simple refinement proof (Lemma 9.2), and a noninterference proof for the abstract machine (Theorem 10.5), but is independent of the code generation infrastructure and corresponding proofs.

Fig. 3.

Semantics of symbolic rule machine, parameterized by $R$ .

More formally, each stepping rule of the new machine (see Fig. 3) includes a uniform call to an IFC enforcement relation, which itself is parameterized by a symbolic IFC rule table $R$ . Given the labels of the values relevant to an instruction, the IFC enforcement relation (i) checks whether the execution of that instruction is allowed in the current configuration, and (ii) if so, yields the labels to put on the resulting PC and on any resulting value. This judgment has the form $⊢_{R} (L_{p c}, ℓ_{1}, ℓ_{2}, ℓ_{3}) ⇝_{op} L_{rpc}, L_{r}$ , where the 4-tuple on the left-hand side represents the input PC label and three additional input labels (more precisely, optional labels, as the number of relevant labels depends on the opcode but the tuple is of fixed size), $o p$ is an opcode, and $L_{rpc}$ and $L_{r}$ are the resulting output labels (of which the second might be ignored).

Let us illustrate, for a few cases, how this new judgment is used in the stepping relation (Fig. 3). The stepping rule for $Add$ passes three inputs to the IFC enforcement judgment: $L_{p c}$ , the label of the current PC, and $L_{1}$ and $L_{2}$ , the labels of the two operands at the top of the stack. (The fourth element of the input tuple is written as $\underline{}$ because it is not needed for $Add$ .) The IFC enforcement judgment produces two labels: $L_{rpc}$ is used to label the next program counter ( $n + 1$ ) and $L_{r}$ is used to label the result value. All the other stepping rules follow a similar scheme. (The one for $Store$ uses all four input labels. In this stepping rule the resulting label $L_{r}$ is used to label the new value m to be stored at location p.)

A symbolic IFC rule table $R$ describes a particular IFC enforcement mechanism. For instance, the rule table $R^{abs}$ corresponding to the IFC mechanism of the abstract machine is shown in Fig. 4. In general, a table $R$ associates a symbolic IFC rule to each instruction opcode (formally, $R$ is a total function). Each of these rules is formed of three symbolic expressions: (i) a boolean expression indicating whether the execution of the instruction is allowed or not (i.e., whether it violates the IFC enforcement mechanism); (ii) a label-valued expression for $L_{rpc}$ , the label of the next PC; and (iii) a label-valued expression for $L_{r}$ , the label of the result value, if there is one. In cases where $L_{r}$ is not used by the corresponding opcode, we write $__$ to mean “don’t care,” which is a synonym for $BOT$ (the symbolic representation of the ⊥ label).

Fig. 4.

Rule table $R^{abs}$ corresponding to abstract IFC machine.

These symbolic expressions are written in a simple domain-specific language (DSL) of operations over an IFC lattice. The grammar of this DSL (Fig. 5) includes label variables ${LAB}_{pc}, \dots, {LAB}_{3}$ , which correspond to the input labels $L_{p c}, \dots, L_{3}$ ; the constant $BOT$ ; and the lattice operators ⊔ (join) and ⊑ (flows).

Fig. 5.

Symbolic IFC rule language syntax.

The IFC enforcement judgment looks up the corresponding symbolic IFC rule in the table and directly evaluates the symbolic expressions in terms of the corresponding lattice operations. In contrast, in Section 6 we compile this rule table into the IFC fault handler for the concrete machine. Formally, the IFC enforcement judgment is defined by the two following cases, depending on whether the second output label is relevant or not:

Here ρ is a 4-tuple of labels, ${Rule}_{R}$ looks up the relevant opcode in rule table $R$ , and the expression evaluation judgment $ρ ⊢ \dots$ is defined in Fig. 6.

Fig. 6.

Symbolic IFC rule language semantics.

5. Concrete machine

The concrete machine provides low-level support for efficiently implementing many different high-level policies (IFC and others) with a combination of a hardware rule cache and a software cache fault handler. In this section we focus on the concrete machine’s hardware, which is completely generic, while in Section 6 we describe a specific fault handler corresponding to the IFC rules of the symbolic rule machine.

The concrete machine has the same general structure as the more abstract ones, but differs in several important respects. One is that it annotates data values with integer tags $T$ , rather than with labels L from an abstract lattice; thus, the concrete atoms a in the data memories and the stack have the form $n @ T$ . Similarly, a concrete action α is either a concrete atom or the silent action τ. We consistently use the word label and variable L to refer to the (abstract, lattice-structured) labels of the abstract and symbolic rule machines and the word tag and variable $T$ for concrete integers representing labels. Using plain integers as tags allows us to delegate their interpretation entirely to software. In this paper we focus solely on using tags to implement IFC labels, although they could also be used for enforcing other policies, such as type and memory safety or control-flow integrity [9,34]. For instance, to implement the two-point abstract lattice with $⊥ ⩽ ⊤$ , we could use 0 to represent ⊥ and 1 to represent ⊤, making the operations ∨ and ⩽ easy to implement (see Section 6). For richer abstract lattices, a more complex concrete representation might be needed; for example, a label containing an arbitrary set of principals might be represented concretely by a pointer to an array data structure (see Section 11). In places where a tag is needed but its value is irrelevant, the concrete machine uses a specific but arbitrary default tag value (e.g., −1), which we write $T_{D}$ .

A second important difference is that the concrete machine has two modes: user mode ( $u$ ), for executing the ordinary user program, and kernel mode ( $k$ ), for handling rule cache faults. To support these two modes, the concrete machine’s state contains a privilege bit π, a separate kernel instruction memory ϕ, and a separate kernel data memory κ, in addition to the user instruction memory ι, the user data memory μ, the stack σ, and the PC. When the machine is operating in user mode ( $π = u$ ), instructions are looked up using the PC as an index into ι, and loads and stores use μ; when in kernel mode ( $π = k$ ), the PC is treated as an index into ϕ, and loads and stores use κ. The concrete step relation has the form $ι, ϕ ⊢ π_{1} κ_{1} μ_{1} [σ_{1}] {pc}_{1} \overset{α}{\to} π_{2} κ_{2} μ_{2} [σ_{2}] {pc}_{2}$ . As before, since ι and ϕ are fixed, we normally leave them implicit when writing down machine transitions.

The concrete machine has the same instruction set as the previous ones, allowing user programs to be run on all three machines unchanged. But the tag-related semantics of instructions depends on the privilege mode, and in user mode the semantics further depends on the state of the rule cache. In the real SAFE machine, the rule cache may contain thousands of entries and is implemented as a separate near-associative memory [33] accessed by special instructions. Here, for simplicity, we use a cache with just one entry, located at the start of kernel memory, and use $Load$ and $Store$ instructions to manipulate it. When implementing simple IFC labels such as the two-point lattice defined above, the rule cache is all that needs to live in κ. More complex label models, on the other hand, such as those of Section 11, may require additional memory to store internal data structures.

The rule cache holds a single rule instance, represented graphically like this:

Location 0 holds an integer representing an opcode. (Since the exact choice of representation doesn’t matter, we will denote each opcode with a lowercase identifier – for example, we might define $add = 0$ , $output = 1$ , etc.) Location 1 holds the PC tag. Locations 2 to 4 hold the tags of any other arguments needed by this particular opcode. Location 5 holds the tag that should go on the PC after this instruction executes, and location 6 holds the tag for the instruction’s result value, if needed. For example, suppose the cache contains this:

(Note that we are showing just the “payload” part of these seven atoms; by convention, the tag part is always $T_{D}$ , and we do not display it.) This one-line rule cache should be thought of as implementing a (very) partial function: when the input is , the output is ; otherwise it is undefined. If 0 is the tag representing the label ⊥, 1 represents ⊤, and −1 is the default tag $T_{D}$ , this can be interpreted abstractly as follows: “If the next instruction is $Add$ , the PC is labeled ⊥, and the two relevant arguments are both labeled ⊤, then the instruction should be allowed, the label on the new PC should be ⊥, and the label on the result of the operation is ⊤.”

There are two sets of stepping rules governing the behavior of the concrete machine in user mode; which set applies depends on whether the current machine state matches the current contents of the rule cache. In the “cache hit” case (Fig. 7), the instruction executes normally, with the cache’s output determining the new PC tag and result tag (if any).

Fig. 7.

Concrete step relation: user mode, cache hit case.

Fig. 8.

Concrete step relation: user mode, cache miss case.

In the “cache miss” case (Fig. 8), the relevant parts of the current state (opcode, PC tag, argument tags) are stored into the input part of the single cache line and the machine simulates a $Call$ to the fault handler.

To see how this works in more detail, consider the two user-mode stepping rules for the $Add$ instruction.

In the first rule (cache hit), the side condition demands that the input part of the current cache contents have the form , where $T_{p c}$ is the tag on the current PC, $T_{1}$ and $T_{2}$ are the tags on the top two atoms on the stack, and the fourth element is the default tag. In this case, the output part of the rule, , determines the tag $T_{rpc}$ on the PC and the tag $T_{r}$ on the new atom pushed onto the stack in the next machine state.

In the second rule (cache miss), the notation $[κ_{i}, κ_{o}]$ means “let $κ_{i}$ be the input part of the current rule cache and $κ_{o}$ be the output part.” The side condition says that the current input part $κ_{i}$ does not have the desired form , so the machine needs to enter the fault handler. The next machine state is formed as follows: (i) the input part of the cache is set to the desired form $κ_{j}$ and the output part is set to ; (ii) a new return frame is pushed on top of the stack to remember the current PC and privilege bit ( $u$ ); (iii) the privilege bit is set to $k$ (which will cause the next instruction to be read from the kernel instruction memory); and (iv) the PC is set to 0, the location in the kernel instruction memory where the fault handler routine begins.

What happens next is up to the fault handler code. Its job is to examine the contents of the first five kernel memory locations and either (i) write appropriate tags for the result and new PC into the sixth and seventh kernel memory locations and then perform a $Ret$ to go back to user mode and restart the faulting instruction, or (ii) stop the machine by jumping to an invalid PC (−1) to signal that the attempted combination of opcode and argument tags is illegal.3

As explained in Section 2, in this work we assume for simplicity that policy violations are fatal. Recent work [45] has shown that it is possible to recover from IFC violations while preserving noninterference.

This mechanism is general and can be used to implement many different high-level policies (IFC and others).

Fig. 9.

Concrete step relation (kernel mode).

In kernel mode (Fig. 9), the treatment of tags is almost completely degenerate: to avoid infinite regress, the concrete machine does not consult the rule cache while in kernel mode. For most instructions, tags read from the current machine state are ignored (indicated by $\underline{}$ ) and tags written to the new state are set to $T_{D}$ . This can be seen for instance in the kernel-mode step rule for addition

The only significant exceptions to this pattern are $Load$ and $Store$ , which preserve the tag of the datum being read from or written to memory, and $Ret$ , which takes both the privilege bit and the new PC (including its tag!) from the return frame at the top of the stack. This is critical, since a $Ret$ instruction is used to return from kernel to user mode when the fault handler has finished executing.

A final point is that $Output$ is not permitted in kernel mode, which guarantees that kernel actions are always the silent action τ.

As an illustration of how all this works, suppose again that $ι = [\dots, Add, \dots]$ , and that the concrete integer tag 0 represents the abstract label ⊥, 1 represents ⊤, and −1 is $T_{D}$ . Then, in a cache-hit configuration, we have (omitting the silent τ label on transitions):

On the other hand, if the tags on both operands are 1 (i.e., ⊤), then the first step will miss in the cache and reduction will proceed as follows:

6. Fault handler for IFC

Now we assemble the pieces. A concrete IFC machine implementing the symbolic rule machine defined in Section 4 can be obtained by installing appropriate fault handler code in the kernel instruction memory of the concrete machine presented in Section 5. In essence, this handler must emulate how the symbolic rule machine looks up and evaluates the DSL expressions in a given IFC rule table. We choose to generate the handler code by compiling the lookup and DSL evaluation relations directly into machine code. (An alternative would be to represent the rule table as abstract syntax in the kernel memory and write an interpreter in machine code for the DSL, but the compilation approach seems to lead to simpler code and proofs.)

Fig. 10.

Generation of fault handler from IFC rule table.

The handler compilation scheme is given in Fig. 10. Each $gen *$ function generates a list of concrete machine instructions; the sequence generated by the top-level $genFaultHandler$ is intended to be installed starting at location 0 in the concrete machine’s kernel instruction memory. The implicit $addr *$ parameters are symbolic names for the locations of the opcode and various tags in the concrete machine’s rule cache, as described in Section 5. The entire generator is parameterized by an arbitrary rule table $R$ . We make heavy use of the (obvious) encoding of booleans where false is represented by 0 and true by any non-zero value.

The top-level handler works in three phases. The first phase, $genComputeResults$ , does most of the work: it consists of a large nested if-then-else chain, built using $genIndexedCases$ , that compares the opcode of the faulting instruction against each possible opcode and, on a match, executes the code generated for the corresponding symbolic IFC rule. The code generated for each symbolic IFC rule (by $genApplyRule$ ) pushes its results onto the stack: a flag indicating whether the instruction is allowed and, if so, the result-PC and result-value tags. This first phase never writes to memory or transfers control outside the handler; this makes it fairly easy to prove correct.

The second phase of the top-level handler, $genStoreResults$ , reads the computed results off the stack and updates the rule cache appropriately. If the result indicates that the instruction is allowed, the result PC and value tags are written to the cache, and true is pushed on the stack; otherwise, nothing is written to the cache, and false is pushed on the stack.

The third and final phase of the top-level handler tests the boolean just pushed onto the stack and either returns to user code (instruction is allowed) or jumps to address −1 (disallowed).

The code for symbolic rule compilation is built by straightforward recursive traversal of the rule DSL syntax for label-valued expressions ( $genELab$ ) and boolean-valued expressions ( $genBool$ ). These functions are (implicitly) parameterized by the definitions of lattice-specific generators $genBot$ , $genJoin$ , and $genFlows$ . To implement these generators for a particular lattice, we first need to choose how to represent abstract labels as integer tags, and then determine a sequence of instructions that encodes each operation. We call such an encoding scheme a concrete lattice. For example, the abstract labels in the two-point lattice can be encoded like booleans, representing ⊥ by 0, ⊤ by non-0, and instantiating $genBot$ , $genJoin$ , and $genFlows$ with code for computing false, disjunction, and implication, respectively. A simple concrete lattice like this can be formalized as a tuple $CL = (Tag, Lab, genBot, genJoin, genFlows)$ , where the encoding and decoding functions $Lab$ and $Tag$ satisfy $Lab \circ Tag = id$ ; to streamline the exposition, we assume this form of concrete lattice for most of the paper. The more realistic encoding in Section 11 will require a more complex treatment.

To raise the level of abstraction of the handler code, we make heavy use of structured code generators; this makes it easier both to understand the code and to prove it correct using a custom Hoare logic that follows the structure of the generators (see Section 7). For example, the $genIf$ function takes two code sequences, representing the “then” and “else” branches of a conditional, and generates code to test the top of the stack and dispatch control appropriately. The higher-order generator $genIndexedCases$ takes a list of integer indices (e.g., opcodes) and functions for generating guards and branch bodies from an index, and generates code that will run the guards in order until one of them computes true, at which point the corresponding branch body is run.

7. Correctness of the fault handler generator

We now turn our attention to verification, beginning with the fault handler. We must show that the generated fault handler emulates the IFC enforcement judgment $⊢_{R} (L_{p c}, ℓ_{1}, ℓ_{2}, ℓ_{3}) ⇝_{opcode} L_{rpc}, L_{r}$ of the symbolic rule machine. The statement and proof of correctness are parametric over the symbolic IFC rule table $R$ and concrete lattice, and hence over correctness lemmas for the lattice operations.

Correctness statement. Let $R$ be an arbitrary rule table and $ϕ_{R} ≜ genFaultHandler R$ be the corresponding generated fault handler. We specify how $ϕ_{R}$ behaves as a whole – as a relation between initial state on entry and final state on completion – using the relation $ϕ ⊢ {cs}_{1} \to_{k}^{⋆} {cs}_{2}$ , defined as the reflexive transitive closure of the concrete step relation, with the constraints that the fault handler code is ϕ and all intermediate states (i.e., strictly preceding ${cs}_{2}$ ) have privilege bit $k$ .

The correctness statement is captured by the following two lemmas. Intuitively, if the symbolic IFC enforcement judgment allows some given user instruction, then executing $ϕ_{R}$ (stored at kernel mode location 0) updates the cache to contain the tag encoding of the appropriate result labels and returns to user-mode; otherwise, $ϕ_{R}$ halts the machine ( $pc = - 1$ ).

Lemma 7.1 (Fault handler correctness, allowed case).

Suppose that $⊢_{R} (L_{p c}, ℓ_{1}, ℓ_{2}, ℓ_{3}) ⇝_{opcode} L_{rpc}, L_{r}$ and

Then $\begin{matrix} ϕ_{R} ⊢ \begin{matrix} ⟨ k & [κ_{i}, κ_{o}] & μ & [(pc, u); σ] & 0 @ T_{D} ⟩ & \to_{k}^{⋆} \\ ⟨ u & [κ_{i}, κ_{o}^{'}] & μ & [σ] & pc ⟩ \end{matrix} \end{matrix}$ with output cache $κ_{o}^{'} = (Tag (L_{rpc}), Tag (L_{r}))$ .

Lemma 7.2 (Fault handler correctness, disallowed case).

Suppose that $⊢_{R} (L_{p c}, ℓ_{1}, ℓ_{2}, ℓ_{3}) {⇝̸}_{opcode}$ , and

Then, for some final stack $σ^{'}$ , $\begin{matrix} ϕ_{R} ⊢ \begin{matrix} ⟨ k & [κ_{i}, κ_{o}] & μ & [(pc, u); σ] & 0 @ T_{D} ⟩ & \to_{k}^{⋆} \\ ⟨ k & [κ_{i}, κ_{o}] & μ & [σ^{'}] & - 1 @ T_{D} ⟩ . \end{matrix} \end{matrix}$

Proof methodology. The fault handler is compiled by composing generators (Fig. 10); accordingly, the proofs of these two lemmas reduce to correctness proofs for the generators. We employ a custom Hoare logic for specifying the generators themselves, which makes the code generation proof simple, reusable, and scalable. This is where defining a DSL for IFC rules and a structured compiler proves to be very useful approach, e.g., compared to symbolic interpretation of hand-written code.

Our logic comprises two kinds of Hoare triples. The generated code mostly consists of self-contained instruction sequences that terminate by “falling off the end” – i.e., that never return or jump outside themselves, although they may contain internal jumps (e.g., to implement conditionals). The only exception is the final step of the handler (third line of $genFaultHandler$ in Fig. 10). We therefore define a standard Hoare triple ${P} c {Q}$ , suitable for reasoning about self-contained code, and use it for the bulk of the proof. To specify the final handler step, we define a non-standard triple ${P} c {Q}_{pc}^{O}$ for reasoning about escaping code.

Self-contained-code Hoare triples. The triple ${P} c {Q}$ , where P and Q are predicates on $κ \times σ$ , says that, if the kernel instruction memory ϕ contains the code sequence c starting at the current PC, and if the current memory and stack satisfy P, then the machine will run (in kernel mode) until the PC points to the instruction immediately following the sequence c, with a resulting memory and stack satisfying Q. In symbols: $\begin{matrix} \begin{matrix} {P} c {Q} ≜ & c = ϕ (n), \dots, ϕ (n^{'} - 1) \land P (κ, σ) ⟹ \\ \exists κ^{'} σ^{'} . Q (κ^{'}, σ^{'}) \land ϕ ⊢ ⟨ k κ μ [σ] n @ T_{D} ⟩ \to_{k}^{⋆} ⟨ k κ^{'} μ [σ^{'}] n^{'} @ T_{D} ⟩ \end{matrix} \end{matrix}$ Note that the instruction memory ϕ is unconstrained outside of c, so if c is not self-contained, no triple about it will be provable; thus, these triples obey the usual composition laws (e.g., the rule of consequence).

Also, because the concrete machine is deterministic, these triples express total, rather than partial, correctness, which is essential for proving termination in Lemmas 7.1 and 7.2. To aid automation of proofs about code sequences, we give triples in weakest-precondition style.

We build proofs by composing atomic specifications of individual instructions, such as

with specifications for structured code generators, such as

(We emphasize that all such specifications are verified, not axiomatized as the inference rule notation might suggest.) We also prove a specification for the specialized case statement $genIndexedCases$ . Although this specification is quite complex when written in full detail (and thus omitted here), it is intuitively simple: given a list of indices and functions for generating guards and branches from the indices, $genIndexedCases$ will run the guards in order until one of them computes $true$ (more precisely, its integer encoding 1), at which point the corresponding branch is run.

The concrete implementations of the lattice operations are also specified using triples in this style.

For the two-point lattice, it is easy to prove that the implemented operators satisfy these specifications; Section 11 describes an analogous result for a lattice of sets of principals.

Going a bit further towards bridging the gap between the symbolic rule and concrete machines, we prove specifications for the generation of label expressions

and for the code generated to implement the application of a symbolic IFC symbolic rule. For instance, the case where the instruction is allowed is described by the following specification (the integer 1 pushed on the output stack encodes the fact that the rule is allowed):

Escaping-code Hoare triples. To be able to specify the entire code of the generated fault handler, we also define a second form of triple, ${P} c {Q}_{pc}^{O}$ , which specifies mostly self-contained, total code c that either makes exactly one jump outside of c or returns out of kernel mode. This non-locality is needed because the fault handler checks whether an information-flow violation is about to occur, and returns to the user-mode caller if not, or jumps to an invalid address otherwise. More precisely, if P and Q are predicates on $κ \times σ$ and O is a function from $κ \times σ$ to outcomes (the constants $Success$ and $Failure$ ), then ${P} c {Q}_{pc}^{O}$ holds if, whenever the kernel instruction memory ϕ contains the sequence c starting at the current PC, the current cache and stack satisfy P, and

if O computes $Success$ then the machine runs (in kernel mode) until it returns to user code at $pc$ , and Q is satisfied.

if O computes $Failure$ then the machine runs (in kernel mode) until it halts ( $p c = - 1$ in kernel mode), and Q is satisfied.

Or, in symbols,

To compose self-contained code with escaping code, we prove two composition laws for these triples, one for pre-composing with specified self-contained code and another for post-composing with arbitrary (unreachable) code:

We use these new triples to specify the $Ret$ and $Jump$ instructions, which could not be given useful specifications using the self-contained-code triples:

Everything comes together in verifying the fault handler. We use contained-code triples to specify everything except for $[Ret]$ , $[Jump]$ , and the final $genIf$ , and then use the escaping-code triple composition laws to connect the non-returning part of the fault handler to the final $genIf$ .

8. Refinement

We have two remaining verification goals. First, we want to show that the concrete machine of Section 5 (running the fault handler of Section 6 compiled from $R^{abs}$ ) enjoys TINI. Proving this directly for the concrete machine would be dauntingly complex, so instead we show that the concrete machine is an implementation of the abstract machine, for which noninterference will be much easier to prove (Section 10). Second, since a trivial always-diverging machine also has TINI, we want to show that the concrete machine is a faithful implementation of the abstract machine that emulates all its behaviors.

We phrase these two results using the notion of machine refinement, which we develop in this section, and which we prove in Section 10 to be TINI preserving. In Section 9, we prove a two-way refinement (one direction for each goal), between the abstract and concrete machines, via the symbolic rule machine in both directions.

From here on we sometimes mention different machines (abstract, symbolic rule, or concrete) in the same statement (e.g., when discussing refinement), and sometimes talk about machines generically (e.g., when defining TINI for all our machines); for these purposes, it is useful to define a generic notion of machine.

Definition 8.1.
A generic machine (or just machine) is a 5-tuple $M = (S, E, I, \cdot \dot{\to} \cdot, Init)$ , where S is a set of states (ranged over by s), E is a set of events (ranged over by e), $\cdot \dot{\to} \cdot \subseteq S \times (E + {τ}) \times S$ is a step relation, and I is a set of input data (ranged over by i) that can be used to build initial states of the machine with the function $Init \in I \to S$ . We call $E + {τ}$ the set of actions of M (ranged over by α).

Conceptually, a machine’s program is included in its input data and gets “loaded” by the function $Init$ , which also initializes the machine memory, stack, and PC. The notion of generic machine abstracts all these details, allowing uniform definitions of refinement and TINI that apply to all three of our IFC machines. To avoid stating it several times below, we stipulate that when we instantiate Definition 8.1 to any of our IFC machines, $Init$ must produce an initial stack with no return frames.

A generic step $s_{1} \overset{e}{\to} s_{2}$ or $s_{1} \overset{τ}{\to} s_{2}$ produces event e or is silent. The reflexive-transitive closure of such steps, omitting silent steps (written $s_{1} \overset{t}{\to}^{⋆} s_{2}$ ) produces traces – i.e., lists, t, of events. It is defined inductively by

where we write ϵ for the empty trace and $e . t$ for consing e to t. When the end state of a step starting in state s is not relevant we write $s \overset{e}{\to}$ , and similarly $s \overset{t}{\to}^{⋆}$ for traces.

When relating executions of two different machines through a refinement, we establish a correspondence between their traces. This relation is usually derived from an elementary relation on events, $⊳ \subseteq E_{1} \times E_{2}$ , which is lifted to actions and traces:
Definition 8.2 (Matching).

Given a relation $⊳ \subseteq E_{1} \times E_{2}$ between two sets of events, its lifts to actions and traces are defined:

We are now ready to define refinement.

Definition 8.3 (Refinement).

Let $M_{1} = (S_{1}, E_{1}, I_{1}, \cdot \dot{\to}_{1} \cdot, {Init}_{1})$ and $M_{2} = (S_{2}, E_{2}, I_{2}, \cdot \dot{\to}_{2} \cdot, {Init}_{2})$ be two machines. A refinement of $M_{1}$ into $M_{2}$ is a pair of relations $(⊳_{i}, ⊳_{e})$ , where $⊳_{i} \subseteq I_{1} \times I_{2}$ and $⊳_{e} \subseteq E_{1} \times E_{2}$ , such that whenever $i_{1} ⊳_{i} i_{2}$ and ${Init}_{2} (i_{2}) \overset{t_{2}}{\to}^{⋆}$ , there exists a trace $t_{1}$ such that ${Init}_{1} (i_{1}) \overset{t_{1}}{\to}^{⋆}$ and $t_{1} [⊳_{e}] t_{2}$ . We also say that $M_{2}$ refines $M_{1}$ . Graphically:

(Plain lines denote premises, dashed ones conclusions.)

In order to prove refinement, we need a variant that considers executions starting at arbitrary related states.

Definition 8.4 (Refinement via states).

Let $M_{1}$ , $M_{2}$ be as above. A state refinement of $M_{1}$ into $M_{2}$ is a pair of relations $(⊳_{s}, ⊳_{e})$ , where $⊳_{s} \subseteq S_{1} \times S_{2}$ and $⊳_{e} \subseteq E_{1} \times E_{2}$ , such that, whenever $s_{1} ⊳_{s} s_{2}$ and $s_{2} \overset{t_{2}}{\to}^{⋆}$ , there exists $t_{1}$ such that $s_{1} \overset{t_{1}}{\to}^{⋆}$ and $t_{1} [⊳_{e}] t_{2}$ .

If the relation on inputs is compatible with the one on states, we can use state refinement to prove refinement.

Lemma 8.5.
Suppose $i_{1} ⊳_{i} i_{2} \Rightarrow {Init}_{1} (i_{1}) ⊳_{s} {Init}_{2} (i_{2})$ , for all $i_{1}$ and $i_{2}$ . If $(⊳_{s}, ⊳_{e})$ is a state refinement then $(⊳_{i}, ⊳_{e})$ is a refinement.

Our plan to derive a refinement between the abstract and concrete machines via the symbolic rule machine requires composition of refinements. Lemma 8.6 (Refinement composition).

Let $(⊳_{i}^{12}, ⊳_{e}^{12})$ be a refinement between $M_{1}$ and $M_{2}$ , and $(⊳_{i}^{23}, ⊳_{e}^{23})$ a refinement between $M_{2}$ and $M_{3}$ . The pair $(⊳_{i}^{23} \circ ⊳_{i}^{12}, ⊳_{e}^{23} \circ ⊳_{e}^{12})$ that composes the matching relations for initial data and events on each layer is a refinement between $M_{1}$ and $M_{3}$ . This can be summarized in the following diagram:

9. Refinements between concrete and abstract

In this section, we show that (1) the concrete machine refines the symbolic rule machine, and (2) vice versa. Using (1) we will be able to show in Section 10 that the concrete machine is noninterfering. From (2) we know that the concrete machine faithfully implements the abstract one, exactly reflecting its execution traces.

9.1. Abstract and symbolic rule machines

The symbolic rule machine (with the rule table $R^{abs}$ ) is a simple reformulation of the abstract machine. Their step relations are (extensionally) equal, and started from the same input data they emit the same traces.

Definition 9.1 (Abstract and symbolic rule machines as generic machines).

For both abstract and symbolic rule machines, input data is a 4-tuple $(p, args, n, L)$ where p is a program, $args$ is a list of atoms (the initial stack), and n is the size of the memory, initialized with n copies of $0 @ L$ . The initial PC is $0 @ L$ .

Lemma 9.2.
The symbolic rule machine instantiated with the rule table $R^{abs}$ refines the abstract machine through $(=, =)$ .

9.2. Concrete machine refines symbolic rule machine

We prove this refinement using a fixed but arbitrary rule table, $R$ , an abstract lattice of labels, and a concrete lattice of tags. The proof uses the correctness of the fault handler (Section 7), so we assume that the fault handler of the concrete machine corresponds to the rule table of the symbolic rule machine ( $ϕ = ϕ_{R}$ ) and that the encoding of abstract labels as integer tags is correct.

Definition 9.3 (Concrete machine as generic machine).

The input data of the concrete machine is a 4-tuple $(p, args, n, T)$ where p is a program, $args$ is a list of concrete atoms (the initial stack), and the initial memory is n copies of $0 @ T$ . The initial PC is $0 @ T$ . The machine starts in user mode, the cache is initialized with an illegal opcode so that the first instruction always faults (giving the fault handler a chance to run and install a correct rule without requiring the initialization process to invent one), and the fault handler code parameterizing the machine is installed in the initial privileged instruction memory ϕ.

The input data and events of the symbolic rule and concrete machines are of different kinds; they are matched using relations ( $⊳_{i}^{c}$ and $⊳_{e}^{c}$ respectively) stipulating that payload values should be equal and that labels should correspond to tags modulo the function $Tag$ of the concrete lattice.

Theorem 9.4.
The concrete IFC machine refines the symbolic rule machine, through $(⊳_{i}^{c}, ⊳_{e}^{c})$ .

We prove this theorem by a refinement via states (Lemma 9.7); this, in turn, relies on two technical lemmas (Lemmas 9.5 and 9.6).

We begin by defining a matching relation $⊳_{s}^{c}$ between the states of the concrete and symbolic rule machines such that
$i_{q} ⊳_{i}^{c} i_{c} \Rightarrow {Init}_{q} (i_{q}) ⊳_{s}^{c} {Init}_{c} (i_{c})$ ,

$(⊳_{s}^{c}, ⊳_{e}^{c})$ is a state refinement of the symbolic rule machine into the concrete machine.
We define $⊳_{s}^{c}$ as

where the new notations are defined as follows. The relation $⊳_{m}$ demands that the memories be equal up to the conversion of labels to concrete tags. The relation $⊳_{σ}$ on stacks is similar, but additionally requires that return frames in the concrete stack have their privilege bit set to $u$ . The basic idea is to match, in $⊳_{s}^{c}$ , only concrete states that are in user mode. We also need to track an extra invariant, $R ⊢ κ$ , which means that the cache κ is consistent with the table $R$ – i.e., κ never lies. More precisely, the output part of κ represents the result of applying the symbolic rule judgment of $R$ to the opcode and labels represented in the input part of κ.

To prove refinement via states, we must account for two situations. First, suppose the concrete machine can take a user step. In this case, we match that step with a single symbolic rule machine step. We write ${cs}^{π}$ to denote a concrete state $cs$ whose privilege bit is π.
Lemma 9.5 (Refinement, non-faulting concrete step).

Let ${cs}_{1}^{u}$ be a concrete state and suppose that ${cs}_{1}^{u} \overset{α_{c}}{\to} {cs}_{2}^{u}$ . Let ${qs}_{1}$ be a symbolic rule machine state with ${qs}_{1} ⊳_{s}^{c} {cs}_{1}^{u}$ . Then there exist ${qs}_{2}$ and $α_{a}$ such that ${qs}_{1} \overset{α_{a}}{\to} {qs}_{2}$ , with ${qs}_{2} ⊳_{s}^{c} {cs}_{2}^{u}$ , and $α_{a} [⊳_{e}^{c}] α_{c}$ . Graphically:

Proof.
We know that ${qs}_{1} ⊳_{s}^{c} {cs}_{1}^{u}$ . By definition of $⊳_{s}^{c}$ in (2), ${qs}_{1}$ and ${cs}_{1}^{u}$ are at the same opcode with the same stack and memory (up to translation between labels and tags), and $R ⊢ κ ({cs}_{1}^{u})$ . Thus $κ ({cs}_{1}^{u})$ matches a line of the symbolic IFC rule table, and since the concrete machine performs a user step from ${cs}_{1}^{u}$ to ${cs}_{2}^{u}$ , it is a line that allows a step to be taken. We conclude that the symbolic rule machine is able to perform the step to ${qs}_{2}$ as required. □

The second case is when the concrete machine faults into kernel mode and returns to user mode after some number of steps.
Lemma 9.6 (Refinement, faulting concrete step).

Let ${cs}_{0}^{u}$ be a concrete state, and suppose that the concrete machine does a faulting step to ${cs}_{1}^{k}$ , stays in kernel mode until ${cs}_{n}^{k}$ , and then exits kernel mode by stepping to ${cs}_{n + 1}^{u}$ . Let ${qs}_{0}$ be a state of the symbolic rule machine that matches ${cs}_{0}^{u}$ . Then ${qs}_{0} ⊳_{s}^{c} {cs}_{n + 1}^{u}$ . Graphically:

Proof.
Since the concrete machine performs a faulting step from ${cs}_{0}^{u}$ to ${cs}_{1}^{k}$ , we know that the current cache input, $κ_{i} ({cs}_{1}^{k})$ , corresponds to the current instruction and the tags it manipulates (they have been put there when entering kernel mode). Now, there are two cases. If evaluating the corresponding IFC rule at the symbolic rule level succeeds, then we apply Lemma 7.1 to conclude directly. Otherwise, we apply Lemma 7.2 and derive that the fault handler ends up in a failing state in kernel mode. This contradicts our initial hypothesis saying that the concrete machine performed a sequence of steps returning to user-mode. □

Given two matching states of the concrete and symbolic rule machines, and a concrete execution starting at that concrete state, these two lemmas can be applied repeatedly to build a matching execution of the symbolic rule machine. There is just one last case to consider, namely when the execution ends with a fault into kernel mode and never returns to user mode. However, no output is produced in this case, guaranteeing that the full trace is matched. We thus derive the following refinement via states, of which Theorem 9.4 is a corollary. Lemma 9.7.
The pair $(⊳_{s}^{c}, ⊳_{e}^{c})$ defines a refinement via states between the symbolic rule machine and the concrete machine.

9.3. Concrete machine refines abstract machine

By composing the refinement of Lemma 9.2 and the refinement of Theorem 9.4 instantiated to the concrete machine running $ϕ_{R^{abs}}$ , we can conclude that the concrete machine refines the abstract one:

Theorem 9.8.
The concrete IFC machine refines the abstract IFC machine via $(⊳_{s}^{c}, ⊳_{e}^{c})$ .

9.4. Abstract machine refines concrete machine

The previous refinement, $(⊳_{s}^{c}, ⊳_{e}^{c})$ , would also hold if the fault handler never returned when called. So, to ensure the concrete machine reflects the behaviors of the abstract machine, we next prove an inverse refinement:

Theorem 9.9.
The abstract IFC machine refines the concrete IFC machine via $(⊳_{i}^{- c}, ⊳_{e}^{- c})$ , where $⊳_{i}^{- c}$ and $⊳_{e}^{- c}$ are the relational inverses of $⊳_{i}^{c}$ and $⊳_{e}^{c}$ .

This guarantees that traces of the abstract machine are also emitted by the concrete machine. As above we use the symbolic rule machine as an intermediate step and show a state refinement of the concrete into the symbolic rule machine. We rely on the following lemma. Lemma 9.10 (Forward refinement).

Let ${qs}_{0}$ and ${cs}_{0}$ be two states with ${cs}_{0} ⊳_{s}^{- c} {qs}_{0}$ . Suppose that the symbolic rule machine takes a step ${qs}_{0} \overset{α_{a}}{\to} {qs}_{1}$ . Then there exist concrete state ${cs}_{1}$ and action $α_{c}$ such that ${cs}_{0} \overset{α_{c}}{\to}^{⋆} {cs}_{1}$ , with ${cs}_{1} ⊳_{s}^{- c} {qs}_{1}$ and $α_{c} [⊳_{e}^{- c}] α_{a}$ .

where $⊳_{s}^{- c}$ and $⊳_{e}^{- c}$ denote the inverses of $⊳_{s}^{c}$ and $⊳_{e}^{c}$ , respectively.

Proof.
Because ${cs}_{0} ⊳_{s}^{- c} {qs}_{0}$ , the cache is consistent with the symbolic rule table $R$ . If the cache input matches the opcode and data of ${cs}_{0}$ , then (because ${qs}_{0} \overset{α_{a}}{\to} {qs}_{1}$ ) the cache output must allow a step ${cs}_{0} \overset{α_{c}}{\to} {cs}_{1}$ as required. On the other hand, if the cache input does not match the opcode and data of ${cs}_{0}$ , then a cache fault occurs, loading the cache input and calling the fault handler. By Lemma 7.1 and the fact that ${qs}_{0} \overset{α_{a}}{\to} {qs}_{1}$ , the cache output is computed to be consistent with $R$ , and this allows the concrete step as claimed. □

9.5. Discussion

The two top-level refinement properties (Theorems 9.4 and 9.9) share the same notion of matching relations but they have been proved independently in our Coq development. In the context of compiler verification [58,81], another proof methodology has been favored: a backward simulation proof can be obtained from a proof of forward simulation under the assumption that the lower-level machine is deterministic. (CompCertTSO [81] also requires a receptiveness hypothesis that trivially holds in our context.) Since our concrete machine is deterministic, we could apply a similar technique. However, unlike in compiler verification where it is common to assume that the source program has a well-defined semantics (i.e. it does not get stuck), we would have to consider the possibility that the high-level semantics (the symbolic rule machine) might block and prove that in this case either the IFC enforcement judgment is stuck (and Lemma 9.6 applies) or the current symbolic rule machine state and matching concrete state are both ill-formed.

10. Noninterference

In this section we define TINI [1,43] for generic machines (recall Definition 8.1), and present a set of unwinding conditions [37] sufficient to guarantee TINI for a generic machine (Theorem 10.3); we show that the abstract machine of Section 3 satisfies these unwinding conditions and thus satisfies TINI (Theorem 10.5), that TINI is preserved by refinement (Theorem 10.6), and finally, using the fact that the concrete IFC machine refines the abstract one (Theorem 9.4), that the concrete machine satisfies TINI (Theorem 10.8).

Termination-insensitive noninterference (TINI). To define noninterference, we need to talk about what can be observed about the output trace produced by a run of a machine.

Definition 10.1 (Observation).

A notion of observation for a generic machine is a 3-tuple $(Ω, {⌊ \cdot ⌋}_{\cdot}, \cdot \approx_{\cdot}^{i} \cdot)$ . Ω is a set of observers (i.e., different degrees of power to observe), ranged over by o. For each $o \in Ω$ , ${⌊ \cdot ⌋}_{o} \subseteq E$ is a predicate of observability of events for observer o, and $\cdot \approx_{o}^{i} \cdot \subseteq I \times I$ is a relation of indistinguishability of input data for observer o.

The predicate ${⌊ e ⌋}_{o}$ is used to filter unobservable events from traces (written ${⌊ t ⌋}_{o}$ ): $\begin{array}{l} {⌊ ϵ ⌋}_{o} = ϵ \\ {⌊ e . t ⌋}_{o} = \{\begin{matrix} e . {⌊ t ⌋}_{o} & if {⌊ e ⌋}_{o} \\ {⌊ t ⌋}_{o} & otherwise \end{matrix} \end{array}$ Also a notion of indistinguishability of traces (written $t_{1} \approx^{t} t_{2}$ ) is defined inductively:

This definition truncates the longer trace to the same length as the shorter and then demands that the remaining elements be pairwise identical.

Definition 10.2 (TINI).

A machine $(S, E, I, \cdot \dot{\to} \cdot, Init)$ with a notion of observation $(Ω, {⌊ \cdot ⌋}_{\cdot}, \cdot \approx_{\cdot}^{i} \cdot)$ satisfies TINI if, for any observer $o \in Ω$ , pair of indistinguishable initial data $i_{1} \approx_{o}^{i} i_{2}$ , and pair of executions $Init (i_{1}) \overset{t_{1}}{\to}^{⋆}$ and $Init (i_{2}) \overset{t_{2}}{\to}^{⋆}$ , we have ${⌊ t_{1} ⌋}_{o} \approx^{t} {⌊ t_{2} ⌋}_{o}$ .

Notice that the input data for our machines includes the program to be executed; hence, we can apply the definition above to the execution of different programs. The reason for calling this notion “termination insensitive” is that, because of truncated traces in (3), we only model the case where we distinguish two runs of the same program by observing two distinguishable events that occur on the same position. Hence, this definition does not attempt to protect against attackers that try to learn a secret by seeing whether a program terminates or not: our observers cannot distinguish between successful termination, failure with an error, or entering an infinite loop with no observable output. This TINI property is standard for a machine with output [1,43].4

⁴
It is called “progress-insensitive noninterference” in a recent survey [43]. We have stated it for inductively defined executions and traces (1), which is all we need in this paper, but it can easily be lifted to coinductive executions and traces: not only successfully terminating and finitely failing executions, but also infinite executions. This holds because TINI is a 2-safety hyperproperty [22]; a formal proof of this can be found in our Coq development.

Unwinding conditions. Having defined TINI for generic notions of machine and observation, we now explain a sufficient set of conditions for such a machine to have the TINI property and sketch a proof of TINI from these conditions. The proof technique is standard [37].

A silent action cannot be observed, so we extend the given predicate ${⌊ e ⌋}_{o}$ to actions by stating that ${⌊ τ ⌋}_{o}$ never holds. From this we inductively define a notion of indistinguishability of actions to observer o (written $α_{1} \approx_{o}^{a} α_{2}$ ):

Two actions are indistinguishable to o if either they are equal, or if neither can be observed by o.

Theorem 10.3.

A machine $(S, E, I, \cdot \dot{\to} \cdot, Init)$ with notion of observation $(Ω, {⌊ \cdot ⌋}_{\cdot}, \cdot \approx_{\cdot}^{i} \cdot)$ satisfies TINI if, for each $o \in Ω$ , there exist two relations, indistinguishability of states to observer o (written $s_{1} \approx_{o}^{s} s_{2}$ ) and observability of states to observer o (written ${⌊ s ⌋}_{o}$ ), satisfying four sanity conditions $\begin{array}{l} (5) & i_{1} \approx_{o}^{i} i_{2} ⟹ Init (i_{1}) \approx_{o}^{s} Init (i_{2}) \\ (6) & s_{1} \approx_{o}^{s} s_{2} ⟹ s_{2} \approx_{o}^{s} s_{1} \\ (7) & s_{1} \approx_{o}^{s} s_{2} ⟹ ({⌊ s_{1} ⌋}_{o} \Leftrightarrow {⌊ s_{2} ⌋}_{o}) \\ (8) & ({⌊ α ⌋}_{o} \land s \overset{α}{\to}) ⟹ {⌊ s ⌋}_{o} \end{array}$ and three unwinding conditions, assuming $s_{1} \approx_{o}^{s} s_{2}$ and $s_{1} \overset{α_{1}}{\to} s_{1}^{'}$ : $\begin{array}{l} (9) & ({⌊ s_{1} ⌋}_{o} \land s_{2} \overset{α_{2}}{\to} s_{2}^{'}) ⟹ (α_{1} \approx_{o}^{a} α_{2} \land s_{1}^{'} \approx_{o}^{s} s_{2}^{'}) \\ (10) & (\neg {⌊ s_{1} ⌋}_{o} \land \neg {⌊ s_{1}^{'} ⌋}_{o}) ⟹ s_{1}^{'} \approx_{o}^{s} s_{2} \\ (11) & (\neg {⌊ s_{1} ⌋}_{o} \land {⌊ s_{1}^{'} ⌋}_{o} \land {⌊ s_{2}^{'} ⌋}_{o} \land s_{2} \overset{α_{2}}{\to} s_{2}^{'}) ⟹ s_{1}^{'} \approx_{o}^{s} s_{2}^{'} \end{array}$

We outline the proof, which motivates each of the sanity and unwinding conditions. To prove TINI we must consider pairs of traces of machine evaluations starting from initial states $Init (i_{1})$ and $Init (i_{2})$ and show that, after filtering for observability, these pairs of traces are indistinguishable. For the proof, we also maintain the invariant that the pairs of states reached by the two evaluations are indistinguishable. We are given that $i_{1} \approx_{o}^{i} i_{2}$ , so by (5) the initial states are indistinguishable, as are the traces emitted so far (namely ϵ).

Now suppose the two evaluations have arrived at two indistinguishable states, $s_{1} \approx_{o}^{s} s_{2}$ , and that the filtered traces emitted so far are indistinguishable. If $s_{1}$ can take a step, $s_{1} \overset{α_{1}}{\to} s_{1}^{'}$ , what is possible for steps from $s_{2}$ ? (We may assume that $s_{2} \overset{α_{2}}{\to} s_{2}^{'}$ : if no step is possible from $s_{2}$ then we are already done because (3), used in the definition of TINI, truncates the trace from $s_{1}$ at this point.) Proceed by cases on observability of $s_{1}$ .

Condition (9) says that, if ${⌊ s_{1} ⌋}_{o}$ , then the new states, $s_{1}^{'}$ and $s_{2}^{'}$ , and the emitted traces remain indistinguishable.

On the other hand, suppose $\neg {⌊ s_{1} ⌋}_{o}$ ; proceed by cases on observability of $s_{1}^{'}$ . (10) says that, if $\neg {⌊ s_{1}^{'} ⌋}_{o}$ , then $s_{1}^{'} \approx_{o}^{s} s_{2}$ ; and by (8), since $s_{1}$ is unobservable, $α_{1}$ must be unobservable, so the filtered emitted traces remain indistinguishable.

Finally, the case where $\neg {⌊ s_{1} ⌋}_{o}$ and ${⌊ s_{1}^{'} ⌋}_{o}$ . Then $\neg {⌊ s_{2} ⌋}_{o}$ (by (7)), and $α_{1}$ and $α_{2}$ are both unobservable by (8). Consider cases on observability of $s_{2}^{'}$ . The filtered traces emitted up to $s_{1}^{'}$ and $s_{2}^{'}$ are indistinguishable, and if ${⌊ s_{2}^{'} ⌋}_{o}$ we are done by (11). If $\neg {⌊ s_{2}^{'} ⌋}_{o}$ , we are in a case symmetric to the paragraph above; by (6) and (10) we have $s_{1} \approx_{o}^{s} s_{2}^{'}$ , and again the filtered traces emitted up to these points are indistinguishable. □

TINI for abstract IFC machine. We now instantiate Theorem 10.3 with the abstract machine defined in Section 3, showing it satisfies TINI for the following notion of observation:

Definition 10.4 (Observation for abstract machine).

Let $L$ be a lattice, with partial order ⩽. For the abstract machine, events $n @ L$ are atoms; we define indistinguishability of atoms, $a_{1} \approx_{o}^{a a} a_{2}$ , as in (4) above. The notion of observation for the abstract machine is $(L, {⌊ \cdot ⌋}_{\cdot}^{a}, \cdot \approx_{\cdot}^{i a} \cdot)$ , where $\begin{array}{l} ⌊ n @ L ⌋_{o}^{a} ≜ L ⩽ o \\ (p, {args}_{1}, n, L) \approx_{o}^{i a} (p, {args}_{2}, n, L) ≜ {args}_{1} [\approx_{o}^{a a}] {args}_{2} . \end{array}$ (On the right-hand side of the second equation, $[\approx_{o}^{a a}]$ is indistinguishability of atoms, lifted to lists as in Definition 8.2.)

To instantiate Theorem 10.3 we must exhibit relations of observability and indistinguishability on states. We outline these definitions and the proofs of the sanity and unwinding conditions here.

A state $s = ⟨ μ [σ] pc ⟩$ of the abstract machine is observable by observer $o \in L$ , written ${⌊ s ⌋}_{o}$ , whenever $p c = n @ L_{p c}$ is itself observable, i.e., $L_{p c} ⩽ o$ .

Indistinguishability of states is defined by two clauses: the first for observable states (left), and the other for non-observable ones (right).

Here we abuse the notation of lifting, $[\approx_{o}^{a a}]$ , using it for memories and stacks (two stack elements are indistinguishable if they are indistinguishable atoms, or are both return stack frames, with indistinguishable return addresses).

Let’s have a more detailed look at the definition of state indistinguishability. For observable states, we simply require that all the state components be indistinguishable. For non-observable ones, however, we must make the relation more permissive. Indeed, the abstract IFC machine steps from an observable state to a non-observable state when, e.g., branching on the value of a secret. When that happens, the tight correspondence on states no longer holds. Depending on the value of a secret, the machine could, e.g., jump to different instruction addresses, put different numbers of values on its stack, perform more or fewer function calls, etc. Because of that, we must allow states with different $pc$ values to be related, and adopt a weaker indistinguishability relation on stacks. This new relation, noted $\sim_{o}^{a}$ , only is used when relating unobservable states, and intuitively says that the stacks of such states only need to be related up to the most recent return frame to an observable one. Formally, $σ_{1} \sim_{o}^{a} σ_{2}$ is defined as ${⌊ σ_{1} ⌋}_{o} [\approx_{o}^{a a}] {⌊ σ_{2} ⌋}_{o}$ , where: $\begin{array}{l} {⌊ [] ⌋}_{o} ≜ [] \\ {⌊ n @ L, σ ⌋}_{o} ≜ {⌊ σ ⌋}_{o} \\ {⌊ n @ L; σ ⌋}_{o} ≜ \{\begin{matrix} n @ L; σ & if L ⩽ o \\ {⌊ σ ⌋}_{o} & otherwise \end{matrix} \end{array}$ In this way we relax the correspondence between call stacks of two machines, while at the same time keeping the invariant that holds on the “observable” part of the stacks, which we will need when proving Eq. (11) for the abstract machine.

Theorem 10.5.
The relations ${⌊ \cdot ⌋}_{\cdot}^{a}$ and $\cdot \approx_{\cdot}^{s a} \cdot$ satisfy the sanity and unwinding conditions of Theorem 10.3 ; thus, the abstract IFC machine has TINI.
Proof.
Most sanity conditions are easy consequences of the definitions, and do not require detailed explanation. We give an overview of the most interesting aspects of the proof; a more detailed account can be found in the formal development.

The $Output$ instruction plays an important role for condition (8) and for the first conclusion of (9). Crucially, since that instruction joins the label of the current $pc$ to the output atom, an unobservable state necessarily produces an unobservable action. Further, when two low states are indistinguishable and step (i.e., when they satisfy the preconditions of (9)), the atoms on top of the stack must be indistinguishable, leading to indistinguishable output actions.

As for the second conclusion of (9), since indistinguishable low states have equal $pc$ values, they execute the same instructions. Thus, showing that the states remain indistinguishable after stepping is just a matter of reasoning about the values that are used by each instruction on both states. These values must be indistinguishable, and it is easy to show that storing them at the same locations in indistinguishable stacks and memories leads to stacks and memories that are still indistinguishable.

Most of the cases of condition (10) – stepping from an unobservable state to another unobservable state – are trivial, since they only manipulate values or unobservable return frames on top of the stack (which by construction are irrelevant when checking whether the corresponding stacks are indistinguishable). The only exception is the $Store$ instruction, which also modifies the memory. Since the label on the $pc$ is assumed to be above the level of the observer, the side condition of that instruction ensures that the same holds of the memory position being updated. This ensures that both memories remain indistinguishable, since the other positions are not affected.

Finally, the precondition of (11) (stepping from unobservable to observable states) only applies when both states execute matching $Ret$ instructions. Since we assume that the resulting states are both observable, we conclude that the top of the original stacks contained the same observable return frame. The definition of indistinguishability says that the portions of the stacks below that frame are indistinguishable. Since those are exactly the values of the new stacks, and the returning $pc$ is the same on both states, we conclude that the resulting observable states are indistinguishable. □

TINI preserved by refinement.
Theorem 10.6 (TINI preservation).

Suppose that the generic machine $M_{2}$ refines $M_{1}$ by refinement $(⊳_{i}, ⊳_{e})$ and that each machine is equipped with a notion of observation. Suppose that, for all observers $o_{2}$ of $M_{2}$ , there exists an observer $o_{1}$ of $M_{1}$ such that the following compatibility conditions hold:

for all $e_{1} \in E_{1}$ and $e_{2} \in E_{2}$ , $e_{1} ⊳_{e} e_{2} \Rightarrow ({⌊ e_{1} ⌋}_{o_{1}} \Leftrightarrow {⌊ e_{2} ⌋}_{o_{2}})$

for all $i_{2}, i_{2}^{'} \in I_{2}, i_{2} \approx_{o_{2}}^{i} i_{2}^{'} \Rightarrow \exists i_{1}, i_{1}^{'} \in I_{1} . i_{1} \approx_{o_{1}}^{i} i_{1}^{'} \land i_{1} ⊳_{i} i_{2} \land i_{1}^{'} ⊳_{i} i_{2}^{'}$

for all $e_{1}, e_{1}^{'} \in E_{1}$ , and all $e_{2}, e_{2}^{'} \in E_{2}$ , $(e_{1} \approx_{o_{1}}^{a} e_{1}^{'} \land e_{1} ⊳_{e} e_{2} \land e_{1}^{'} ⊳_{e} e_{2}^{'}) \Rightarrow e_{2} \approx_{o_{2}}^{a} e_{2}^{'}$

Then, if

M_{1}

has TINI,

M_{2}

also has TINI.

Proof.
We include a brief proof sketch to convey the meaning of the theorem and the role of the compatibility conditions; intuitively, they say that $o_{1}$ does not have more observation power than $o_{2}$ . Suppose that $o_{2}$ observes two traces $t_{2}$ and $t_{2}^{'}$ , starting from initial states $i_{2}$ and $i_{2}^{'}$ . We want to show that both traces are indistinguishable whenever the initial states are. By condition (2), we can find related initial states $i_{1}$ and $i_{1}^{'}$ of $M_{1}$ that are indistinguishable. Since $M_{2}$ refines $M_{1}$ , we know that these initial states produce traces $t_{1}$ and $t_{1}^{'}$ that match $t_{2}$ and $t_{2}^{'}$ ; furthermore, since $M_{1}$ has TINI, $t_{1}$ and $t_{1}^{'}$ are indistinguishable. By condition (1), filtering related traces results in related traces; that is, ${⌊ t_{1} ⌋}_{o_{1}} [⊳_{e}] {⌊ t_{2} ⌋}_{o_{2}}$ , and similarly for the other two traces. This implies, thanks to condition (3), that we can use the indistinguishability of ${⌊ t_{1} ⌋}_{o_{1}}$ and ${⌊ t_{1}^{'} ⌋}_{o_{1}}$ to argue that ${⌊ t_{2} ⌋}_{o_{2}}$ and ${⌊ t_{2}^{'} ⌋}_{o_{2}^{'}}$ are also indistinguishable, by a simple induction on the traces. □

Some formulations of noninterference are subject to the refinement paradox [48], in which refinements of a noninterferent system may violate noninterference. We avoid this issue by employing a strong notion of noninterference that restricts the amount of non-determinism in the system and is thus preserved by any refinement (Theorem 10.6).5
⁵
The recent noninterference proof for the seL4 microkernel [66,67] works similarly (see Section 12).

Since our abstract machine is deterministic, it is easy to show this strong notion of noninterference for it. In Section 13 we discuss a possible technique for generalizing to the concurrent setting while preserving a high degree of determinism.

TINI for concrete machine with IFC fault handler. It remains to define a notion of observation on the concrete machine, instantiating the definition of TINI for this machine. This definition refers to a concrete lattice $CL$ , which must be a correct encoding of an abstract lattice $L$ : the lattice operators $genBot$ , $genJoin$ , and $genFlows$ must satisfy the specifications in Section 7.
Definition 10.7 (Observation for the concrete machine).

Let $L$ be an abstract lattice, and $CL$ be correct with respect to $L$ . The observation for the concrete machine is $(L, {⌊ \cdot ⌋}_{\cdot}^{c}, \cdot \approx_{\cdot}^{i c} \cdot)$ , where $\begin{array}{l} ⌊ n @ T ⌋_{o}^{c} ≜ Lab (T) ⩽ o, \\ (p, {args}_{1}^{'}, n, T) \approx_{o}^{i c} (p, {args}_{2}^{'}, n, T) ≜ {args}_{1} [\approx_{o}^{a a}] {args}_{2}, \end{array}$ and ${args}_{i}^{'} = map (λ (n @ L) . n @ Tag (L)) {args}_{i}$ .

Finally, we prove that the backward refinement proved in Section 9 (Theorem 9.8) satisfies the compatibility constraints of Theorem 10.6, so we derive the main result:

Theorem 10.8.
The concrete IFC machine running the fault handler $ϕ_{R^{abs}}$ satisfies TINI.

11. An extended system

Fig. 11.

Additional instructions for extensions.

Thus far we have presented our methodology in the context of a simple machine architecture and IFC discipline. We now show how it can be scaled up to a significantly more sophisticated setting, where the basic machine is extended with a frame-based memory model supporting dynamic allocation and a system call mechanism for adding special-purpose primitives. Building on these features, we define an abstract IFC machine that uses sets of principals as its labels and a corresponding concrete machine implementation where tags are pointers to dynamically allocated representations of these sets. While still much less complex than the real SAFE system, this extended model serves as good evidence of the robustness our approach, and how it might apply to more realistic designs: The new features were added by incrementally adapting the Coq formalization of the basic system, without requiring any major changes to the initial proof architecture.

Fig. 12.

Semantics of selected new abstract machine instructions.

Figure 11 shows the new instructions supported by the extended model. Instruction $PushCachePtr$ , $Unpack$ , and $Pack$ are used only by the concrete machine, for the compiled fault handler (hence they only have a kernel-mode stepping rule; they simply get stuck if executed outside kernel mode, or on an abstract machine). We also add two stack-manipulation instructions, $Dup$ and $Swap$ , to make programming the kernel routines more convenient. It remains true that any program for the abstract machine makes sense to run on the abstract rule machine and the concrete machine. For brevity, we detail stepping rules only for the extended abstract IFC machine (Fig. 12) and concrete machine (Fig. 13); corresponding extensions to the symbolic IFC rule machine are straightforward (we also omit rules for $Dup$ and $Swap$ ). Individual rules are explained below.

Fig. 13.

Semantics of selected new concrete machine instructions.

11.1. Dynamic memory allocation

High-level programming languages usually assume a structured memory model, in which independently allocated frames are disjoint by construction and programs cannot depend on the relative placement of frames in memory. The SAFE hardware enforces this abstraction by attaching explicit runtime types to all values, distinguishing pointers from other data. Only data marked as pointers can be used to access memory. To obtain a pointer, one must either call the (privileged) memory manager to allocate a fresh frame or else offset an existing pointer. In particular, it is not possible to “forge” a pointer from an integer. Each pointer also carries information about its base and bounds, and the hardware prevents it from being used to access memory outside of its frame.

Frame-based memory model. In our extended system, we model the user-level view of SAFE’s memory system by adding a frame-structured memory (similar to [59]), distinguished pointers (so values, the payload field of atoms and the tag field of concrete atoms, can now either be an integer $(Int n)$ or a pointer $(Ptr p)$ ), and an allocation instruction to our basic machines. We do this (nearly) uniformly at all levels of abstraction.6

⁶
It would be interesting to describe an implementation of the memory manager in a still-lower-level concrete machine with no built-in $Alloc$ instruction, but we leave this as future work.

A pointer is a pair

p = (id, o)

of a frame identifier

id

and an offset o into that frame. In the machine state, the data memory μ is a partial function from pointers to individual storage cells that is undefined on out-of-frame pointers. By abuse of notation, μ is also a partial function from frame identifiers to frames, which are just lists of atoms.

The most important new rule of the extended abstract machine is $Alloc$ (Fig. 12). In this machine there is a separate memory region (assumed infinite) corresponding to each label. The auxiliary function $alloc$ in the rule for $Alloc$ takes a size k, the label (region) at which to allocate, and a default atom a; it extends μ with a fresh frame of size k, initializing its contents to a. It returns the id of the new frame and the extended memory $μ^{'}$ .

IFC and memory allocation. We require that the frame identifiers produced by allocation at one label not be affected by allocations at other labels; e.g., $alloc$ might allocate sequentially in each region. Thus, indistinguishability of low atoms is just syntactic equality, preserving Definition 10.4 from the simple abstract machine, which is convenient for proving noninterference, as we explain below. We allow a program to observe frame sizes using a new $SizeOf$ instruction, which requires tainting the result of $Alloc$ with L, the label of the size argument. There are also new instructions $Eq$ , for comparing two values (including pointers) for equality, and $GetOff$ , for extracting the offset field of a pointer into an integer. However, frame ids are intuitively abstract: the concrete representation of frame ids is not accessible, and pointers cannot be forged or output. The extended concrete machine stepping rules for these new instructions are analogous to the abstract machine rules, with the important exception of $Alloc$ , which is discussed below.

A few small modifications to existing instructions in the basic machine (Fig. 2) are needed to handle pointers properly. In particular: (i) $Load$ and $Store$ require pointer arguments and get stuck if the pointer’s offset is out of range for its frame. (ii) $Add$ takes either two integers or an integer and a pointer, where $Int n + Int m = Int (n + m)$ and $Ptr (id, o_{1}) + Int o_{2} = Ptr (id, o_{1} + o_{2})$ . (iii) $Output$ works only on integers, not pointers. Analogous modifications are needed in the concrete machine semantic rules.

Concrete allocator. The extended concrete machine’s semantics for $Alloc$ differ from those of the abstract machine in one key respect. Using one region per tag would not be a realistic strategy for a concrete implementation; e.g., the number of different tags might be extremely large. Instead, we use a single region for all user-mode allocations at the concrete level. We also collapse the separate user and kernel memories from the basic concrete machine into a single memory. Since we still want to be able to distinguish user and kernel frames, we mark each frame with a privilege mode (i.e., we use two allocation regions). Figure 13 shows the corresponding concrete stepping rule for $Alloc$ for two cases: non-faulting user mode and kernel mode. The rule cache is now just a distinguished kernel frame $cache$ ; to access it, the fault handler uses the (privileged) $PushCachePtr$ instruction. The concrete $Load$ and $Store$ rules are modified to prevent dereferencing kernel pointers in user mode. These checks are only needed if we want to allow user-level code to manipulate kernel pointers directly while protecting the data structures they point to. For instance, we could allow certain operations on pointers representing labels, such as taking the join of two labels, while preserving noninterference. If kernel pointers cannot be “leaked” into user data (as in Section 11.3), these checks can be safely omitted, since user-level code won’t be able to tamper with kernel data.

Proof by refinement. As before, we prove noninterference for the concrete machine by combining a proof of noninterference of the abstract machine with a two-stage proof that the concrete machine refines the abstract machine. By using this approach we avoid some well-known difficulties in proving noninterference directly for the concrete machine. In particular, when frames allocated in low and high contexts share the same region, allocations in high contexts can cause variations in the precise pointer values returned for allocations in low contexts, and these variations must be taken into account when defining the indistinguishability relation. For example, Banerjee and Naumann [11] prove noninterference by parameterizing their indistinguishability relation with a partial bijection that keeps track of indistinguishable memory addresses. Our approach, by contrast, defines pointer indistinguishability only at the abstract level, where indistinguishable low pointers are identical. This proof strategy still requires relating memory addresses when showing refinement, but this relation does not appear in the noninterference proof at the abstract level. The refinement proof itself uses a simplified form of memory injections [59]. The differences in the memory region structure of both machines are significant, but invisible to programs, since no information about frame ids is revealed to programs beyond what can be obtained by comparing pointers for equality. This restriction allows the refinement proof to go through straightforwardly.

11.2. System calls

To support the implementation of policy-specific primitives on top of the concrete machine, we provide a new system call instruction. The $SysCall id$ instruction is parameterized by a system call identifier. The step relation of each machine is now parameterized by a table T that maps system call identifiers to their implementations.

In the abstract and symbolic rule machines, a system call implementation is an arbitrary Coq function that removes a list of atoms from the top of the stack and either puts a result on top of the stack or fails, halting the machine. The system call implementation is responsible for computing the label of the result and performing any checks that are needed to ensure noninterference.

In the concrete machine, system calls are implemented by kernel routines and the call table contains the entry points of these routines in the kernel instruction memory. Executing a system call involves inserting the return address on the stack (underneath the call arguments) and jumping to the corresponding entry point. The kernel code terminates either by returning a result to the user program or by halting the machine.

This feature has no major impact on the proofs of noninterference and refinement. For noninterference, we must show that all the abstract system calls preserve indistinguishability of abstract machine states; for refinement, we show that each concrete system call correctly implements the abstract one using the machinery of Section 7.

11.3. Labeling with sets of principals

The full SAFE machine supports dynamic creation of security principals. In the extended model, we make a first step toward dynamic principal creation by taking principals to be integers and instantiating the (parametric) lattice of labels with the lattice of finite sets of integers. This lattice is statically known, but models dynamic creation by supporting unbounded labels and having no top element. In this lattice, ⊥ is ∅, ∨ is ∪, and ⩽ is ⊆. We enrich our IFC model by adding a new classification primitive $joinP$ that adds a principal to an atom’s label, encoded using the system call mechanism described above. The operation of $joinP$ is given by the following derived rule, which is an instance of the $SysCall$ rule from Fig. 12.

At the concrete level, a tag is now a pointer to an array of principals (integers) stored in kernel memory. To keep the fault handler code simple, we do not maintain canonical representations of sets: one set may be represented by different arrays, and a given array may have duplicate elements. (As a consequence, the mapping from abstract labels to tags is no longer a function; we return to this point below.) Since the fault handler generator in the basic system is parametric in the underlying lattice, it doesn’t require any modification. All we must do is provide concrete implementations for the appropriate lattice operations: $genJoin$ just allocates a fresh array and concatenates both argument arrays into it; $genFlows$ checks for array inclusion by iterating through one array and testing whether each element appears in the other; and $genBot$ allocates a new empty array. Finally, we provide kernel code to implement $joinP$ , which requires two new privileged instructions, $Pack$ and $Unpack$ (Fig. 13), to manipulate the payload and tag fields of atoms; otherwise, the implementation is similar to that of $genJoin$ .

A more realistic system would keep canonical representations of sets and avoid unnecessary allocation in order to improve its memory footprint and tag cache usage. But even with the present simplistic approach, both the code for the lattice operations and their proofs of correctness are significantly more elaborate than for the trivial two-point lattice. In particular, we need an additional code generator to build counted loops, e.g., for computing the join of two tags. $\begin{matrix} \begin{matrix} genFor c & = & [Dup] + + genIf (genLoop (c + + [Push (- 1), Add])) [] \\ where genLoop c = c + + [Dup, Bnz (- (length c + 1))] \end{matrix} \end{matrix}$ Here, c is a code sequence representing the loop body, which is expected to preserve an index value on top of the stack; the generator builds code to execute that body repeatedly, decrementing the index each time until it reaches 0. The corresponding specification is

To avoid reasoning about memory updates as far as possible, we code in a style where all local context is stored on the stack and manipulated using $Dup$ and $Swap$ . Although the resulting code is lengthy, it is relatively easy to automate the corresponding proofs.

Stateful encoding of labels. Changing the representation of tags from integers to pointers requires modifying one small part of the basic system proof. Recall that in Section 6 we described the encoding of labels into tags as a pure function $Lab$ . To deal with the memory-dependent and non-canonical representation of sets described above, the extended system instead uses a relation between an abstract label, a concrete tag that encodes it, and a memory in which this tag should be interpreted.

If tags are pointers to data structures, it is crucial that these data structures remain intact as long as the tags appear in the machine state. We guarantee this by maintaining the very strong invariant that each execution of the fault handler only allocates new frames, and never modifies the contents of existing ones, except for the $cache$ frame (which tags never point into). A more realistic implementation might use mutable kernel memory for other purposes and garbage collect unused tags; this would require a more complicated memory invariant.

The TINI formulation is similar in essence to the one in Section 10, but some subtleties arise for concrete output events, since their tags cannot be interpreted on their own anymore. We wish to (i) keep the semantics of the concrete machine independent of high-level policies such as IFC and (ii) give a statement of noninterference that does not refer to pointers. To achieve these seemingly contradictory aims, we model an event of the concrete machine as a pair of a concrete atom plus the whole state of the kernel memory. This memory is not visible to observers in the formulation of TINI, but instead determines which events’ payloads they are able to observe. This is done by extending our notion of observation with a function that interprets every concrete event present in the output trace in higher-level terms. This interpretation abstracts away from low-level representation issues, such as the layout of data structures in memory, and allows us to give a more natural definition of event indistinguishability in the formulation of TINI. For instance, in the extended system described above, the interpretation of a pointer tag is the set of principals that pointer represents in kernel memory – that is, the contents of the array it points to. This allows us to define the event indistinguishability relation by simple equality.

Our model of observation in terms of an interpretation function is an idealization of what happens in the real SAFE machine, where communication of labeled data with the outside world involves cryptography. Extending this model this is left as future work.

12. Related work

The SAFE design spans a number of research areas, and a comprehensive overview of related work would be huge. We focus here on a small set of especially relevant points of comparison.

Language-based IFC. Static approaches to IFC have generally dominated language-based security research [69,73,77,93]; however, statically enforcing IFC at the lowest level of a real system is challenging. Soundly analyzing native binaries with reasonable precision is hard (static IFC for low-level code usually stops at the bytecode level [13,38,42,60]), even more so without the compiler’s cooperation (e.g., for stripped or obfuscated binaries). Proof-carrying code [12,13,38] and typed assembly language [62,94,95] have been used for enforcing IFC on low-level code without low-level analysis or adding the compiler to the TCB. In SAFE [30,35] we follow a different approach, enforcing noninterference using purely dynamic checks, for arbitrary binaries in a custom-designed instruction set. The mechanisms we use for this are similar to those found in recent work on purely dynamic IFC for high-level languages [2,4–7,40,41,44,45,64,72,75,78,83,88]; however, as far as we know, we are the first to push these ideas to the lowest level.

seL4. Murray et al. [66] recently demonstrated a machine-checked noninterference proof for the implementation of the seL4 microkernel. This proof is carried out by refinement and reuses the specification and most of the existing functional correctness proof of seL4 [54]. Like the TINI property in this paper, the variant of intransitive noninterference used by Murray et al. is preserved by refinement because it implies a high degree of determinism [67]. This organization of their proof was responsible for a significant saving in effort, even when factoring in the additional work required to remove all observable non-determinism from the seL4 specification. Beyond these similarities, SAFE and seL4 rely on completely different mechanisms to achieve different notions of noninterference (seL4 admits intransitive IFC policies, capturing the “where” dimension of declassification [79], while we consider transitive ones). Whereas, in SAFE, each word of data has an IFC label and labels are propagated on each instruction, the seL4 kernel maintains separation between several large partitions (e.g., one partition can run an unmodified version of Linux) and ensures that information is conveyed between such partitions only in accordance with a fixed access control policy.

PROSPER. In parallel work, Dam et al. [27,28,53] verified information flow security for a tiny proof-of-concept separation kernel running on ARMv7 and using a Memory Management Unit for physical protection of memory regions belonging to different partitions. The authors argue that noninterference is not well suited for systems in which components are supposed to communicate with each other. Instead, they use the bisimulation proof method to show trace equivalence between the real system and an ideal top-level specification that is secure by construction. As in seL4 [66], the proof methodology precludes an abstract treatment of scheduling, but the authors contend this is to be expected when information flow is to be taken into account. In more recent work, Balliu et al. [10] propose a symbolic execution-based information flow analysis for machine code, and use this technique to verify a separation kernel system call handler, a UART device driver, and a crypto service modular exponentiation routine.

TIARA and ARIES. The SAFE architecture embodies a number of innovations from earlier paper designs. In particular, the TIARA design [84] first proposed the idea of a zero-kernel operating system and sketched a concrete architecture, while the ARIES project proposed using a hardware rule cache to speed up information-flow tracking [16]. In TIARA and ARIES, tags had a fixed set of fields and were of limited length, whereas, in SAFE, tags are pointers to arbitrary data structures, allowing them to represent complex IFC labels encoding sophisticated security policies [63], for instance decentralized ones [69,87]. Moreover, unlike TIARA and ARIES, which made no formal soundness claims, SAFE proposes a set of IFC rules aimed at achieving noninterference; the proof we present in this paper, though for a simplified model, provides evidence that this goal is feasible.

RIFLE and other binary-rewriting-based IFC systems. RIFLE [91] enforces user-specified information-flow policies for x86 binaries using binary rewriting, static analysis, and augmented hardware. Binary rewriting is used to make implicit flows explicit; it heavily relies on static analysis for reconstructing the program’s control-flow graph and performing reaching-definitions and alias analysis. The augmented hardware architecture associates labels with registers and memory and updates these labels on each instruction to track explicit flows. Additional security registers are used by the binary translation mechanism to help track implicit flows. Beringer [14] recently proved (in Coq) that the main ideas in RIFLE can be used to achieve noninterference for a simple While language. Unlike RIFLE, SAFE achieves noninterference purely dynamically and does not rely on binary rewriting or heroic static analysis of binaries. Moreover, the SAFE hardware is generic, simply caching instances of software-managed rules.

While many other information flow tracking systems based on binary rewriting have been proposed, few are concerned with soundly handling implicit flows [23,61], and even these do so only to the extent they can statically analyze binaries. Since, unlike RIFLE (and SAFE), these systems use unmodified hardware, the overhead for tracking implicit flows can be large. To reduce this overhead, recent systems track implicit flows selectively [52] or not at all [49,74] – arguably a reasonable tradeoff in settings such as malware analysis or attack detection, where speed and precision are more important than soundness.

Hardware taint tracking. The last decade has seen significant progress in specialized hardware for accelerating taint tracking [19,25,26,31,32,89,92]. Most commonly, a single tag bit is associated with each word to specify if it is tainted or not. Initially aimed at mitigating low-level memory corruption attacks by preventing the use of tainted pointers and the execution of tainted instructions [19,25,89], hardware-based taint tracking has also been used to prevent high-level attacks such as SQL injection and cross-site scripting [26]. In contrast to SAFE, these systems prioritize efficiency and overall helpfulness over the soundness of the analysis, striking a heuristic balance between false positives and false negatives (missed attacks). As a consequence, these systems ignore implicit flows and often do not even track all explicit flows. While early systems supported a single hard-coded taint propagation policy, recent ones allow the policy to be defined in software [26,32,92] and support monitoring policies that go beyond taint tracking [18,31,32,76]. Harmoni [32], for example, provides a pair of caches that are quite similar to the SAFE rule cache. Possibly these could even be adapted to enforcing noninterference, in which case we expect the proof methodology introduced here to apply.

Timing and termination. Our TINI property ignores both termination and timing: a program that diverges, fails, or takes varying amounts of time to run based on a sensitive input is considered secure. The full SAFE design includes a clearance-based access-control mechanism [88] for addressing termination and timing covert channels (i.e., high-bandwidth channels through which malicious code can exfiltrate secrets it directly has access to). Stefan et al. [86] have also shown that in a concurrent setting such leaks can be prevented by an adapted IFC mechanism, at the risk of spawning very large numbers of threads. We believe that this IFC mechanism could also be enforced using the hardware mechanisms we describe here. A recently proposed technique for instruction-based scheduling [17,85] is aimed at preventing leaks via the internal timing side-channel (e.g., malicious code sharing the same processor inferring secrets through timing variations arising from cache misses). This could probably be adapted to SAFE, and since the SAFE processor is very simple the mitigation could work well [24]. Finally, several mechanisms have been proposed for mitigating the external timing side-channel (i.e., leakage of secrets to an attacker making timing observations over the network) and thus reducing the rate at which bits can be leaked [3,98]. We do not consider any of these attacks or mitigations in this work.

Verification of low-level code. The distinctive challenge in verifying machine code is coping with unstructured control flow. Our approach using structured generators to build the fault handler is similar to the mechanisms used in Chlipala’s Bedrock system [20,21] and by Jensen et al. [50], but there are several points of difference. These systems each build macros on top of a powerful low-level program logic for machine code (Ni and Shao’s XCAP [71], in the case of Bedrock), whereas we take a simpler, ad-hoc approach, building directly on our stack machine’s relatively high-level semantics. Both these systems are based on separation logic, which we can do without since (at least in the present simplified model) we have very few memory operations to reason about. We have instead focused on developing a simple Hoare logic specifically suited to verifying structured runtime-system code; e.g., we omit support for arbitrary code pointers, but add support for reasoning about termination. We use total-correctness Hoare triples (similar to Myreen and Gordon [70]) and weakest preconditions to guarantee progress, not just safety, for our handler code. Finally, our level of automation is much more modest than Bedrock’s, though still adequate to discharge most verification conditions on straight-line stack manipulation code rapidly and often automatically.

Work on testing noninterference. The abstract machine in Section 3 was proposed by Hriţcu et al. [46], extended in this work with dynamic allocation and data classification (Section 11), and recently further extended by Hriţcu et al. to a sophisticated machine featuring a highly permissive flow-sensitive dynamic enforcement mechanism, public labels, and registers [47]. While the focus of that work is on verifying noninterference by random testing, it also shows how to use invariants discovered during testing to formalize proofs of noninterference in Coq.

Although the abstract machine and IFC mechanism considered here are simpler than the most complex ones of Hriţcu et al. [47], our main concerns are the concrete machine, the IFC fault handler, and the key properties of this combination, all of which are novel. We believe nevertheless that our methodology could be extended to that setting as well, verifying an implementation of this extended IFC machine by a lower-level one. Depending on the hardware capabilities at the lower level, some of the features of the machine could have to be implemented in software, requiring further proofs. For instance, this extended IFC machine still relies on a protected stack for soundly performing function calls and returns: on a call, the entire register file is stored on this stack, so that it can be restored upon a return, thereby preventing data leakage. At the lowest level, this protected stack could be implemented with a regular stack living in kernel space, managed through special system calls.

Tagging hardware beyond IFC. Although the tagging mechanism we discuss arose in the context of the SAFE system, and was primarily designed for information-flow control, it is sufficiently generic to be implemented in other architectures and to enforce more security policies.

In follow-on work, Dhawan et al. [34] adapt the tagging mechanism to a more conventional RISC processor, using it to implement policies such as memory safety and control-flow integrity. They evaluate the performance of the mechanism on benchmark simulations, which indicate a modest impact on speed (typically under 10%) and power ceiling (less that 10%), even when enforcing multiple policies simultaneously.

Azevedo de Amorim et al. [9] use Coq to formalize a generic version of the symbolic machine of Section 4; that machine is different from the one discussed here in that it is based on a more conventional processor design (e.g., with registers instead of a protected stack), and serves as a high-level substrate for programming many different security policies, including compartmentalization and memory safety. Finally, they formulate the intended effect of each policy as a security property, using formal proofs to show that each policy enforces the corresponding property.

A recent project at Draper Labs [29] is working to extend the RISC-V processor with tag propagation hardware in the style of the SAFE processor. As of March 2016, a prototype able to boot Linux is running on FPGA boards.

13. Conclusions and future work

We have presented a formal model of the key IFC mechanisms of the SAFE system: propagating and checking tags to enforce security, using a hardware cache for common-case efficiency and a software fault handler for maximum flexibility. To formalize and prove properties at such a low level (including features such as dynamic memory allocation and labels represented by pointers to in-memory data structures), we first construct a high-level abstract specification of the system, then refine it in two steps into a realistic concrete machine. A bidirectional refinement methodology allows us to prove (i) that the concrete machine, loaded with the right fault handler (i.e. correctly implementing the IFC enforcement of the abstract specification) satisfies a traditional notion of termination-insensitive noninterference, and (ii) that the concrete machine reflects all the behaviors of the abstract specification. Our formalization reflects the programmability of the fault handling mechanism, in that the fault handler code is compiled from a rule table written in a small DSL. We set up a custom Hoare logic to specify and verify the corresponding machine code, following the structure of a simple compiler for this DSL.

The development in this paper concerns three deterministic machines and simplifies away concurrency. While the lack of concurrency is a significant current limitation that we would like to remove by moving to a multithreading single-core model, we still want to maintain the abstraction layers of a proof-by-refinement architecture. This requires some care so as not to run afoul of the refinement paradox [48] since some standard notions of noninterference (for example possibilistic noninterference) are not preserved by refinement in the presence of non-determinism. One promising path toward this objective is inspired by the recent noninterference proof for seL4 [66,67]. If we manage to share a common thread scheduler between the abstract and concrete machines, we could still prove a strong double refinement property (concrete refines abstract and vice versa) and hence preserve a strong notion of noninterference (such as the TINI notion from this work) or a possibilistic variation.

Although this paper focuses on IFC and noninterference, the tagging facilities of the concrete machine are completely generic and have been used since to enforce completely different properties like memory safety, compartment isolation, and control-flow integrity [9]. Moreover, although the rule cache/fault handler design arose in the context of SAFE, it has since been adapted to a conventional RISC processor [34].

Footnotes

Acknowledgments

We are grateful to Maxime Dénès, Deepak Garg, Greg Morrisett, Toby Murray, Jeremy Planul, Alejandro Russo, Howie Shrobe, Jonathan M. Smith, Deian Stefan, and Greg Sullivan for useful discussions and helpful feedback on early drafts. We also thank the anonymous reviewers for their insightful comments. This material is based upon work supported by the DARPA CRASH and SOUND programs through the US Air Force Research Laboratory (AFRL) under Contracts No. FA8650-10-C-7090 and FA8650-11-C-7189. This work was also partially supported by NSF award 1513854 Micro-Policies: A Framework for Tag-Based Security Monitors. The views expressed are those of the authors and do not reflect the official policy or position of the Department of Defense or the U.S. Government.

References

Askarov,

Hunt,

Sabelfeld and

Sands, Termination-insensitive noninterference leaks more than just a bit, in: 13th European Symposium on Research in Computer Security (ESORICS), Malaga, Spain, October 2008, LNCS, Vol. 5283, Springer-Verlag, 2008.

Askarov and

Sabelfeld, Tight enforcement of information-release policies for dynamic languages, in: 22nd IEEE Computer Security Foundations Symposium (CSF), IEEE Computer Society, 2009, pp. 43–59.

Askarov,

Zhang and

A.C.

Myers, Predictive black-box mitigation of timing channels, in: 17th ACM Conference on Computer and Communications Security, ACM, 2010, pp. 297–307.

T.H.

Austin and

Flanagan, Efficient purely-dynamic information flow analysis, in: Workshop on Programming Languages and Analysis for Security (PLAS), PLAS, ACM, 2009, pp. 113–124. doi:10.1145/1554339.1554353.

T.H.

Austin and

Flanagan, Permissive dynamic information flow analysis, in: Proceedings of the 5th Workshop on Programming Languages and Analysis for Security, PLAS, ACM, 2010, pp. 3:1–3:12.

T.H.

Austin and

Flanagan, Multiple facets for dynamic information flow, in: Proceedings of the 39th Symposium on Principles of Programming Languages, POPL, 2012, pp. 165–178.

T.H.

Austin,

Flanagan and

Abadi, A functional view of imperative information flow, in: 10th Asian Symposium on Programming Languages and Systems (APLAS), Lecture Notes in Computer Science, Vol. 7705, Springer, 2012, pp. 34–49. doi:10.1007/978-3-642-35182-2_4.

Azevedo de Amorim,

Collins,

DeHon,

Demange,

Hriţcu,

Pichardie,

B.C.

Pierce,

Pollack and

Tolmach, A verified information-flow architecture, in: Proceedings of the 41st Symposium on Principles of Programming Languages, POPL, ACM, 2014, pp. 165–178.

Azevedo de Amorim,

Dénès,

Giannarakis,

Hriţcu,

B.C.

Pierce,

Spector-Zabusky and

Tolmach, Micro-policies: Formally verified, tag-based security monitors, in: 36th IEEE Symposium on Security and Privacy (Oakland S&P), IEEE Computer Society, 2015, pp. 813–830.

10.

Balliu,

Dam and

Guanciale, Automating information flow analysis of low level code, in: ACM SIGSAC Conference on Computer and Communications Security, CCS,

Ahn,

Yung and

Li, eds, ACM, 2014, pp. 1080–1091.

11.

Banerjee and

D.A.

Naumann, Stack-based access control and secure information flow, Journal of Functional Programming 15(2) (2005), 131–177. doi:10.1017/S0956796804005453.

12.

Barthe,

Crégut,

Grégoire,

T.P.

Jensen and

Pichardie, The MOBIUS proof carrying code infrastructure, in: 6th International Symposium on Formal Methods for Components and Objects (FMCO), Lecture Notes in Computer Science, Vol. 5382, Springer, 2007, pp. 1–24. doi:10.1007/978-3-540-92188-2_1.

13.

Barthe,

Pichardie and

Rezk, A certified lightweight non-interference Java bytecode verifier, in: 16th European Symposium on Programming Languages and Systems (ESOP), Lecture Notes in Computer Science, Vol. 4421, Springer, 2007, pp. 125–140. doi:10.1007/978-3-540-71316-6_10.

14.

Beringer, End-to-end multilevel hybrid information flow control, in: 10th Asian Symposium on Programming Languages and Systems (APLAS), Lecture Notes in Computer Science, Vol. 7705, Springer, 2012, pp. 50–65. doi:10.1007/978-3-642-35182-2_5.

15.

Bichhawat,

Rajani,

Garg and

Hammer, Generalizing permissive-upgrade in dynamic information flow analysis, in: 9th Workshop on Programming Languages and Analysis for Security (PLAS), ACM, 2014, p. 15.

16.

Brown and

T.F.

KnightJr., A minimally trusted computing base for dynamically ensuring secure information flow, Technical Report 5, MIT CSAIL, 2001, Aries Memo No. 15.

17.

Buiras,

Levy,

Stefan,

Russo and

Mazières, A library for removing cache-based attacks in concurrent information flow systems, in: 8th International Symposium on Trustworthy Global Computing,

Abadi and

Lluch-Lafuente, eds, Lecture Notes in Computer Science, Vol. 8358, Springer, 2013, pp. 199–216. doi:10.1007/978-3-319-05119-2_12.

18.

Chen,

Kozuch,

Strigkos,

Falsafi,

P.B.

Gibbons,

T.C.

Mowry,

Ramachandran,

Ruwase,

M.P.

Ryan and

Vlachos, Flexible hardware acceleration for instruction-grain program monitoring, in: 35th International Symposium on Computer Architecture (ISCA), IEEE, 2008, pp. 377–388.

19.

Chen,

Xu,

Nakka,

Kalbarczyk and

Iyer, Defeating memory corruption attacks via pointer taintedness detection, in: International Conference on Dependable Systems and Networks (DSN), 2005, pp. 378–387.

20.

Chlipala, Mostly-automated verification of low-level programs in computational separation logic, in: ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), 2011, pp. 234–245. doi:10.1145/1993498.1993526.

21.

Chlipala, The Bedrock structured programming system: Combining generative metaprogramming and Hoare logic in an extensible program verifier, in: 18th ACM SIGPLAN International Conference on Functional Programming (ICFP), ACM, 2013, pp. 391–402. doi:10.1145/2500365.2500592.

22.

M.R.

Clarkson and

F.B.

Schneider, Hyperproperties, Journal of Computer Security 18(6) (2010), 1157–1210. doi:10.3233/JCS-2009-0393.

23.

J.A.

Clause,

Li and

Orso, Dytan: A generic dynamic taint analysis framework, in: ACM/SIGSOFT International Symposium on Software Testing and Analysis (ISSTA), ACM, 2007, pp. 196–206.

24.

Cock,

Ge,

T.C.

Murray and

Heiser, The last mile: An empirical study of timing channels on seL4, in: ACM SIGSAC Conference on Computer and Communications Security,

Ahn,

Yung and

Li, eds, ACM, 2014, pp. 570–581.

25.

J.R.

Crandall and

F.T.

Chong, Minos: Control data attack prevention orthogonal to memory model, in: 37th Annual International Symposium on Microarchitecture (MICRO), IEEE Computer Society, 2004, pp. 221–232. doi:10.1109/MICRO.2004.26.

26.

Dalton,

Kannan and

Kozyrakis, Raksha: A flexible information flow architecture for software security, in: International Symposium on Computer Architecture (ISCA), 2007, pp. 482–493.

27.

Dam,

Guanciale,

Khakpour,

Nemati and

Schwarz, Formal verification of information flow security for a simple ARM-based separation kernel, in: ACM Conference on Computer and Communications Security, ACM, 2013, pp. 223–234.

28.

Dam,

Guanciale and

Nemati, Machine code verification of a tiny ARM hypervisor, in: ACM Workshop on Trustworthy Embedded Devices,

Sadeghi,

Armknecht and

Seifert, eds, ACM, 2013, pp. 3–12. doi:10.1145/2517300.2517302.

29.

DeHon,

Boling,

Nikhil,

Rad,

Schwarz,

Sharma,

Stoy,

Sullivan and

Sutherland, DOVER: A Metadata-Extended RISC-V, in: RISC-V Workshop, 2016, Accompanying talk at http://youtu.be/r5dIS1kDars.

30.

DeHon,

Karel,

T.F.

KnightJr.,

Malecha,

Montagu,

Morisset,

Morrisett,

B.C.

Pierce,

Pollack,

Ray,

Shivers,

J.M.

Smith and

Sullivan, Preliminary design of the SAFE platform, in: 6th Workshop on Programming Languages and Operating Systems, PLOS, 2011.

31.

D.Y.

Deng,

Lo,

Malysa,

Schneider and

G.E.

Suh, Flexible and efficient instruction-grained run-time monitoring using on-chip reconfigurable fabric, in: Proceedings of the 2010 43rd Annual IEEE/ACM International Symposium on Microarchitecture, MICRO ’43, IEEE Computer Society, Washington, DC, USA, 2010, pp. 137–148. doi:10.1109/MICRO.2010.17.

32.

D.Y.

Deng and

G.E.

Suh, High-performance parallel accelerator for flexible and efficient run-time monitoring, in: IEEE/IFIP International Conference on Dependable Systems and Networks (DSN), IEEE Computer Society, 2012, pp. 1–12. doi:10.1109/DSN.2012.6263925.

33.

Dhawan and

DeHon, Area-efficient near-associative memories on FPGAs, in: International Symposium on Field-Programmable Gate Arrays (FPGA2013), 2013.

34.

Dhawan,

Hriţcu,

Rubin,

Vasilakis,

Chiricescu,

J.M.

Smith,

T.F.

KnightJr.,

B.C.

Pierce and

DeHon, Architectural support for software-defined metadata processing, in: International Conference on Architectural Support for Programming Languages and Operating Systems, 2015, pp. 487–502.

35.

Dhawan,

Kwon,

Kadric,

Hriţcu,

B.C.

Pierce,

J.M.

Smith,

DeHon,

Malecha,

Morrisett,

T.F.

KnightJr.,

Sutherland,

Hawkins,

Zyxnfryx,

Wittenberg,

Trei,

Ray and

Sullivan, Hardware support for safety interlocks and introspection, in: SASO Workshop on Adaptive Host and Network Security, 2012.

36.

Efstathopoulos,

Krohn,

VanDeBogart,

Frey,

Ziegler,

Kohler,

Mazières,

Kaashoek and

Morris, Labels and event processes in the Asbestos operating system, in: Proceedings of the Symposium on Operating Systems Principles, SOSP, ACM, 2005, pp. 17–30.

37.

J.A.

Goguen and

Meseguer, Unwinding and inference control, in: IEEE Symposium on Security and Privacy, IEEE Computer Society, 1984, pp. 75–87.

38.

Grabowski, Information flow analysis for mobile code in dynamic security environments, PhD thesis, LMU München, 2012.

39.

Gu,

Koenig,

Ramananandro,

Shao,

X.N.

Wu,

Weng,

Zhang and

Guo, Deep specifications and certified abstraction layers, in: 42nd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages,

S.K.

Rajamani and

Walker, eds, ACM, 2015, pp. 595–608. doi:10.1145/2676726.2676975.

40.

G.L.

Guernic, Automaton-based confidentiality monitoring of concurrent programs, in: 20th Computer Security Foundations Symposium, CSF, IEEE Computer Society, 2007, pp. 218–232. doi:10.1109/CSF.2007.10.

41.

G.L.

Guernic,

Banerjee,

T.P.

Jensen and

D.A.

Schmidt, Automata-based confidentiality monitoring, in: 11th Asian Computing Science Conference, Springer, 2006, pp. 75–89.

42.

Hammer and

Snelting, Flow-sensitive, context-sensitive, and object-sensitive information flow control based on program dependence graphs, International Journal of Information Security 8(6) (2009), 399–422. doi:10.1007/s10207-009-0086-1.

43.

Hedin and

Sabelfeld, A Perspective on Information-Flow Control, Marktoberdorf Summer School, IOS Press, 2011.

44.

Hedin and

Sabelfeld, Information-flow security for a core of JavaScript, in: 25th IEEE Computer Security Foundations Symposium (CSF), CSF, IEEE, 2012, pp. 3–18.

45.

Hriţcu,

Greenberg,

Karel,

B.C.

Pierce and

Morrisett, All your IFCException are belong to us, in: 34th IEEE Symposium on Security and Privacy, IEEE Computer Society Press, 2013, pp. 3–17.

46.

Hriţcu,

Hughes,

B.C.

Pierce,

Spector-Zabusky,

Vytiniotis,

Azevedo de Amorim and

Lampropoulos, Testing noninterference, quickly, in: 18th ACM SIGPLAN International Conference on Functional Programming (ICFP), 2013.

47.

Hriţcu,

Lampropoulos,

Spector-Zabusky,

Azevedo de Amorim,

Dénès,

Hughes,

B.C.

Pierce and

Vytiniotis, Testing noninterference, quickly, 2013, Sept. 2014, Submitted to Special Issue of Journal of Functional Programming for ICFP (arXiv:1409.0393).

48.

Jacob, On the derivation of secure components, in: IEEE Symposium on Security and Privacy, IEEE Computer Society, 1989, pp. 242–247.

49.

Jee,

Portokalidis,

V.P.

Kemerlis,

Ghosh,

D.I.

August and

A.D.

Keromytis, A general approach for efficiently accelerating software-based dynamic data flow tracking on commodity hardware, in: Network and Distributed System Security Symposium (NDSS), The Internet Society, 2012.

50.

J.B.

Jensen,

Benton and

Kennedy, High-level separation logic for low-level code, in: 40th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL), ACM, 2013, pp. 301–314. doi:10.1145/2429069.2429105.

51.

A.C.

Myers, Jflow: Practical mostly-static information flow control, in: Proceedings of the 26th Symposium on Principles of Programming Languages (POPL), ACM, 1999, pp. 228–241.

52.

M.G.

Kang,

McCamant,

Poosankam and

Song, DTA++: Dynamic taint analysis with targeted control-flow propagation, in: Network and Distributed System Security Symposium (NDSS), The Internet Society, 2011.

53.

Khakpour,

Schwarz and

Dam, Machine assisted proof of ARMv7 instruction level isolation properties, in: 3rd International Conference on Certified Programs and Proofs, Lecture Notes in Computer Science, Vol. 8307, Springer, 2013, pp. 276–291. doi:10.1007/978-3-319-03545-1_18.

54.

Klein,

Elphinstone,

Heiser,

Andronick,

Cock,

Derrin,

Elkaduwe,

Engelhardt,

Kolanski,

Norrish,

Sewell,

Tuch and

Winwood, seL4: Formal verification of an OS kernel, in: Proceedings of the Symposium on Operating Systems Principles, ACM, 2009, pp. 207–220.

55.

M.N.

Krohn and

Tromer, Noninterference for a practical DIFC-based operating system, in: 30th IEEE Symposium on Security and Privacy, IEEE Computer Society, 2009, pp. 61–76.

56.

M.N.

Krohn,

Yip,

M.Z.

Brodsky,

Cliffer,

M.F.

Kaashoek,

Kohler and

Morris, Information flow control for standard OS abstractions, in: Proceedings of the Symposium on Operating Systems Principles, SOSP, ACM, 2007, pp. 321–334.

57.

Kwon,

Dhawan,

J.M.

Smith,

T.F.

KnightJr. and

DeHon, Low-fat pointers: Compact encoding and efficient gate-level implementation of fat pointers for spatial safety and capability-based security, in: ACM SIGSAC Conference on Computer and Communications Security (CCS), ACM, 2013, pp. 721–732.

58.

Leroy, A formally verified compiler back-end, Journal of Automated Reasoning 43(4) (2009), 363–446. doi:10.1007/s10817-009-9155-4.

59.

Leroy and

Blazy, Formal verification of a C-like memory model and its uses for verifying program transformations, Journal of Automated Reasoning 41(1) (2008), 1–31. doi:10.1007/s10817-008-9099-0.

60.

Mann and

Starostin, A framework for static detection of privacy leaks in Android applications, in: ACM Symposium on Applied Computing (SAC), ACM, 2012, pp. 1457–1462.

61.

Masri,

Podgurski and

Leon, Detecting and debugging insecure information flows, in: International Symposium on Software Reliability Engineering (ISSRE), IEEE Computer Society, 2004, pp. 198–209. doi:10.1109/ISSRE.2004.17.

62.

Medel,

A.B.

Compagnoni and

Bonelli, A typed assembly language for non-interference, in: 9th Italian Conference on Theoretical Computer Science (ICTCS), Lecture Notes in Computer Science, Vol. 3701, Springer, 2005, pp. 360–374.

63.

Montagu,

B.C.

Pierce and

Pollack, A theory of information-flow labels, in: 26th IEEE Computer Security Foundations Symposium (CSF), IEEE, 2013, pp. 3–17.

64.

Moore and

Chong, Static analysis for efficient hybrid information-flow control, in: Proceedings of the 24th Computer Security Foundations Symposium, CSF, IEEE Computer Society, 2011, pp. 146–160.

65.

Morrisett,

Tan,

Tassarotti,

J.-B.

Tristan and

Gan, RockSalt: Better, faster, stronger SFI for the x86, in: ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), ACM, 2012, pp. 395–404. doi:10.1145/2254064.2254111.

66.

T.C.

Murray,

Matichuk,

Brassil,

Gammie,

Bourke,

Seefried,

Lewis,

Gao and

Klein, seL4: From general purpose to a proof of information flow enforcement, in: 34th IEEE Symposium on Security and Privacy, IEEE, 2013, pp. 415–429.

67.

T.C.

Murray,

Matichuk,

Brassil,

Gammie and

Klein, Noninterference for operating system kernels, in: Second International Conference on Certified Programs and Proofs (CPP), Lecture Notes in Computer Science, Vol. 7679, Springer, 2012, pp. 126–142. doi:10.1007/978-3-642-35308-6_12.

68.

A.C.

Myers, Mostly-static decentralized information flow control, PhD thesis, Massachusetts Institute of Technology, 1999.

69.

A.C.

Myers and

Liskov, Protecting privacy using the decentralized label model, Transactions on Software Engineering And Methodology (TOSEM) 9 (2000), 410–442. doi:10.1145/363516.363526.

70.

M.O.

Myreen and

M.J.C.

Gordon, Hoare logic for realistically modelled machine code, in: 13th International Conference on Tools and Algorithms for the Construction and Analysis of Systems (TACAS), Lecture Notes in Computer Science, Vol. 4424, Springer, 2007, pp. 568–582. doi:10.1007/978-3-540-71209-1_44.

71.

Ni and

Shao, Certified assembly programming with embedded code pointers, in: Symposium on Principles of Programming Languages (POPL), ACM, 2006, pp. 320–333.

72.

Pistoia,

Banerjee and

D.A.

Naumann, Beyond stack inspection: A unified access-control and information-flow security model, in: Proceedings of the Symposium on Security and Privacy, SP, IEEE Computer Society, 2007, pp. 149–163.

73.

Pottier and

Simonet, Information flow inference for ML, ACM Transactions on Programming Languages and Systems 25(1) (2003), 117–158. doi:10.1145/596980.596983.

74.

Qin,

Wang,

Li,

Kim,

Zhou and

Wu, LIFT: A low-overhead practical information flow tracking system for detecting security attacks, in: 39th IEEE/ACM International Symposium on Microarchitecture (MICRO-39), 2006, pp. 135–148.

75.

Russo and

Sabelfeld, Dynamic vs. static flow-sensitive security analysis, in: 23rd Computer Security Foundations Symposium (CSF), CSF, IEEE Computer Society, 2010, pp. 186–199.

76.

Ruwase,

P.B.

Gibbons,

T.C.

Mowry,

Ramachandran,

Chen,

Kozuch and

M.P.

Ryan, Parallelizing dynamic information flow tracking, in: 20th Annual ACM Symposium on Parallelism in Algorithms and Architectures (SPAA), ACM, 2008, pp. 35–45.

77.

Sabelfeld and

Myers, Language-based information-flow security, IEEE Journal on Selected Areas in Communications 21(1) (2003), 5–19. doi:10.1109/JSAC.2002.806121.

78.

Sabelfeld and

Russo, From dynamic to static and back: Riding the roller coaster of information-flow control research, in: Ershov Memorial Conference, Springer, 2009, pp. 352–365.

79.

Sabelfeld and

Sands, Dimensions and principles of declassification, in: Computer Security Foundations 18th Workshop, IEEE, 2005, pp. 255–269.

80.

F.B.

Schneider, Enforceable security policies, ACM Transactions of Information Systems Security 3(1) (2000), 30–50. doi:10.1145/353323.353382.

81.

Sevcík,

Vafeiadis,

F.Z.

Nardelli,

Jagannathan and

Sewell, Relaxed-memory concurrency and verified compilation, in: Symposium on Principles of Programming Languages (POPL), ACM, 2011, pp. 43–54.

82.

Shao, Clean-slate development of certified OS kernels, in: Conference on Certified Programs and Proofs,

Leroy and

Tiu, eds, ACM, 2015, pp. 95–96.

83.

Shinnar,

Pistoia and

Banerjee, A language for information flow: Dynamic tracking in multiple interdependent dimensions, in: Proceedings of the 4th Workshop on Programming Languages and Analysis for Security, PLAS, ACM, 2009, pp. 125–131. doi:10.1145/1554339.1554354.

84.

Shrobe,

DeHon and

T.F.

KnightJr., Trust-management, intrusion-tolerance, accountability, and reconstitution architecture (TIARA), December 2009.

85.

Stefan,

Buiras,

E.Z.

Yang,

Levy,

Terei,

Russo and

Mazières, Eliminating cache-based timing attacks with instruction-based scheduling, in: 18th European Symposium on Research in Computer Security (ESORICS), Lecture Notes in Computer Science, Vol. 8134, Springer, 2013, pp. 718–735.

86.

Stefan,

Russo,

Buiras,

Levy,

J.C.

Mitchell and

Mazières, Addressing covert termination and timing channels in concurrent information flow systems, in: Proceedings of the International Conference on Functional Programming (ICFP), ACM, 2012.

87.

Stefan,

Russo,

Mazières and

J.C.

Mitchell, Disjunction category labels, in: 16th Nordic Conference on Secure IT Systems, NordSec, Springer, 2011, pp. 223–239.

88.

Stefan,

Russo,

J.C.

Mitchell and

Mazières, Flexible dynamic information flow control in Haskell, in: 4th Symposium on Haskell, ACM, 2011, pp. 95–106.

89.

G.E.

Suh,

J.W.

Lee,

Zhang and

Devadas, Secure program execution via dynamic information flow tracking, in: International Conference on Architectural Support for Programming Languages and Operating Systems, 2004, pp. 85–96.

90.

The Coq Development Team. The Coq Reference Manual, version 8.4, 2012, Available electronically at http://coq.inria.fr/doc.

91.

Vachharajani,

M.J.

Bridges,

Chang,

Rangan,

Ottoni,

J.A.

Blome,

G.A.

Reis,

Vachharajani and

D.I.

August, RIFLE: An architectural framework for user-centric information-flow security, in: 37th International Symposium on Microarchitecture, 2004.

92.

Venkataramani,

Doudalis,

Solihin and

Prvulovic, FlexiTaint: A programmable accelerator for dynamic taint propagation, in: 14th International Symposium on High Performance Computer Architecture (HPCA), 2008, pp. 173–184.

93.

Volpano,

Smith and

Irvine, A sound type system for secure flow analysis, Journal of Computer Security 4(3) (1996), 167–187. doi:10.3233/JCS-1996-42-304.

94.

Yu and

Islam, A typed assembly language for confidentiality, in: 15th European Symposium on Programming (ESOP), Lecture Notes in Computer Science, Vol. 3924, Springer, 2006, pp. 162–179.

95.

Yu, More typed assembly languages for confidentiality, in: 5th Asian Symposium on Programming Languages and Systems (APLAS), Lecture Notes in Computer Science, Vol. 4807, Springer, 2007, pp. 86–104. doi:10.1007/978-3-540-76637-7_7.

96.

S.A.

Zdancewic, Programming languages for information security, PhD thesis, Cornell University, 2002.

97.

Zeldovich,

Boyd-Wickizer,

Kohler and

Mazières, Making information flow explicit in HiStar, Communications of the ACM 54(11) (2011), 93–101. doi:10.1145/2018396.2018419.

98.

Zhang,

Askarov and

A.C.

Myers, Predictive mitigation of timing channels in interactive systems, in: 18th ACM Conference on Computer and Communications Security, ACM, 2011, pp. 563–574.

A verified information-flow architecture

Abstract

Keywords

1. Introduction

2. Overview of SAFE

3. Abstract IFC machine

Lemma 7.1 (Fault handler correctness, allowed case).

Lemma 7.2 (Fault handler correctness, disallowed case).

8. Refinement

Definition 8.3 (Refinement).

Definition 8.4 (Refinement via states).

9. Refinements between concrete and abstract

9.1. Abstract and symbolic rule machines

Definition 9.1 (Abstract and symbolic rule machines as generic machines).

Lemma 9.2. The symbolic rule machine instantiated with the rule table R abs refines the abstract machine through ( = , = ) . 9.2. Concrete machine refines symbolic rule machine

Definition 9.3 (Concrete machine as generic machine).

Theorem 9.8. The concrete IFC machine refines the abstract IFC machine via ( ⊳ s c , ⊳ e c ) . 9.4. Abstract machine refines concrete machine

10. Noninterference

Definition 10.1 (Observation).

Definition 10.2 (TINI).

Theorem 10.8. The concrete IFC machine running the fault handler ϕ R abs satisfies TINI. 11. An extended system

6 It would be interesting to describe an implementation of the memory manager in a still-lower-level concrete machine with no built-in Alloc instruction, but we leave this as future work.

11.3. Labeling with sets of principals

12. Related work

13. Conclusions and future work

Footnotes

Acknowledgments

References

Lemma 9.2.
The symbolic rule machine instantiated with the rule table $R^{abs}$ refines the abstract machine through $(=, =)$ .

9.2. Concrete machine refines symbolic rule machine

Theorem 9.8.
The concrete IFC machine refines the abstract IFC machine via $(⊳_{s}^{c}, ⊳_{e}^{c})$ .

9.4. Abstract machine refines concrete machine

Theorem 10.8.
The concrete IFC machine running the fault handler $ϕ_{R^{abs}}$ satisfies TINI.

11. An extended system

⁶
It would be interesting to describe an implementation of the memory manager in a still-lower-level concrete machine with no built-in $Alloc$ instruction, but we leave this as future work.