Tracking Information Flow at the Gate-Level for Secure Architectures

Many critical systems require tight guarantees on the flow of information, for example when handling secret cryptographic keys or critical avionics data. Unfortunately, even understanding the true flow of information through a traditional processor is difficult because executing an instruction affects so much internal state: the program counter, the memory system, forwarding and pipeline logic, and countless other bits throughout the machine. We propose a new method for constructing and analyzing architectures capable of tracking all information flow within the machine, including all explicit data transfers and all implicit flows (those subtly devious flows caused by not performing conditional operations). The key to such an approach is our novel gate-level information flow tracking method which provides a way to compose complex logical structures with well defined information flow properties. Starting from a simple NAND gate, we describe how to to create more complex structures including muxes, control, registers, and finally a small microprocessor, all then implemented and tested on an FPGA. The resulting system, while less efficient than a traditional processor, is the first proof of concept demonstrating strong information-containment all the way down to the gate-level implementation. 1 High Assurance Systems Systems responsible for controlling aircraft, protecting the master secret keys for a bank, or regulating access to extremely sensitive commercial or military information, all demand a level of assurance far beyond the norm. Creating these systems today is an incredibly expensive operation both in terms of time and money; and even assessing the assurance of the resulting system can cost upwards of $10,000 per line of code [2]. The enforcement of information flow policies is one of the most important aspects of such high assurance systems, yet is also one of the hardest to get correct in implementation. The recent explosion of work on dynamic dataflow tracking architectures has led to many clever new ways of detecting everything from general code injection attacks to cross-site scripting attacks. The basic scheme keeps track of a binary property, trusted or untrusted, for every piece of data. Data from “untrusted” sources (e.g. from the network) are marked as untrusted, and the output of an instruction is marked as untrusted if any of its inputs are untrusted. While these systems will likely prove themselves useful in a variety of real-life security scenarios, precisely capturing the flow of information in a traditional microprocessor quickly leads to an explosion of untrusted state because information is leaked practically everywhere and by everything. If you are executing an exceedingly critical piece of software, for example, using your private key to sign an important message, information about that key is leaked in some form or another by almost everything that you do with it. The time it takes to perform the authentication, the elements in the cache you displace due to your operations, the paths through the code the encryption software takes, even the paths through your code that are never taken can leak information about the key. This paper summarizes an earlier paper [7] that presented, for the first time, a processor architecture and implementation that can track all information-flows. On such a microprocessor it is impossible for an adversary to hide the flow of information through the design, whether that flow was intended by both parties (e.g. through a covert channel) or not (e.g. through a timing-channel). One of the key insights in this paper is that all information flows, whether implicit, covert, or explicit, look surprisingly similar at the gate level where weakly defined ISA descriptions give way to precise logical functions. While past approaches have assumed that any use of untrusted data should lead to an untrusted output, we observe that at the gate level this is overly conservative. If one input to an AND gate is 0, the other input can never affect the result and thus should have no bearing on the trust of the output. Based upon this observation, we introduce a novel logic discipline, Gate-Level Information-Flow Tracking (GLIFT) logic, which is built around a precise method for augmenting arbitrary logic blocks with tracking logic and a further method for making compositions of those blocks. Using this discipline we demonstrate how to create an architecture that, while