Sean Noble Anderson
Portland State University
ander28@pdx.edu
Roberto Blanco
MPI-SP
roberto.blanco@mpi-sp.org
Leonidas Lampropoulos
{@IEEEauthorhalign}
Benjamin C. Pierce
University of Maryland, College Park
leonidas@umd.edu
University of Pennsylvania
bcpierce@cis.upenn.edu
Andrew Tolmach
Portland State University
tolmach@pdx.edu
Abstract
The term stack safety is used to describe a variety of compiler,
run-time, and hardware mechanisms for protecting stack memory. Unlike
“the heap,” the ISA-level stack does not correspond to a single
high-level language concept: different compilers use it in different
ways to support procedural and functional abstraction mechanisms from
a wide range of languages. This protean nature makes it difficult to
nail down what it means to correctly enforce stack safety.
We propose a new formal characterization of stack safety using concepts
from language-based security. Rather than treating
stack safety as a monolithic property, we decompose it into an
integrity property and a confidentiality property for each of the
caller and the callee, plus a control-flow property: five properties
in all.
This formulation is motivated by a particular class of enforcement
mechanisms, the “lazy” stack safety micro-policies studied by
Roessler and DeHon [DBLP:conf/sp/RoesslerD18], which permit
functions to write into one another’s frames but taint the
changed locations so that the frame’s owner cannot access them. No
existing characterization of stack safety captures this style of
safety; we capture it here by stating our properties in terms of the
observable behavior of the system.
Our properties go further than previous formal definitions of stack
safety, supporting caller- and callee-saved registers, arguments
passed on the stack, and tail-call elimination. We validate the properties by using them to distinguish between
correct and incorrect implementations of Roessler and DeHon’s
micro-policies using property-based random testing. Our test harness
successfully identifies several broken variants, including Roessler
and DeHon’s lazy policy; a repaired version of their policy passes
our tests.
I Introduction
Functions in high-level languages (and related abstractions such
as procedures, methods, etc.) are units of computation
that invoke one another to define larger computations in a modular way.
At a low level, each function activation manages its own local
variables, spilled temporaries, etc., as well as information about the
caller to which it will return.
The call stack is the fundamental data structure used to
implement functions, aided by an Application Binary Interface (ABI)
that defines how registers are shared between activations.
From a security perspective, attacks on the call stack
are attacks on the function abstraction itself.
Indeed, the stack is an ancient [phrack96:smashingthestack] and
perennial [mitre-cwe, DBLP:conf/raid/VeendCB12, DBLP:conf/sp/SzekeresPWS13, DBLP:conf/sp/HuSACSL16, msrc-bluehat, chromium-security]
target for low-level attacks, sometimes involving control-flow
hijacking via corrupting the return address, sometimes memory corruption
more generally.
The variety in attacks on the stack is mirrored in the range of
software and hardware protections that aim to prevent them,
including stack canaries [Cowan+98],
bounds checking [NagarakatteZMZ09, NagarakatteZMZ10, DeviettiBMZ08],
split stacks [Kuznetsov+14],
shadow stacks [Dang+15, Shanbhogue+19],
capabilities [Woodruff+14, Chisnall+15, SkorstengaardLocal, SkorstengaardSTKJFP, Georges22:TempsDesCerises],
and hardware tagging [DBLP:conf/sp/RoesslerD18, Gollapudi+23].
But enforcement mechanisms can be brittle, successfully eliminating one
attack while leaving room for others. To avoid an endless game of
whack-a-mole, we seek formal properties of safe behavior that can be
proven, or at least rigorously tested. Such properties can be used as
the specification against which enforcement can be validated—even
enforcement mechanisms that do not fulfill a property can benefit from the
ability to articulate why and when they may fail.
Many of the mechanisms listed above are fundamentally ill-suited for
offering formal guarantees: they may impede attackers, but they do not provide
universal protection. Shadow stacks, for instance, aim to “restrict
the flexibility available in creating gadget chains”
[Shanbhogue+19], not to categorically rule out attacks. Other
mechanisms, such as SoftBound [NagarakatteZMZ09] and code-pointer
integrity [Kuznetsov+14], do aim for stronger guarantees, but not
formal ones. To our knowledge, the sole
line of work making a formal claim to protect stack safety is the
study of secure calling conventions by Skorstengaard et
al. [SkorstengaardSTKJFP] and Georges et
al. [Georges22:TempsDesCerises].
Some of the other mechanisms listed above should also be amenable to strong
formal guarantees. In particular, Roessler and DeHon
[DBLP:conf/sp/RoesslerD18] present an array of tag-based
micro-policies [pump_oakland2015] for stack safety that aim to offer
universal protection. But the reasoning involved can be subtle:
they include micro-policy optimizations, Lazy Tagging and Lazy Clearing
(likely to be deployed together, which we hereafter refer to as Lazy
Tagging and Clearing, or LTC). LTC allows function activations to write
improperly into one another’s stack frames, but ensures that the owner of
the corrupted memory cannot access it afterward, avoiding expensive
clearings of the stack frame.
Under this policy, one function activation can corrupt another’s
memory—just not in ways that affect observable behavior.
Therefore, LTC would not fulfill Georges et al.’s property
(adapted to the tagged setting). But LTC does arguably enforce stack safety,
or as Roessler and DeHon describe it informally, a sort of data-flow
integrity tied to the stack. A looser, more observational
definition of stack safety is needed to fit this situation.
We propose here a formal characterization of stack safety based on
the intuition of protecting function activations from each other and
using the tools of language-based
security [sabelfeld2003language] to treat function activations as
security principals. We decompose stack safety into a family of
properties describing
the integrity and confidentiality of the caller’s local state
and the callee’s behavior during (and after) the callee’s execution,
together with the
well-bracketed control flow (WBCF) property articulated by
Skorstengaard et al. [SkorstengaardSTKJFP].
Our properties are stated abstractly in the hope that they can also be
applied to other enforcement mechanisms besides LTC.
However, it does not seem feasible to give
a universal definition of stack safety
that applies to all architectures and compilers.
While many security properties can be described purely at
the level of a high-level programming language and translated to a
target machine by a secure compiler, stack safety cannot be defined in
this way, since “the stack” is not explicitly present in the
definitions of most source languages but rather is implicit in the semantics
of features such as calls and returns.111
Contrast Azevedo de
Amorim et al.’s work on heap safety
[DBLP:conf/post/AmorimHP18], where the concept of the heap figures
directly in high-level language semantics and its security is
therefore amenable to a high-level treatment.
But neither can stack safety be described coherently as a purely
low-level property;
indeed, at the lowest level, the specification of a “well-behaved
stack” is almost vacuous. The ISA is not concerned with such
questions as whether a caller’s frame should be readable or writable
to its callee. Those are the purview of high-level languages built
atop the hardware stack.
Thus, any low-level treatment of stack safety must begin by asking:
which high-level features are supported in a given
setting using the stack, and how does their presence influence
the expectation of well-bracketed control flow, confidentiality,
and integrity? We begin with a simple system
with very few features, then move to a more realistic one supporting
tail-call elimination, argument passing on the stack, and callee-save
registers. Our properties are factored so that the basic structure
of each of our five properties remains constant while the presence or
absence of different features leads to subtler differences in how
they behave.
We demonstrate the usefulness of our properties for distinguishing
between correct and
incorrect enforcement using
QuickChick [Denes:VSL2014, Pierce:SF4], a property-based
random testing tool for Coq.
Indeed, we find that the published version of LTC is flawed in
a way that undermines both integrity and confidentiality; after
correcting this flaw, LTC satisfies all of our
properties. Further, we modify LTC to protect the features of
our more realistic system and apply
random testing to validate this extended protection mechanism against
the extended properties.
In summary, we offer the following contributions:
•
We give a novel characterization of stack safety as a conjunction
of security properties—confidentiality and integrity for callee
and caller—plus well-bracketed control-flow.
The properties are parameterized over a notion of
external observation, allowing them to characterize lazy enforcement
mechanisms.
•
We extend these core definitions to
describe a realistic setting with argument passing on the stack,
callee-saves registers, and tail-call elimination. The model is
modular enough that adding these features is straightforward.
•
We validate a published enforcement mechanism, Lazy
Tagging and Clearing, via property-based random testing, find that
it falls short, and propose and validate a fix.
The following section offers a brief overview of our framework and
assumptions. SectionIII walks through a function call in
a simple example machine, discusses informally how each of our properties
applies to it, and motivates the properties
from a security perspective.
SectionIV formalizes the machine model,
its security semantics, and the stack safety properties built on these.
LABEL:sec:extensions describes how to support an extended set of features.
LABEL:sec:enforcement describes the micro-policies that we test,
LABEL:sec:testing the testing framework itself, and
LABEL:sec:relwork and LABEL:sec:future related and future work.
The accompanying artifact 222https://github.com/SNoAnd/stack-safety
contains formal definitions (in Coq) of our
properties, plus our testing framework. It does not include proofs, since
we use Coq primarily for the QuickChick testing library and to
ensure that our definitions are unambiguous. Formal proofs are left
as future work.
II Framework and Assumptions
Stack safety properties need to describe the behavior of machine code, but they naturally
talk about function activations and stack contents—abstractions that
are typically not visible at machine level. To bridge this gap,
our properties are defined in terms of a security semantics layered on top of
the standard execution semantics of the machine. The security semantics identifies certain
state transitions of the machine as security-relevant operations, which update
a notional security context. This context consists of
an (abstract) stack of function activations, each associated with a view
that maps each machine state element (memory location or register)
to a security class (active, sealed, etc.) specifying how the activation
can access the element.
The action of a security-relevant operation on the context is defined by a function
that characterizes how the operation’s underling machine code ought to
implement the function abstraction in terms of the stack and registers.
Given the security classes of the elements of the machine state, we
define high-level
security properties—integrity, confidentiality, and well-bracketed
control flow—as
predicates that must hold on each call. These predicates draw on the idea of
variant states from the theory of non-interference, plus a notion of
observable events, which might include specific function calls (e.g., system
calls that perform I/O), writes to special addresses representing
memory-mapped regions, etc. For example, to show that certain locations are kept
secret, it suffices to compare executions starting at machine states which vary at those locations
and check that their traces of observable events are the same. This structure
allows us to talk about the eventual impact of leaks or memory corruption without
reference to internal implementation details and, in particular, to support lazy enforcement by
flagging corruption of values only when it can actually impact visible behavior.
We introduce these properties by example in SectionIII and
formally in SectionIV. In the remainder
of this section we introduce the underlying semantic framework
in more detail.
Machine Model
We assume a conventional ISA (e.g., RISC-V, x86-64, etc.), with registers including a program counter
and stack pointer.
We make no particular assumptions about the provenance of the machine code; in particular,
we do not assume any particular compiler.
If the machine is enhanced with enforcement mechanisms such as hardware
tags [pump_hasp2014, Gollapudi+23] or
capabilities [Woodruff+14], we
assume that the behavior of these mechanisms is incorporated into the basic
step semantics of the machine, with a notion of “compatible” states that
share security behavior that may be defined based on the enforcement mechanism.
Failstop behavior by enforcement mechanisms is modeled as stepping to the same state
(and thus silently diverging).
Security Semantics
A security semantics extends the core machine model
with additional context about the identities of current and pending
functions (which act as security principals) and about their security
requirements on registers and memory. This added context is purely notional;
it does not affect the behavior of the core machine. The security context
evolves dynamically through the execution of security-relevant operations,
which include calls, returns, and frame manipulation.
Our security properties are phrased in terms of this context, often as predicates
on future states (“when control returns to the current function, X
must hold…”)
or as relations on traces of future execution
(hyper-properties).
Security-relevant operations abstract over the implementation details of the
actions they take. Since the same machine instruction may be used by compilers for
different purposes, we assume that the compiler or another trusted
source has provided
labels to identify the security-relevant purpose of each instruction,
if any. For instance,
in the tagged RISC-V architecture
that we use in our examples and tests,
calls and returns are conventionally performed using the jal
(“jump-and-link”)
and jalr (“jump-and-link-register”) instructions, but these
instructions might also be used for other things.
These considerations lead to an annotated version of the
machine transition function, written , where and are machine states, is
an optional externally observable event, and is a
list of security-relevant operations—necessary because a single step might
perform multiple simultaneous operations.
This is then lifted into a transition between pairs of machine states
and contexts by applying a transition function parameterized by the operation.
We will decompose this function into rules associated with each operation and introduce
them as needed.
The most important of these rules describe call and return operations.
A call pushes a new view onto the context stack and changes the class of the
caller’s data to protect it from the new callee; a return reverses these steps.
Other operations signal how parts of the stack frame are being used to store
or share data, and their corresponding rules alter the classes of different
state elements accordingly.
Exactly which operations and rules are needed depends on
what code features we wish to support.
The set of security-relevant operations () covered in this paper is given in
TableI. A core set of operations covering calls, returns, and local
memory is introduced in the example in SectionIII
and formalized in SectionIV. An extended set covering simple memory sharing and
tail-call elimination is described in LABEL:sec:extensions and tested in LABEL:sec:testing.
The remaining operations are needed for the capability-based model in
LABEL:app:ptr.
TABLE I: Security-relevant operations and their parameters, with the
sections where they are first defined or used. Entries in light grey do not appear in
our examples, but are part of our testing. Dark grey entries are not tested.
Views and Security Classes
The security context consists of a stack of views, where a view is a
function mapping
each state element to a security class—one of
, , , or .
State elements that are outside of the stack—general-purpose memory used for
globals and the heap, as well as the code region and globally shared
registers—are always labeled . We place security requirements on some
elements for purposes of the well-bracketed control flow WBCF property, and a
given enforcement mechanism
might restrict their access (e.g., by rendering code immutable), but for integrity
and confidentiality purposes they are considered accessible at all times.
When a function is newly activated, every stack location that is available
for use but not yet initialized
is . From the perspective of the caller, the callee has no obligations
regarding its use of free elements.
Arguments are marked , meaning that their contents may be
used safely.
When a function allocates memory for its own stack frame, that memory will also be .
Then, on a call, elements that are not being used to communicate with
the callee will become —i.e., reserved for an inactive principal
and expected to be unchanged when it becomes active again.
Instantiating the Framework
Conceptually, the following steps are needed to instantiate the framework to a specific machine
and coding conventions: (i) define the base machine semantics, including any hardware
security enforcement features; (ii) identify the set of
security-relevant operations and rules required by the coding conventions; (iii) determine
how to label machine instructions with security-relevant
operations as appropriate; (iv) specify the form of observable events.
Threat Model and Limitations
When our properties are used to evaluate a system, the threat model
will depend on the details of that system. However, there are some
constraints that our design puts on any system. In particular, we must
trust that the security-relevant operations have been correctly labeled.
If a compiled function
call is not marked as such, then the caller’s data might not be
protected from the callee; conversely, marking too many operations as
calls may cause otherwise safe programs to be rejected.
We do not assume that low-level code adheres to any single calling
convention or is being used to implement any particular
source-language constructs.
Indeed, if the source language is C, then high-level programs might
contain undefined behavior, in which case they might be compiled to
arbitrary machine code.
In general, it is impossible to distinguish buggy machine code from an
attacker. In examples, we often identify one function or another as
an attacker, but our framework does not require any static division between trusted
and untrusted code, and we aim to protect even buggy code.
This is a strong threat model, but it does omit some important aspects
of stack safety in real systems: in particular, it does not address
concurrency. Hardware and timing attacks are also out of scope.
III Properties by Example
In this section, we introduce our security properties by means
of small code examples, using a simple set of security-relevant operations for
calls, returns, and private allocations.
Figure1 gives C code and possible corresponding compiled 64-bit RISC-V code
for a function main, which
takes an argument secret and initializes a local variable sensitive to contain
potentially sensitive data.
Then main calls another function f,
and afterward it performs a test on sensitive to decide whether
to output secret. Since sensitive is initialized to 0,
the test should always fail, and main should instead output the return value of f.
Output is performed by writing to the special global out,
and we assume that such writes are the only observable events in the system.
The C code is compiled using the standard RISC-V calling conventions [RISC-V-CC].
In particular, the function’s first argument and its
return value are both passed in a0.
Memory is byte addressed, and the stack grows towards
lower addresses. We assume that main begins at address 0 and its
callee f at address 100. The annotations in the right-hand column are
security-relevant operations, described further below.
The assembly is a simplified but otherwise typical compilation of the
source code into RISC-V; its details are less important than the positions
of the security-relevant operations.
volatile int out;
void main(int secret) {
int sensitive = 0;
int res = f();
if (sensitive == 42)
out = secret;
else
out = res;
}
0:
addi sp,sp,-20
4:
sd ra,12(sp)
8:
sw a0,8(sp)
12:
sw zero,4(sp)
16:
jal f,ra
20:
sw a0,0(sp)
24:
lw a4,4(sp)
28:
li a5,42
32:
bne a4,a5,L1
36:
lw a0,8(sp)
40:
sw a0,out
44:
j L2
L1, 48:
lw a0,0(sp)
52:
sw a0,out
L2, 56:
ld ra,12(sp)
60:
addi sp,sp,20
64:
jalr ra
Figure 1: Example: C and assembly code for main and layout of its stack frame (the stack grows to the left).
Now, suppose that f is actually an attacker seeking
to leak secret. It might do so in a number of ways, shown as snippets of
assembly code in Fig.2.
Leakage is most obviously viewed as a violation of main’s confidentiality.
In Fig.2(a), f takes an offset from the stack
pointer, accesses secret, and directly outputs it. More
subtly, even if it is somehow prevented from outputting secret
directly, f
can instead return its value so that main stores it to out,
as in Fig.2(b).
Beyond simply reading secret, the attacker might overwrite sensitive
with 42, guaranteeing that main publishes its own secret unintentionally
(Fig.2(c)); this does not violate main’s
confidentiality, but
rather its integrity.
In Fig.2(d), the attacker arranges to return to the
wrong instruction, thereby bypassing the check and publishing secret regardless; this
violates the program’s well-bracketed control flow (WBCF).
In Fig.2(e), a different attack violates WBCF, this time
by returning to the correct program counter but with the wrong stack pointer.
(We pad some of these variants with nops just so that all the
snippets have the same length, which keeps the step numbering uniform in Fig.3.)
100:
lw a4,8(sp)
104:
sw a4,out
108:
li a0,1
112:
jalr ra
(a)Leaking secret directly
100:
lw a4,8(sp)
104:
mov a0,a4
108:
nop
112:
jalr ra
(b)Leaking secret indirectly
100:
li a5,42
104:
sw a5,4(sp)
108:
li a0,1
112:
jalr ra
(c)Attacking sensitive
100:
addi ra,ra,16
104:
nop
108:
nop
112:
jalr ra
(d)Attacking control flow
100:
addi sp,sp,8
104:
nop
108:
nop
112:
jalr ra
(e)Attacking stack pointer integrity
Figure 2: Example: assembly code alternatives for f as an attacker.
The security semantics for this program is based
on the security-relevant events noted in the right columns of Figs.1 and 2,
namely execution of instructions that allocate or deallocate space (specified by
an sp-relative offset and size), make a call (with a specified list of argument registers),
or make a return.
Our security semantics attaches a security context to the machine state,
consisting of a view and a stack of pending activations’ views.
Figure3 shows how the security context evolves over the first few
steps of the program. (The formal details of the security semantics are described in
SectionIV, and the context evolution rules are formalized in Fig.7.)
Execution begins at the start of main, with the program counter
(pc) set to zero and the stack pointer (sp) at address 1000.
State transitions are numbered and may be labeled with a security operation, written
, between steps.
The initial view maps all stack addresses below sp to and the remainder of
memory to . The sole used argument register, a0, is mapped to ;
other caller-save registers are mapped to and callee-save registers to .
Step 1 allocates a word each for secret, sensitive, and res, as well
as two words for the return address; this has the
effect of marking those bytes .
We use to denote updates to .
pc
sp
Context
0
1000
4
980
2-4
16
980
100
980
6-8
112
980
20
980
Figure 3: Execution of example up through the return from f. In stack diagrams, addresses increase to the right, stack grows to the left, and boxes represent 4-byte words.
At step 5, the current principal’s record is pushed onto the inactive list.
The callee’s view is updated from the caller’s such that all memory locations
become . (For now we assume no sharing of stack memory between activations; data is
passed only through argument registers, which remain active. In the presence of memory
sharing, some memory would remain active, too.)
Function f does not take any arguments; if it did, any registers containing them would be
mapped to , while any non-argument, caller-saved
registers are mapped to . In the current example, only register a0 changes
security class. All callee-save registers remain for all calls, so
if, in the example, we varied the assembly code for main so that sensitive was stored
in a callee-save register (e.g., s0) rather than in memory, its security class would still
be at the entry to f.
At step 9, f returns and the topmost inactive view, that of main, is restored.
We now show how this security semantics can be used to define notions of confidentiality,
integrity, and correct control flow in such a way that many classes of
bad behavior, including the attacks in Fig.2, are
detected as security violations.
Well-Bracketed Control Flow
To begin with, if f returns to an unexpected place (i.e., or
), we say that it has violated WBCF. WBCF is a relationship between
call steps and their corresponding return steps: just after the return, the program
counter should be at the next instruction below the call,
and the stack pointer should have the same value that it had before the call.
Both of these are essential for security. In Fig.2(d), the attacker adds
16 to the return address and then returns; this bypasses the if-test in the code and outputs
secret.
In Fig.2(e), the attacker returns with instead of the
correct . In this scenario, given the layout of main’s frame,
res
sens
sec
main’s attempt to read sensitive may instead
read part of the return address, and its attempt to output
res will instead output secret.
Before the call, the program counter is 16 and the stack pointer is 980.
So we define a predicate on states that should hold just after the return:
.
We can identify the point just after the return (if a return occurs)
as the first state in which the pending call stack is smaller than it was
just after the call.
WBCF requires that, if is the state at that point, then holds.
This property is formalized in LABEL:tab:props, line 1.
Stack Integrity
Like WBCF, stack integrity defines a condition at the call that must hold upon
return. This time the condition applies to all of the memory in the caller’s
frame. In Fig.3 we see the lifecycle of an allocated frame:
upon allocation, the view labels it , and when a call is made, it instead
becomes . Intuitively, the integrity of main
is preserved if, when control returns to it, any elements
are identical to when it made the call.
Again, we need to know when a caller has been returned to,
and we use the same mechanism of checking the depth of the call stack.
In the case of the call from main to f, the elements are the
addresses 980 through 999 and callee-saved registers such as
the stack pointer. Note that callee-saved registers often change
during the call—but if the caller accesses them after the call, it should find them
restored to their prior value.
While it would be simple to define integrity as “all sealed elements retain their
values after the call,” this would be stricter than necessary. Suppose that
a callee overwrites some data of its caller, but the caller never accesses that data
(or only does so after re-initializing it). This would be harmless, with the callee
essentially using the caller’s memory as scratch space, but the caller never seeing any change.
For a set of elements ,
a pair of states and are -variants if
their values an only disagree on elements in .
We say that the elements of are irrelevant
in if they can be replaced by arbitrary other values without changing the
observable behavior of the machine. All other elements are relevant.333
This story is slightly over-simplified. If an enforcement mechanism maintains
additional state associated with elements, such as tags, we don’t want that
state to vary. This is touched on in SectionIV-D.
We define caller integrity (ClrI) as the property that
every relevant element that is under the callee’s view is restored
to its original value at the return point.
(This property is formalized in LABEL:tab:props, line 2).
Figure 4: Integrity Violation: sensitive changed, and if varied, changes future outputs
In our example setting, the observation trace consists of the sequence
of values written to out. In Fig.2(c) the states before
and after the call differ in the value of sensitive. Figure4
shows the states before and after the call, which disagree on the value at
sensitive. If we consider a
variant of the original return state in which sensitive is 0 (orange)
as opposed to 42 (blue), that state will eventually output 1, while the actual
execution outputs 5. This means that sensitive is relevant.
To be more explicit, similar to WBCF, we define
as a predicate on states that holds if
all relevant sealed addresses in are the same as after step 5.
We require that hold on the state following the matching return,
which is reached by step 9. Here sensitive has obviously changed, but we
just saw that it is relevant.
Caller Confidentiality
We treat confidentiality as a form of non-interference as well: the confidentiality of a caller
means that its callee’s behavior is dependent only on publicly visible data,
not the caller’s private state. This also requires that the callee initialize
memory before reading it.
As we saw in the examples, we must consider both the observable events
that the callee produces during the call and the changes that the callee makes to the state that might
affect the caller after the callee returns.
Consider the state after step 5, shown at the top of Fig.5,
with the attacker code from Fig.2(a) and the assumption that
secret has the value 5. We take a variant state over
the set of elements that are in (orange), and compare it to the
original (blue). During the execution, the value of secret is written
to the output, and the information leak is evidenced by the fact that the
outputs do not agree—the original outputs 5, while the variant outputs 3.
This is a violation of
internal confidentiality (formalized in LABEL:tab:props, line 3a).
Figure 5: Internal Confidentiality Violation
But, in Fig.2(b), we also saw an attacker that exfiltrated the secret
by reading it and then returning it, in a context where the caller would output the returned
value. Figure6 shows the behavior of the same variants under this attacker,
but in this case, there is no output during the call. Instead the value of secret is
extracted and placed in a0, the return value register.
Figure 6: Return-time Confidentiality Violation
At the end of the call, we can deduce that every element on which
the variant states disagree must carry some information derived from
the original varied elements. In most cases, that is because the element
is one of the original varied elements and has not changed during the
call, which does not represent a leak. But in the case of a0, it
has changed during the call, and the return states do not agree
on its value. This represents data that has been leaked, and should
not be used to affect future execution.
Unless a0 happens to be irrelevant to the caller, this example
is a violation of what we term return-time confidentiality
(formalized in LABEL:tab:props, line 3b).
Structurally, return-time confidentiality resembles integrity, but now dealing with
variants. We begin with a state immediately following
a call, . We consider an arbitrary variant state,
, which may vary any element that is or ,
i.e., any element that is not used legitimately to pass arguments. Caller confidentiality
therefore can be thought of as the callee’s insensitivity to elements in its initial state
that are not part of the caller-callee interface.
We define a binary relation on pairs of states,
which holds on eventual return states and
if all relevant elements are uncorrupted relative to and .
An element is corrupted if it differs between and ,
and it either changed between and or between and .
Finally, we define caller confidentiality (ClrC) as the
combination of internal and return-time confidentiality (LABEL:tab:props, line 3).
The Callee’s Perspective
We presented our initial example from the perspective of the caller, but a callee
may also have privilege that its caller lacks, and which must be protected from the
caller. Consider a function that makes a privileged system call to obtain a secret key,
and uses that key to perform a specific task. An untrustworthy or erroneous caller might
attempt to read the key out of the callee’s memory after return, or to influence the callee
to cause it to misuse the key itself!
Where the caller’s confidentiality and integrity are concerned with protecting specific,
identifiable state—the caller’s stack frame—their callee equivalents are concerned
with enforcing the expected interface between caller and callee. Communication between
the principals should occur only through the state elements that are designated for the
purpose: those labeled and .
Applying this intuition using our framework, callee confidentiality (CleC)
turns out to resemble ClrI, extended to every element that is not marked
or at call-time. The callee’s internal behavior is represented by those
elements that change over the course of its execution, and which are not part of the
interface with the caller. At return, those elements should become irrelevant to the
subsequent behavior of the caller.
Similarly, in callee integrity (CleI), only elements marked
or at the call should influence the behavior of the callee. It may seem
odd to call this integrity, as the callee does not have a private state. But
an erroneous callee that performs a read-before-write within its stack
frame, or which uses a non-argument register without initializing it, is vulnerable
to its caller seeding those elements with values that will change its behavior.
The fact that well-behaved callees have integrity by definition is probably why
callee integrity is not typically discussed.
IV Formalization
We now give a formal description of our machine model, security semantics,
and properties. Our definitions abstract over: (i) the details of the target machine
architecture and ABI, (ii) the set of security-relevant operations and their effects on
the security context, (iii) the set of observable events, and (iv) a notion of value compatibility.
IV-AMachine
The building blocks of a machine are words and registers.
Words are ranged over by and, when used as addresses, ,
and are drawn from the set .
Registers in the set are ranged over by , with the stack pointer
given the special name sp;
some registers may be classified as caller-saved (CLR) or callee-saved (CLE).
Along with the program counter, pc, these are referred to as
state elements in the set .
A machine state is a map from state elements to a set of
values.
Each value contains a payload word, written .
We write to denote the value of at
and as shorthand for .
Depending on the specific machine being modeled, values may also contain other
information relevant to hardware enforcement (such as a tag).
When constructing variants (see SectionIV-D, this additional information should
not be varied. To capture this idea, we assume a given compatibility equivalence relation on values,
and lift it element-wise to states. Two values should be compatible if their
non-payload information (e.g., their tag) is identical.
The machine has a step function .
Except for the annotations over the arrow, this function just encodes the usual
ISA description of the machine’s instruction set. The annotations serve to connect
the machine’s operation to our security setting:
is a list of security-relevant operations drawn from an assumed given set ,
and is an (potentially silent) observable event; these are described further below.
IV-BSecurity semantics
The security semantics operates in parallel with the machine.
Each state element (memory word or register) is given a security class
.
A view maps elements to security classes.
For any security class , we write
to denote the set of elements such that .
The initial view maps all stack locations to ,
all other locations to , and registers based on which set they
belong to: for callee-saved, for caller-saved except for those
that contain arguments at the start of execution, which are , and otherwise.
A (security) context is
a pair of the current activation’s view and
a list of views representing the call stack (pending inactive
principals), ranged over by .
The initial context is .
SectionIII describes informally how the security context evolves as the system performs
security-relevant operations. Formally, we combine each machine state with a context
to create a combined state and lift the transition
to on combined states.
At each step, the context updates based on an assumed given function
.
Since a single step might correspond to multiple operations, we apply
as many times as needed, using .
A definition of is most convenient to present decomposed into
rules for each operation. We have already seen the intuition behind the rules for
, , and .
For the machine described in the example, the rules would be those
found in Fig.7.
Note that takes as its first argument the state before the step.
Alloc
Dealloc
Call
Return
Figure 7: Basic Operations
IV-CEvents and Traces
We abstract over the events that can be observed in the system, assuming just
a given set that contains at least the element , the silent
event. Other events might represent certain function calls (i.e., system calls)
or writes to special addresses representing memory-mapped regions.
A trace is a nonempty, finite or infinite sequence
of events, ranged over by .
We use “” to represent “cons” for traces, reserving “::”
for list-cons.
We are particularly interested in traces that end just after a function returns.
We define these in terms of the depth of the security context’s call stack .
We write for the trace of execution from a state
up to the first point where the stack depth is smaller than , defined
coinductively by these rules:
Done
Step
When , the trace will always be infinite because the machine never halts; in this case we
omit and just write .
Two event traces and are similar,
written , if the sequence of non-silent events
is the same. That is, we compare up to deletion of events.
Note that this results in an infinite silent trace being similar to
any trace. So, a trace that silently diverges due to a failstop will
be vacuously similar to all other traces.
SimRefl
SimEvent
SimLeft
SimRight
IV-DVariants, corrupted sets, and “on-return” assertions
Two (compatible) states are variants with respect to a set of elements
if they agree on the value of every element not in .
Our notion of non-interference involves comparing the traces of such
-variants. We use this to define sets of irrelevant elements.
Recall that is a policy-specific compatibility relation.
Definition 1.
The difference set of two machine states and ,
written ,
is the set of elements such that .