Weird machines, exploitability, and provable unexploitability

Thomas Dullien
[email protected]

ABSTRACT list with standard operations allow an attacker sufficient

The concept of exploit is central to computer security, particularly degrees of freedom.
in the context of memory corruptions. Yet, in spite of the centrality • Questions of ’exploitability’ are often decoupled from is-
of the concept and voluminous descriptions of various exploitation sues of control-flow or compromising the instruction pointer
techniques or countermeasures, a good theoretical framework for of a target: Control flow integrity is just one security prop-
describing and reasoning about exploitation has not yet been put erty that can be violated, and perfect CFI does not imply
forward. security. Attackers aim to violate CFI because it provides
A body of concepts and folk theorems exists in the community of the most convenient and powerful avenue to violate se-
exploitation practitioners; unfortunately, these concepts are rarely curity properties, not because it provides the only such
written down or made sufficiently precise for people outside of this avenue.
community to benefit from them. • If exploitability is a result of target’s complexity, the bound-
This paper clarifies a number of these concepts, provides a clear ary where complexity causes exploitability is much lower
definition of exploit, a clear definition of the concept of a weird than commonly appreciated.
machine, and how programming of a weird machine leads to ex- The misunderstandings surrounding weird machines are particu-
ploitation. The papers also shows, somewhat counterintuitively, larly unfortunate as the framework of weird machines subsumes
that it is feasible to design some software in a way that even pow- many individual techniques; the framework predicts that many
erful attackers - with the ability to corrupt memory once - cannot exploitation countermeasures are overly specific and bound to be
gain an advantage. bypassable. Among other things, the bypassing of most early ROP
countermeasures could have been easily predicted without the
KEYWORDS ensuing series of tit-for-tat papers, and the somewhat limited ef-
exploitation, memory corruptions fectiveness of control-flow-integrity (CFI) [1, 9, 22] against many
attacks such as counterfeit-object-oriented programming (COOP)
[16] as well as the existence of data-oriented-programming (DOP)
PROBLEM DESCRIPTION
[12] would have come as less of a surprise.
The concept of exploit is central in computer security. While intu-
itively clear, it has not been formalized - even in the very restricted Contributions. This paper provides the following contributions:
setting of memory-corruption attacks. Two largely disjoint com- (1) Proper definitions and formalizations of the ’folk theorems’
munities have worked on exploring the process of exploitation: of the EP community.
’Exploit practitioners’ (EPs) with focus on building working ex- (2) A clear definition of ’exploit’ which better matches real-
ploits have been investigating the topic at least since the infamous world requirements than the popular approach of showing
Morris worm, and academic researchers, who really began focus- Turing-completeness of emergent computation.
ing on the problem with the re-invention and popularization of (3) A first step toward understanding what distinguishes un-
return-oriented programming (ROP) by Shacham et al [20]. exploitable from exploitable programs. The paper presents
The aversion of the EP-community to formal publishing1 has two implementations of the same program. An attacker
lead to an accumulation of folklore knowledge within that commu- with the ability to flip a bit of his choosing can exploit
nity which is not properly communicated to a wider audience; this, one variant, while the other can be shown to be immune
unfortunately, often leads to duplicated effort, re-invention, and even to this powerful attacker. The differences between
sometimes even acrimony between members of the two communi- the programs hint at differences in computational power
ties [11]. obtained by the attacker - which depend on the choice of
The concept of a weird machine is informally familiar in the EP data structures for the program implementation.
community, but widely misunderstood outside of that community. The intuitions behind and implications of 1 and 2 are common
It has numerous implications, most importantly: knowledge, all formalisms, definitions and proofs, as well as 3, are
• The complexity of the attacked program works in favor of contributions of the author(s).
the attacker. We hope that this paper bridges the gap between the two com-
• Given enough time for the preparation of an exploit, non- munities and provides a common vocabulary.
exploitability is the exception, not the rule. Even extremely
restricted programs consisting of little more than a linked RELATED WORK
1 Or worse, the incentive structure that keeps the EP community from publishing at all. The concept of a weird machine that will be discussed in this paper
has found numerous mentions over the years; not all these mentions
Conference’17, July 2017, Washington, DC, USA
2017. ACM ISBN 978-x-xxxx-xxxx-x/YY/MM. . . $15.00 refer to the same concept. [8] discussed weird machines but only
https://doi.org/10.1145/nnnnnnn.nnnnnnn provided an informal description, not a definition. The Langsec
1
community uses the term in their literature, often informally and For simplicity, we will use the notation IFSM in the rest of the
vaguely defined, and with slightly varying meanings. [2–4] paper even when the machine under discussion is a transducer.
[24] discusses weird machines in proof-carrying code (PCC) For situations when an IFSM needs to be specified formally,
that arise when the PCC system fails to capture all necessary and recall that a finite-state transducer can be described by the 7-tuple
sufficient conditions for safe program execution; Contrary to the θ = (Q, i, F , Σ, ∆, δ, σ ) that consists of the set of states Q, the initial
present paper, he focuses on computations involving unexpected state i, the final states F , input- and output alphabets Σ and ∆, a
control flow and the proof-carrying-code scenario. This paper is state transition function δ : Q × Σ → Q and the output function σ
inspired heavily by the use of ’dueling’ finite-state transducers in which maps Q × Σ → ∆.
that paper, though.
Computation (and correctness) in the presence of faults has been
studied in [25] , which introduces a lambda-calculus to calculate
1.1 Software as emulators for the IFSM
correctly given hardware faults. [14] studies automatic detection Since any real-world software can be modelled as an IFSM, but has
of two classes of heap corruptions in running code by keeping to execute on a real-world general-purpose machine, an emulator
multiple copies of a randomized heap. for the IFSM needs to be constructed. This process is normally done
By and large, while many academic and non-academic papers by humans and called programming or development, but can be done
have studied concrete exploitation instances, few have considered automatically in the rare case that the IFSM is formally specified.
foundational questions. Why consider software as emulator for the IFSM instead of ex-
We will see later that weird machines arise when an abstract, amining software as the primary object of study? The answer lies
intended machine and a concrete implementation which tries to in the very definition of bug or security vulnerability: When the
simulate the abstract machine fails to do so. Studying equivalence security issue arises from a software flaw (in contrast to a hardware
between automata which simulate each other at different levels of problem such as [13]) , it is impossible to even define ’flaw’ without
abstraction has been studied by the model-checking and verification taking into account what a bug-free version of the software would
community using stuttering bisimulation extensively. [5, 10, 23] have been. Viewing the software as a (potentially faulty) emulator
This paper eschews the somewhat specialized language of stuttering for the IFSM allows the exploration of how software faults lead to
bisimulation to allow broader accessibility. significantly larger (in the state-space sense) emulated machines.

OVERVIEW OF THE PAPER 1.2 Example IFSM: A tiny secure

In order to get to the important results of the paper, a fair bit of message-passing server
set-up and definitions are needed. The paper first defines ’the soft- We introduce an example IFSM with the properties of being small,
ware the developer intended to write’ and a simple computing having a clearly-defined security boundary, and allowing for enough
environment for which this software is written. This is followed complexity to be interesting. We describe the IFSM informally first
by further definitions that permit describing erroneous states and and subsequently give a formal example.
distinguishing between erroneous states with and without secu- Informally, our example IFSM is a machine that remembers a
rity implications. Finally, a precise definition of exploit and weird password-secret pair for later retrieval through re-submission of
machine is provided. the right password; retrieval removes the password-secret pair. We
A running example is used throughout these sections. Two im- set an arbitrary limit that the system need not remember more than
plementations of the same software are introduced, along with 5000 password-secret pairs.
a theoretical attacker. We prove that one implementation cannot A diagram sketching the IFSM is shown on page 3 in Figure 1.
be exploited while the other implementation can, and discuss the To transform this sketch into a formally defined FSM, we re-
underlying reasons. place the memory of the described machine with explicit states. We
Finally, we discuss the implications for exploit mitigations, control- denote the set of possible configurations of Memory with M:
flow integrity, and software security.

1 THE INTENDED FINITE-STATE MACHINE 

 ∅, 

 {(p1 , s 1 )}, pi , si ∈ bits 32 \{0} 

 

(IFSM) M :=
 

The design of any real software can be described as a potentially  ...,

 pi , p j 
 {(p1 , s 1 ), . . . , (p5000 , s 5000 )}
 


very large and only implicitly specified finite state machine (or  
transducer, if output is possible)2 . This FSM transitions between
individual states according to inputs, and outputs data when nec- The central looping state A in the informal diagram can be replaced
essary. Since any real software needs to run on a finite-memory by a family of states AM indexed by a memory configuration M ∈
computing device, the nonequivalence of a FSM to a Turing machine M. The starting configuration transitions into A ∅ , and after reading
does not matter - any real, finite-input software can be modelled (p, s), the machine transitions into A {(p,s)} and so forth. With the
as a FSM (or FST) given a sufficiently large state set. properly adjusted transitions, it is now clear that we have a proper
FST (albeit with a large number of individual states).
2 The The formal specification of the example IFSM in the 7-tuple form
bisimulation community uses the concept of process, which is similar - but more
readers will be familiar with FSMs, and they serve our purpose well enough θ = (Q, i, F , Σ, ∆, δ, σ ) is as follows:
2
 start

Read input password-secret pair (A) Switch by condition

read(p)
read(s)

IF condition b:
Store pair in memory (B) ∀(p ′, s ′ ) ∈ Memory : p ′ , p
Memory ← Memory ∪ {(p, s)} |Memory| ≤ 4999
s , 0, p , 0

Output the requested secret (C) IF condition c:

Memory ← {(p ′, s ′ ) ∈ Memory | p ′ , p} ∃(p ′, s ′ ) ∈ Memory : p = p ′
print(s ′ ) s,0

IF condition d:
Output error message (D) s=0
print(0) ∨p = 0
∨ |Memory| = 5000

Figure 1: A diagrammatic sketch of the example IFSM

1.3.1 Security properties of the example IFSM. The example

IFSM should satisfy the informal notion that ”you need to know (or
guess) the right password in order to obtain a stored secret”.
Q := {AM , M ∈ M}, i := A ∅ , F := ∅ Intuitively, the attacker should not be able to ’cheat’ - there
Σ := {(p, s)|p, s ∈ bits 32 }, ∆ := {s ∈ bits 32 } should be no way for the attacker to somehow get better-than-
guessing odds to obtain the stored secret from the IFSM.


 (p, s) < M In order to make this precise, we borrow ideas from the crypto-

A if ∧|M | ≤ 4999

M graphic community, and define a multi-step game where an attacker


 ∪(p,s)
δ := AM × (p, s)


→ ∧s , 0 and a defender get to take turns interacting with the machine, and
AM \(p,s) if (p, s) ∈ M we specify that there is no way that the attacker can gain an advan-



tage.

AM otherwise



( The game mechanics are as follows:
s ′ if (p, s ′ ) ∈ M
σ := AM × (p, s) →
0 if s = 0 ∨ |M | = 5000 (1) The attacker chooses a probability distribution A over
finite-state transducers Θexploit that have an input alpha-
bet ΣΘexploit = ∆ and output alphabet ∆Θexploit = Σ. This
1.3 Security properties of the IFSM means that the attacker specifies one or more finite-state
Not every malfunction of a program has security implications. To transducers that take as input the outputs of the IFSM, and
distinguish between plain erroneous states and erroneous states output words that are the input for the IFSM.
that have security implications, security properties of the IFSM (2) Once this is done, the defender draws two elements p, s
need to be defined. from bits 32 according to the uniform distribution.
Security properties are statements (possibly about probabilities) (3) The attacker draws a finite-state transducer from his dis-
over sequences of states, inputs, and outputs of the IFSM. They are tribution and is allowed to have it interact with the IFSM
part of the specification of the IFSM. Not every true statement is a for an attacker-chosen number of steps n setup .
security property, but every security property is a true statement. (4) The defender sends his (p, s) to the IFSM.
The attackers goal is always to violate a security property of the (5) The attacker gets to have his Θexploit interact with the IFSM
IFSM when interacting with the emulator for the IFSM. for a further attacker-chosen number of steps n exploit .
3
 The probability for Θexploit to obtain the defenders secret should program that is running, and the line in the program the machine
be no better than guessing. Let o exploit be the sequence of outputs will execute next.
that the Θexploit produced, and o IFSM the sequence of outputs the
IFSM produced during the game. Then our desired security property 2.1 Example IFSM: What to emulate?
is: There are many different ways of emulating the IFSM in the toy
n setup + n exploit |o exploit | computing environment. Examining our informal diagram again,
P[s ∈ o IFSM ] ≤ =
|bits 32 | 232 emulation needs to be constructed for the three conditional edges
The probability here is given a random draw from the attacker- in the diagram (labeled b, c, and d) as well as the 3 different state
specified distribution over transducers. This encodes our desired modifications (labeled B, C, D).
property: An attacker cannot do better than randomly guessing the
2.1.1 Example IFSM emulation: Variant 1. The first emulator of
password, and the attacker cannot provide a program that does any
the example IFSM uses registers/cells 0 through 5 as scratch for
better.
reading input, and cells 6 to 10006 as a simple flat array for storing
pairs of values. It uses no sophisticated data structures and simply
2 A TOY COMPUTING ENVIRONMENT searches memory for empty pairs of memory cells, zeroing them in
The IFSM itself is a theoretical construct. In order to ’run’ the order to release them.
IFSM, a programmer needs to build an emulator for the IFSM, and Full source code for the emulator can be found on page 13 in
this emulator needs to be built for a different, general-purpose figure 5.
computing environment, which will be introduced next.
For our investigation, the Cook-and-Reckhow [6] RAM machine 2.1.2 Example IFSM emulation: Variant 2. The first example does
model is well-suited. Their machine model covers both random- not use any sophisticated data structures. The Memory of the IFSM
access-machine variants (Harvard architectures) and random-access- is emulated by a simple flat array, at the cost of always having to
stored-program variants (for von-Neumann-Architectures); our dis- traverse all 5000 elements of the array when checking for a value.
cussion applies equally to both, but our concrete example assumes The second variant implements the same IFSM, but in order to
a Harvard architecture. be more efficient, implements Memory as two singly linked lists,
The machine model consists of a number of registers as well as one for keeping track of free space for password-secret tuples, and
the following operations: one for keeping track of currently active password-secret tuples.
Full source code for the emulator for variant 2 can be found on
LOAD(C, rd ) : rd ← C Load a constant page 14 in figure 6.
ADD(r s1 , r s2 , rd ) : rd ← r s1 + r s2 Add two registers
or a register and constant 3 ERRORS - REACHING A WEIRD STATE
SUB(r s1 , r s2 , rd ) : rd ← r s1 − r s2 Subtract two registers A common problem when investigating foundations of computer
security is the difficulty of even defining exactly what a bug is -
or a register and constant defining precisely when a program has encountered a flaw and is
ICOPY(rp , rd ) : rd ← r rp Indirect memory read no longer in a well-defined state. Using the abstraction of the IFSM
DCOPY(rd , r s ) : rrd ← rs Indirect memory write and viewing the software as an emulator for the IFSM, this becomes
JNZ/JZ(r , Iz ) Transfer control to tractable.
Intuitively, a program has gone ’off the rails’ or a bug has oc-
Iz if r is nonzero, zero curred when the concrete cpu has entered a state that has no clean
READ(rd ) : rd ← input Read a value from input equivalent in the IFSM - when the state of the cpu neither maps
PRINT(r s ) : rd → output Write a value to output to a valid state of the IFSM, nor to an intermediate state along the
edges of the IFSM.
While the original model assumes an infinite quantity of infinite- To make this notion formal, we define two mappings (remember
size registers, we fix the size of our registers and the number of these that Qcpu is the set of possible states of the concrete cpu on which
registers arbitrarily. We do this for both theoretical (it simplifies the IFSM is emulated, and Q θ is the set of possible states of the
some counting arguments later) and for practical reasons (real IFSM):
machines have finite RAM).
For the purposes of this paper, we fix the size of registers/memory
cells to be 32-bit numbers (the set of which we denote bits 32 ), and Definition 3.1 (Instantiation). Given an IFSM θ and a target ma-
the number of registers/memory cells to 216 . We also denote the chine cpu on which the IFSM is emulated by means of a program ρ,
memory cells r 0 , . . . , r 6 as registers. This has no effect at the moment, the instantiation mapping
but will be used later when we introduce attacker models. γθ, cpu, ρ : Q θ → P(Qcpu )
The set of possible memory configurations of the machine is
is a mapping that maps states of the IFSM to the set of states of the
denoted by Qcpu ; a program for this cpu is denoted with ρ, and
concrete cpu that can be used to represent these states. Note that it
individual lines in this program is denoted by ρ i where i is the line
is common that one state in the IFSM can be represented by a large
number.
number of states of the target machine.
Note that the state of the machine is fully determined by the
tuple ((q 1 , . . . , q 216 ) =: q,
® ρ, ρ i ): The state of all memory cells, the
4
 Definition 3.2 (Abstraction). Given an IFSM θ and a target ma- 3.1 Defining weird states
chine cpu on which the IFSM is emulated by means of program ρ, With the above definitions we can partition the set of possible states
the partial abstraction mapping Qcpu into three parts: States that directly correspond to states of
α θ,cpu, ρ : Qcpu → Q θ the IFSM, transitory states that are just symptoms of the emulator
transitioning between valid IFSM states, and all the other states.
maps a concrete state of the target machine to the IFSM state that
These other states are the object of study of this paper, and the
it represents. Note that this is a partial mapping: There are many
principal object of study of the exploit practitioner community.
states of cpu which do not map to an IFSM state. We denote the set
sane . They will be called weird states in the remainder of this paper - to
of states on which α is defined as Qcpu
reflect the fact that they arise unintentionally and do not have any
During the process of emulating the IFSM, the target machine meaningful interpretation on the more abstract level of the ISFM.
is necessarily in states on which α θ,cpu, ρ is not defined - since
following an edge in the IFSM diagram often involves multi-step Definition 3.5 (Weird state). Given an IFSM θ , the computing
state modifications to reach a desired target state of the IFSM. To environment cpu and the program ρ that is supposed to emulate θ ,
differentiate these states from erroneous states, we define transitory the set Qcpu can be partitioned into disjoint sets as follows:
states. sane Û trans Û weird
Qcpu = Qcpu ∪Qcpu ∪Qcpu
Intuitively, a transitory state is a state occuring during the emu-
lation of an edge in the state machine diagram of the IFSM that is sane nor in Q trans is called
An element of Qcpu that is neither in Qcpu cpu
always part of a benign and intended transition. weird .
a weird state, and the set of all such states is denoted as Qcpu
Definition 3.3 (Transitory State). Given an IFSM θ and a target
3.1.1 Possible sources of weird states. There are many possible
machine cpu on which the IFSM is emulated by means of the pro-
sources for weird states. Some of these sources are:
gram ρ, a transitory state q t r ans of the cpu is a state that satisfies
all of the following: Human Error in the construction of the program ρ. This is
(1) there exists S, S ′ ∈ Q θ and σ ∈ Σ so that δ (S, σ ) = S ′ - probably the single most common source of weird states
the transition from S to S ′ given input σ is an existing in the real world: Since the process of constructing ρ is
transition in the IFSM, hence an intended transition. based on humans that often have to work on a non-existent
(2) there exists q S ∈ γθ,cpu, ρ (S), q S ′ ∈ γθ,cpu, ρ (S ′ ) and a or highly incomplete specification of the IFSM, mistakes
sequence of state transitions are made and program paths through ρ exist that allow
entering a weird state. Real-world examples of this include
q S →n q t r ans →n q S ′
′
pretty much all memory corruption bugs, buffer overflows
so that α θ,cpu, ρ is not defined on all intermediate states etc.
and so that all sequences of transitions from q t r ans lead Hardware Faults during the execution of ρ. While determin-
to q S ′ , irrespective of any addition input and before the istic computing is a convenient abstraction, the hardware
machine performs any output. of any real-world computing system is often only proba-
The set of transitory states will be denoted Qcputrans from here on. bilistically deterministic, e.g. deterministic in the average
case with some low-probability situations in which it non-
Clearly, if irrespective of any attacker actions (input) the machine deterministically flips some bits. A prime example for this
always transitions into a well-defined and intended state without is the widely-publicized Rowhammer hardware issue [13]
any observable effects, the transitory state is not relevant for the (and the resulting exploitation [17]) .
security properties of the IFSM. Transcription Errors that are introduced into ρ if ρ is trans-
Example 3.4 (Example mappings for Emulator Variant 1). For our mitted over a channel that can introduce errors. Examples
very simple first example, we can provide the relevant mappings of this include ρ being stored on a storage medium / hard-
explicitly. An element of Qcpu can be described by the state of all disk which due to environmental factors or hardware fail-
memory cells (® q) and the program line ρ i . Let τ (i) := 2i + base. ure corrupts ρ partially.
Then
 q® ∈ Qcpu so that
 
 4 WEIRD MACHINES: EMULATED IFSM
<5000 with TRANSITIONS APPLIED TO WEIRD STATES
 
∀(p, s) ∈ M ∃i ∈
 

 N 

γθ,cpu, ρ (AM ) = , =

 

(q q
τ (i) τ (i)+1 ) (p, s) Given the definition of weird states, we now need to examine what
∧(∀i , j with (qτ (i) , qτ (i)+1 ) = (qτ (j) , qτ (j)+1 )  happens to the emulated IFSM when ρ can be made to compute on

 

 

 ⇒q = q = 0) a weird state.
 
τ (i) τ (i)+1

 
Once we have γ , we can define α in terms of it: Let q ′ ∈ Qcpu . Then
Ø 4.1 Interaction as a form of programming
α θ,cpu, ρ : γθ,cpu, ρ (AM ) → Q
Before examining computation on weird states, though, we need to
M ∈M
clarify to ourselves that sending input to a finite state transducer is
α θ,cpu, ρ (q ′ ) = AM with q ′ ∈ γθ,cpu, ρ (AM ) a form of programming. The set of symbols that can be sent for a
Now we have all the pieces in place to define erroneous and restricted instruction set, and the state transitions inside the finite
non-erroneous states. state transducer are the semantics of these instructions. Sending
5
input is the same thing as programming. This change of perspective Now we consider an attacker that has the ability to somehow
is crucial. move the cpu into a weird state - a state that has no meaning-
The classical perspective views a program as being a sequence ful equivalent in the IFSM, and that will also not necessarily re-
of instructions that, combined with some input, drive the machine converge to a state that does. This initial weird state will be called
through a series of states: weird .
qinit ∈ Qcpu
Data Once the attacker has achieved this, a new computing device
emerges: A machine that transforms the states in Qcpu , particularly
weird , by means of transitions that were meant to trans-
those in Qcpu
Input Input
form valid IFSM states into each other, and that takes an instruction
stream from the attacker (in form of further inputs).
State 1 State 2 State 3 State 4 State 5
Definition 4.1 (Weird Machine). The weird machine is the comput-
ing device that arises from the operation of the emulated transitions
Instruction Instruction Instruction Instruction
of the IFSM on weird states. It consists of the 7-tuple

Program weird sane t r ans ′ ′ ′ ′

(Qcpu , qinit , Qcpu ∪ Qcpu , Σ , ∆ ,δ ,σ )
We can summarize the sequence of instruction that drives the
machine from state 1 to state 5 into one instruction, and summarize sane ∪ Q t r ans are terminating states for the weird
Note that Qcpu cpu
the intermediate states, too: From the outside, they are unobserv-
able. machine; if one of these states is entered, ρ begins emulating the
Data (Program from attacker perspective) original IFSM again. Further note that the alphabets for input and
output may be different from those for the IFSM.
Input Input
The weird machine has a number of interesting properties:
Input as instruction stream The most interesting property
State 1 State 4 State 5 of the weird machine is that, contrary to individual lines
of ρ transforming states in Qcpu , the weird machine takes
the instruction stream from user input: Every input is an
Instruction(s) Instruction(s)
opcode that leads to the execution of the emulated transi-
tion. While this is true for the IFSM as well, the IFSM can
Program (Data from attacker perspective) only reach a well-defined and safe set of states. The weird
The symmetry of the resulting diagram makes it clear that every machine on the other hand has a state space of unknown
finite-state transducer (and as a result, every piece of real-world size that can be explored by ’programming’ it - sending
software) can be viewed from two angles: As an intended machine careful crafted inputs.
where the contents of memory, combined with the code, operate Unknown state space The state space is a priori not known:
on input data - but, from the attacker perspective, as an unintended It depends heavily on ρ and qinit , and determining the size
and shape of Qcpuweird is very difficult. This also means that
machine where the input data, combined with the code, operates on
the contents of memory. Each side views what it can control as the determining whether the security properties of the IFSM
program, and what it does not control as the data. Mathematically, can be violated is a nontrivial endeavour.
there is no distinction between the two perspectives. Unknown computational power It is a-priori unclear how
Under normal conditions, this dual perspective does not matter: much computational power a given weird machine will
By sending symbols to the IFSM, the attacker can of course cause the have. Intuitively, since the transitions of the IFSM end up
IFSM to change state - this is obvious and unremarkable. The dual being the ’instructions’ of the weird machine, greater com-
perspective becomes important as soon as a weird state is entered plexity of the IFSM appears to imply greater computational
and the attacker obtains much more liberty to modify states than power; but the actual way the transitions are implemented
anticipated. is just as important - some constructs will lead to easier
exploitation than others.
Emergent instruction set The attacker gets to choose the
4.2 The weird machine sequence of instructions, but the instruction set itself emerges
from a combination of the IFSM and the emulator ρ. This
To recapitulate: There is the machine that the programmer intends
means that while the machine is programmable, and the
to have, the IFSM. Since he only has the cpu available, he generates
semantics of the instructions are well-defined, the instruc-
the program ρ to simulate the IFSM on the general cpu. This pro-
tions themselves are often extremely unwieldly to use. Fur-
gram emulates all the state transitions of the IFSM so that a state
sane gets transformed into another state from Q sane , whilst thermore, the attacker needs to discover the semantics of
from Qcpu cpu
trans . his instructions during the construction of the attack and
traversing a number of states from Qcpu infer them from ρ and qinit .
6
5 DEFINITION OF EXPLOITATION turns out - possibly counterintuitively - to be not exploitable by
Definition 5.1 (Exploitation). Given a method to enter a weird this powerful attacker.
state qinit ∈ Qcpuinit ⊂ Q weird from a set of particular sane states
cpu 5.1.2 Extending the security game. We defined security proper-
sane
{qi }i ∈I ⊂ Qcpu , exploitation is the process of setup (choosing the ties involving an attacker that can specify a probability distribution
right qi ), instantiation (entering qinit ) and programming of the over finite-state transducers from which an ”attacking” transducer
weird machine so that security properties of the IFSM are violated. is drawn. In order to include our attacker models into this frame-
An exploit is "just" a program for the weird machine that leads work, we simply allow the attacker to corrupt memory while the
to a violation of the security properties. For a given vulnerability (a two machines duel. Concretely, step 5 in the game described in 1.3.1
method to move the machine into a weird state) it is likely that an is extended so that the attacker can stop the attacked program at
infinite number of different programs exist that achieve the same any point, flip a single bit of memory, and then resume execution.
goals by different means. 5.1.3 Proof of exploitability of Variant 2. In order to show ex-
ploitability, it is sufficient to provide a sequence of steps (including
5.1 Exploitability of Variant 1 and Variant 2 a single chosen bitflip) that helps an attacker violate the assump-
A natural question arises when discussing "exploitability": Do the tions of the security model. This is done using sequential diagrams
different implementations of our IFSM have different properties showing the internal state of the emulator over pages 8, 9 and 10.
with regards to exploitability ? Does the attacker gain more power In this example, the attacker gets to interact with the machine for a
by corrupting memory in one case than in the other? Is it possible few steps; the defender gets to store his secret in the machine, and
to implement software in a way that is more resilient to exploitation the attacker then gets to attempt to extract the defenders secret by
under certain memory corruptions? flipping just a single bit.
In order to answer these questions, we need a model for an The machine begins in it’s initial state, e.g. all memory cells are
attacker. empty and the head of the free list is at zero.
The diagrams on pages 8, 9 and 10 show the first 15 non-register
5.1.1 The attacker model. How does one model the capabilities
memory cells, along with the points-to-relations between them. Fur-
of an attacker? The cryptographic community has a hierarchy of
thermore, the heads of the free and used linked lists are marked. Be-
detailed attacker models (known-plaintext, chosen-plaintext etc.)
tween two such diagrams, the actions that the defender or attacker
under which they examine their constructs; in order to reason about
takes are listed, and the resulting state is shown in the subsequent
the exploitability of the different implementations we define a few
diagram.
attacker models for memory corruptions. Some of these will seem
Following the diagrams, it is clear that an attacker can exploit the
unrealistically powerful - this is by design, as resilience against
linked-list variant of the IFSM emulator using just a single bit-flip.
an unrealistically powerful attacker will imply resilience against
It is also clear that the specific sequence of inputs the attacker sends
less-powerful attackers.
to the emulator after the bit-flip constitutes a form of program.
Arbitrary program-point, chosen-bitflip In this model, the
attacker gets to stop ρ while executing, flip an attacker- 5.1.4 Proof of non-exploitability of Variant 1. The proof idea is
chosen bit in memory, and continue executing. to show that any attacker that is capable of flipping a single bit can
Arbitrary program-point, chosen-bitflip, registers This be emulated by an attacker without this capability with a maximum
model is identical to the above with the exception that the of 10000 more interactions between attacker and emulated IFSM,
memory cells 0 through 6 are protected from the attacker. thus demonstrating that the attacker can not obtain a significant
This reflects the notion that cpu registers exist that are advantage by using his bit-flipping ability. The number 10000 arises
normally not corrupted. The attacker still gets to stop ρ from the fact that our IFSM has a maximum of 5000 (p, s)-tuples
while executing, and gets to choose which bit to flip. in memory. In order to replace a particular memory cell in the
Fixed-program point, chosen bitflip, registers In reality, emulated IFSM, the emulation process needs to fill up to 4999 tuples
attackers can usually not stop the program at an arbitrary with temporary dummy values and remove them again thereafter,
point to flip bits. It is more likely that a transcription error leading to 9998 extra interactions for targeting a particular cell.
has happened (e.g. a bug has been introduced into ρ) at a
particular program point. Assumption 1. We assume that the security property in 1.3.1 holds
for Variant 1 provided the attacker can not corrupt memory.
Various other models are imaginable.3
For the purpose of examining our two different variants, we The proof proceeds by contradiction: Assume that an attacker
choose the second model: Arbitrary program-point, chosen-bitflip can specify a distribution over finite state transducers, a particular
anywhere in memory with the exception of the first 7 cells (reg- bit of memory, and a particular point in time when to flip this bit
isters). This choice is made out of convenience; obviously, more of memory, to gain an advantage of at least knowing one bit of the
powerful attackers exist. secret:
We show next how the variant 2 (which uses the singly-linked n setup + n exploit |o exploit |
lists) is exploitable in this model, while variant 1 that uses flat arrays P[s ∈ o IFSM ] > =
|bits 31 | 231
3 Other examples that are worth exploring: Fixed-program-point random-bit flip,
Fixed-program-point chosen-bit flip, Fixed-program-point chosen-byte-writing, Fixed- Let Θexploit be a transducer from the specified distribution that
program-point arbitrary memory rewriting etc. succeeds with maximal advantage: No other transducer shall have
7
free_head=0

Step 1: Attacker sends (p0 , s 0 ), (p1 , s 1 ), (p2 , s 2 ).

p0 s0 n0 p1 s1 n1 p2 s2 n2

free_head=9

Step 2: Defender sends (pd , sd ).

p0 s0 n0 p1 s1 n1 p2 s2 n2 pd sd nd

free_head=12

Step 3.1: Attacker sends (p2 , X )

p0 s0 n0 p1 s2 n3 p2 s2 n2 pd sd nd

free_head=6

Step 3.2: Attacker sends (p1 , X )

p0 s0 n0 p1 s1 n1 p2 s2 n2 pd sd nd

free_head=3

Step 3.3: Attacker sends (p3 , s 3 )

Figure 2: The first part of the attack: Attacker set-up.

8
 Step 3.3: Attacker sent (p2 , X ), (p1 , X ), (p3 , s 3 )

p0 s0 n0 p3 s3 n3 p2 s2 n2 pd sd nd

free_head=6

Step 3.4: Attacker sends (p4 , s 4 )

p0 s0 n0 p3 s3 n3 p4 s4 n4 pd sd nd

free_head=12

Step 4: The attacker gets to corrupt a single bit, and increments n 3 .

p0 s0 n0 p3 s3 n3 p4 s4 n4 pd sd nd

free_head=12
Step 5: The attacker sends (s 4 , X ). The machine follows
the linked list, interprets s 4 as password, and outputs n 4 .

p0 s0 n0 p3 s3 n3 p4 s4 n4 pd sd nd

free_head=12
The machine then sets the three cells to be free,
and overwrites the storted pd with free-head.

Figure 3: The attacker uses his memory-corrupting powers.

9
 The machine just overwrote pd with free-head.

p0 s0 n0 p3 s3 n3 p4 s4 n4 12 sd nd

free_head=7

Step 6: The attacker sends (12, X ) and obtains sd .

Figure 4: The final successful steps of the attack.

a greater gap between it’s probability of success and the security is not either, and the game proceeds normally without attacker
boundary: advantage.
|o exploit | For case 3: If p was previously known, the attacker sends (p, 0),
Θexploit = arg max P[s ∈ o IFSM ] − receives s, and then sends (p, s ⊕ 2i ). If p was not known to the
exploit 231
attacker, the game proceeds normally without attacker advantage.
.
For case 5: The value p = 2i must have been known, and the
We now state two lemmas describing the set of states reachable
transition can be emulated by simply sending (2i , x).
by an attacker. No proof is given, but they are easily verified by
□
inspecting the code.
Lemma 1. All states in Qcpu t r ans are of the following form: q ∈ This means that the transitions that the attacker gains that help
sane
Qcpu with exactly one partially-stored tuple (corresponding to pro- him transit from one sane state to another, but along an unintended
gram lines 36 and 37) - a short time period where one of the memory path, do not provide him with any significant advantage over an
cells contains a p , 0 with a stale s. attacker that can not corrupt memory. What about the transitions
that lead to weird states?
Lemma 2. An attacker that can flip a bit can only perform the
following 5 transitions: Lemma 3. For any sequence of state transitions that successfully
violates the security property, there exists a p ′ which is never sent by
(1) Replace a (p, s) tuple in memory with (p ⊕ 2i , s).
either party.
(2) Transition a state with memory containing two tuples (p, s 1 ), (p⊕
2i , s 2 ) into a state where memory contains (p, s 1 ), (p, s 2 ). Proof. Any sequence for which such a p ′ does not exist is of
(3) Replace a (p, s) tuple in memory with (p, s ⊕ 2i ) length 232 − 1 and can hence not break the security property. □
(4) Replace a (p, 2i ) tuple with (p, 0)
(5) Replace a (2i , s) tuple with (0, s) Theorem 2. Any sequence of state transitions during a successful
sane to Q sane . Only 2
Note that 1, 3 and 5 are all transitions from Qcpu attack that uses transition 2 can only produce output that is a proper
cpu
weir d .
and 4 lead to Qcpu subsequence of the output produced by an attacker that cannot flip
memory bits, with a maximum of 10000 extra steps.
Now consider S ∈ Qcpun the sequence of state transitions of Q
cpu
for a successful attack by Θexploit . Proof. For case 2:
Given that the attacker only gets to flip a bit once, the sequence
Theorem 1. Any sequence of state transitions during a successful S will of the form
attack that use transitions 1, 3, or 5 above can be emulated by an
attacker that can not flip memory bits in at most 10000 steps. (qsane )n1 →t2 (qweir d )n2 →t2′ (qsane )n3

Proof. For all cases, the attacker without the ability to flip bits with n 3 possibly zero. The weird state the attacker enters with t 2 is
sends (pi , x i ) tuples to fill all empty cells preceding the cell in which identical to a sane state except for a duplicate entry with the same
Θexploit flips a bit, performs the action described, and then sends p. From this state on, there are two classes of interactions that can
(pi , x i ) to free up these cells again. We denote an arbitrary value occur:
with x. (1) A tuple (p, x) is sent, which transitions cpu via t 2′ back into
For case 1: If p was previously known to the attacker, an attacker a sane state.
without the ability to flip bits can simply send (p, x), receive s, and (2) A tuple (p ′ , p, x) is sent, which transitions into another
send (p ⊕ 2i , s). If p was not previously known to the attacker, p ⊕ 2i state in the same class (sane except duplicate p).
10
An attacker without bit flips can produce an output sequence that exploitation of hardware-failure-induced random bit flips [17]. In
contains the output sequence of the attacker with bit flips as follows: all of these cases, large percentages of the security and computer
(1) Perform identical actions until the bit flip. science community were convinced that the underlying memory
(2) From then on, if p ⊕ 2i is sent, replace it with p ′ . corruption could not be leveraged meaningfully by attackers, only
(3) If p is sent and the address of the cell where p is stored is to be proven wrong later.
less than the address where p ′ is stored, proceed normally It is difficult to reason about the computational power of a given
to receive s 1 . Next weird machine: After all, a vulnerability provides an assembly lan-
(a) Send (p ′, x), receive s 2 . guage for a computer that has never been programmed before,
(b) Fill any relevant empty cells. and that was not designed with programmability in mind. The
(c) Send (p, s 2 ). inherent difficulty of making statements about the non-existence
(d) Free the temporary cells again. of programs in a given machine language with only empirically
(4) If p is sent and the address of the cell where p is stored accessible semantics may be one of the reasons why statements
is larger than the address where p ′ is stored, replace the about non-exploitability are difficult.
sending of p with p ′ . Furthermore, many security vulnerabilities have the property
(5) Other operations proceed as normal. that many different initial states can be used to initialize the weird
□ machine, further complicating matters: One needs to argue over all
possible transitions into weird states and their possible trajectories
Theorem 3. Any sequence of state transitions during a successful thereafter.
attack that uses transition 4 can only produce output that is a proper
subsequence of the output produced by an attacker that cannot flip
memory bits.
6.2 Making statements about
non-exploitability is possible
Proof. The same properties about the weird state only transi- While making statements about non-exploitability is supremely
tioning into another weird state of the same form or back into a difficult for complex systems, somewhat surprisingly we can con-
sane state that held in the proof for transition 2 holds for transition struct computational environments and implementations that are
4. To produce the desired output sequence, the attacker without bit provably resistant to classes of memory-corrupting attackers.
flips simply replaces the first query for p after the bit flip with the This may open a somewhat new research direction: What data
query (0, 0). □ structures can be implemented with what level of resiliency against
We have shown that we can emulate any bit-flipping attacker in memory corruptions, and at what performance cost?
a maximum of 10000 steps using a non-bit-flipping attacker.
Since we assumed that our bit-flipping attacker can obtain an 6.3 Mitigations and their utility
attack probability
Computer security has a long history of exploit mitigations - and
|o exploit | bypasses for these mitigations: From stack cookies [7, 15] via ASLR
P[s ∈ o IFSM ] >
231 [21] to various forms of control-flow-integrity (CFI) [1, 9, 22] . The
it follows that the emulation for the bit-flipping attacker by a non- historical pattern has been the publication of a given mitigation,
bit-flipping attacker achieves followed by methods to bypass the mitigations for particular bug
|o exploit | + 10000 |o exploit | instances or entire classes of bugs.
P[s ∈ o IFSM ] > > In recent years, exploit mitigations that introduce randomness
231 232 into the states of cpu have been very popular, ranging from ASLR
This contradicts our assumption that the non-bit-flipping at- [21] via various heap layout randomizations to efforts that shuf-
tacker cannot beat our security boundary, and hence proves that a fle existing code blocks around to prevent ROP-style attacks. It
bit-flipping attacker cannot get an advantage of even a single bit has often been argued (with some plausibility) that these prevent
over a non-bit-flipping attacker. exploitation - or at least "raise the bar" for an attacker. While in-
troducing unpredictability into a programming language makes
6 CONSEQUENCES programming more difficult and less convenient, it is somewhat un-
There are a number of consequences of the previous discussion; clear to what extent layering such mitigations provides long-term
they mostly relate to questions about mitigations, demonstrating obstacles for an attacker that repeatedly attacks the same target.
non-exploitability, and the decoupling of exploitation from control An attacker that deals with the same target program repeat-
flow. edly finds himself in a situation where he repeatedly programs
highly related computational devices, and it is doubtful that no
6.1 Making statements about weird machine program fragments exist which allow an attacker
non-exploitability is difficult to achieve security violations in spite of not knowing the exact
Even experts in computer security routinely make mistakes when state of cpu from the outset. It is imaginable that the added benefit
assessing the exploitability of a particular security issue. Examples from increasing randomization beyond ASLR vanishes rapidly if
range from Sendmail bugs [19] via the famous exploitation of a the attacker cannot be generically prevented from reading crucial
memcpy with ’negative’ length in Apache [18] to the successful parts of memory.
11
 Mitigations should be preferred that detect corruptions and large [3] Sergey Bratus, Julian Bangert, Alexandar Gabrovsky, Anna Shubina, Michael E.
classes of weird states in order to terminate the program quickly. 4 Locasto, and Daniel Bilar. 2014. Ẃeird MachineṔatterns. See [2], 157–171.
https://doi.org/10.1007/978-3-319-04447-7_13
Ideally, mitigations should work independently of the particular [4] Sergey Bratus, Michael E. Locasto, Len Sassaman Meredith L. Patterson, and
way the attacker chooses to program the weird machine. Mitigations Anna Shubina. 2011. Exploit Programming: From Buffer Overflows to Weird
that only break a particular way of attacking a vulnerability are Machines and Theory of Computation. j-LOGIN 36, 6 (Dec. 2011), 13–21. https:
//www.usenix.org/publications/login/december-2011-volume-36-number-6/
akin to blacklisting a particular programming language idiom - exploit-programming-buffer-overflows-weird
unless the idiom is particularly important and unavoidable, odds [5] Michael C. Browne, Edmund M. Clarke, and Orna Grumberg. 1988. Characteriz-
ing Finite Kripke Structures in Propositional Temporal Logic. Theor. Comput. Sci.
are that an attacker can work around the missing idiom. While this 59 (1988), 115–131. https://doi.org/10.1016/0304-3975(88)90098-9
certainly creates a cost for the attacker, the risk is that this is a [6] Stephen A. Cook and Robert A. Reckhow. 1972. Time-bounded Random Access
one-off cost: The attacker only has to construct a new idiom once, Machines. In Proceedings of the Fourth Annual ACM Symposium on Theory of
Computing (STOC ’72). ACM, New York, NY, USA, 73–80. https://doi.org/10.1145/
and can re-use it for multiple attacks on the same target. 800152.804898
[7] Crispin Cowan, Calton Pu, Dave Maier, Heather Hintony, Jonathan Walpole,
6.3.1 Limitations of CFI to prevent exploitation. It should be Peat Bakke, Steve Beattie, Aaron Grier, Perry Wagle, and Qian Zhang. 1998.
noted that both examples under consideration in this paper exhib- StackGuard: Automatic Adaptive Detection and Prevention of Buffer-overflow
Attacks. In Proceedings of the 7th Conference on USENIX Security Symposium -
ited perfect control-flow-integrity: An attacker never subverted Volume 7 (SSYM’98). USENIX Association, Berkeley, CA, USA, 5–5. http://dl.acm.
control flow (nor could he, in the computational model we used). org/citation.cfm?id=1267549.1267554
Historically,attackers preferred to obtain control over the instruc- [8] Thomas Dullien. 2011. Exploitation and state machines. In Infiltrate Offensive
Security Conference. Miami Beach, Florida. http://www.slideshare.net/scovetta/
tion pointer of cpu - so most effort on the defensive side is spent on fundamentals-of-exploitationrevisited
preventing this from happening. It is likely, though, that the reason [9] Enes Göktas, Elias Athanasopoulos, Herbert Bos, and Georgios Portokalidis.
why attackers prefer hijacking the instruction pointer is because 2014. Out of Control: Overcoming Control-Flow Integrity. In Proceedings of the
2014 IEEE Symposium on Security and Privacy (SP ’14). IEEE Computer Society,
it allows them to leave the ”difficult” world of weird machine pro- Washington, DC, USA, 575–589. https://doi.org/10.1109/SP.2014.43
gramming and program a machine that is well-understood with [10] Jan Friso Groote and Frits W. Vaandrager. 1990. An Efficient Algorithm for
Branching Bisimulation and Stuttering Equivalence.. In ICALP (2009-09-19) (Lec-
clearly specified semantics - the cpu. It is quite unclear to what ture Notes in Computer Science), Mike Paterson (Ed.), Vol. 443. Springer, 626–638.
extent perfect CFI would render attacks impossible, and depends http://dblp.uni-trier.de/db/conf/icalp/icalp90.html#GrooteV90
heavily on the security properties of the attacked program, as well [11] Sean Heelan. 2010. Misleading the public for fun and profit.
https://sean.heelan.io/2010/12/07/misleading-the-public-for-fun-and-profit/
as the other code it contains. (Dec. 2010).
An excessive focus on control flow may set wrong priorities: [12] Hong Hu, Shweta Shinde, Sendroiu Adrian, Zheng Chua Leong, Prateek Saxena,
Exploitation can occur without control flow ever being diverted, and Zhenkai Liang. 2016. Data-Oriented Programming: On the Expressiveness
of Non-Control Data Attacks. In 37th IEEE Symposium on Security and Privacy,
and the only thing that can obviously be prevented by perfect CFI San Jose, CA, US, May 2016.
are arbitrary syscalls out-of-sequence with the normal behavior [13] Yoongu Kim, Ross Daly, Jeremie Kim, Chris Fallin, Ji Hye Lee, Donghyuk Lee,
Chris Wilkerson, Konrad Lai, and Onur Mutlu. 2014. Flipping Bits in Memory
of the program. While this in itself may be a worthwhile goal, the Without Accessing Them: An Experimental Study of DRAM Disturbance Errors.
amount of damage an attacker can do without subverting control SIGARCH Comput. Archit. News 42, 3 (June 2014), 361–372. https://doi.org/10.
flow is substantial. 1145/2678373.2665726
[14] Gene Novark, Emery D. Berger, and Benjamin G. Zorn. 2007. Exterminator:
Automatically correcting memory errors with high probability. In In Proceedings
6.4 Acknowledgements of the 2007 ACM SIGPLAN Conference on Programming Language Design and
Implementation, ACM. Press.
This paper grew out of long discussions with and benefited from [15] Gerardo Richarte. 2002. Four different tricks to bypass StackShield and Stack-
suggestions given by (in random order): Felix Lindner, Ralf-Philipp Guard protection. World Wide Web 1 (2002).
Weinmann, Willem Pinckaers, Vincenzo Iozzo, Julien Vanegue, [16] Felix Schuster, Thomas Tendyck, Christopher Liebchen, Lucas Davi, Ahmad-Reza
Sadeghi, and Thorsten Holz. 2015. Counterfeit Object-oriented Programming:
Sergey Bratus, Ian Beer, William Whistler, Sean Heelan, Sebas- On the Difficulty of Preventing Code Reuse Attacks in C++ Applications.. In
tian Krahmer, Sarah Zennou, Ulfar Erlingsson, Mark Brand, Ivan IEEE Symposium on Security and Privacy. IEEE, IEEE Computer Society, 745–762.
http://dblp.uni-trier.de/db/conf/sp/sp2015.html#SchusterTLDSH15
Fratric, Jann Horn, Mara Tam and Alexander Peslyak. [17] Mark Seaborn and Thomas Dullien. 2015. Exploiting the DRAM rowhammer bug
to gain kernel privileges. http://googleprojectzero.blogspot.fr/2015/03/exploiting-
APPENDIX dram-rowhammer-bug-to-gain.html. (March 2015).
[18] GOBBLES Security. 2002. Ending a few arguments with one simple attachment.
Appendix A: Program listing for the flat-array BugTraq Mailing List 1 (June 2002).
[19] LSD Security. Technical analysis of the remote sendmail vulnerability. Email
variant posted to Bugtraq Mailing List, http://seclists.org/bugtraq/2003/Mar/44 month =
mar, year =. (????).
Appendix B: Program listing for the linked-list [20] Hovav Shacham. 2007. The Geometry of Innocent Flesh on the Bone: Return-
variant into-libc Without Function Calls (on the x86). In Proceedings of the 14th ACM
Conference on Computer and Communications Security (CCS ’07). ACM, New York,
REFERENCES NY, USA, 552–561. https://doi.org/10.1145/1315245.1315313
[21] PaX Team. 2003. https://pax.grsecurity.net/docs/aslr.txt. Text File. (March 2003).
[1] Martín Abadi, Mihai Budiu, Úlfar Erlingsson, and Jay Ligatti. 2005. Control- [22] PaX Team. 2015. RAP: RIP ROP. https://pax.grsecurity.net/docs/PaXTeam-
flow Integrity. In Proceedings of the 12th ACM Conference on Computer and H2HC15-RAP-RIP-ROP.pdf. (Oct. 2015).
Communications Security (CCS ’05). ACM, New York, NY, USA, 340–353. https: [23] Rob J. van Glabbeek and W. Peter Weijland. 1996. Branching Time and
//doi.org/10.1145/1102120.1102165 Abstraction in Bisimulation Semantics. J. ACM 43, 3 (May 1996), 555–600.
[2] Clive Blackwell and Hong Zhu (Eds.). 2014. Cyberpatterns, Unifying Design https://doi.org/10.1145/233551.233556
Patterns with Security and Attack Patterns. Springer. https://doi.org/10.1007/ [24] Julien Vanegue. 2014. The Weird Machines in Proof-Carrying Code. 2014 IEEE
978-3-319-04447-7 Security and Privacy Workshops 0 (2014), 209–213. https://doi.org/10.1109/SPW.
2014.37
4 Strong stack cookies are one example of a mitigation that will deterministically detect
a particular class of corruptions if a given program point ρ i is reached.
12
 1 . const f i r s t I n d e x 6
2 . const lastIndex 6 + (5000∗2)
3 BasicStateA :
4 READ r0 # Read p
5 READ r1 # Read s
6 CheckForNullSecret :
7 JZ r1 , O u t p u t E r r o r M e s s a g e
8 JZ r0 , O u t p u t E r r o r M e s s a g e
9 CheckForPresenceOfP : # Run t h r o u g h a l l p o s s i b l e a r r a y e n t r i e s .
10 LOAD f i r s t I n d e x , r3
11 LOAD lastIndex , r4
12 CheckForCorrectP :
13 ICOPY r3 , r 5 # Load t h e s t o r e d p o f t h e t u p l e
14 SUB r5 , r0 , r 5 # Subtract the input p
15 JZ r5 , PWasFound
16 ADD r3 , 2 , r 3 # Advance t h e i n d e x i n t o t h e t u p l e a r r a y .
17 SUB r3 , r4 , r 5 # Have we c h e c k e d a l l e l e m e n t s o f t h e a r r a y ?
18 JNZ r5 , C h e c k F o r C o r r e c t P
19 PWasNotFound :
20 LOAD f i r s t I n d e x , r3
21 LOAD lastIndex , r4
22 SearchForEmptySlot :
23 ICOPY r3 , r 5
24 JZ r5 , EmptyFound
25 ADD r3 , 2 , r 3
26 SUB r3 , r4 , r 5
27 JZ r5 , NoEmptyFound
28 J SearchForEmptySlot
29 NoEmptyFound :
30 OutputErrorMessage :
31 SUB r0 , r0 , r 0
32 PRINT r0
33 J BasicStateA
34 EmptyFound :
35 DCOPY r3 , r 0 # W r i t e t h e p a s s w o r d
36 ADD r3 , 1 , r 3 # Adjust the pointer
37 DCOPY r3 , r 1 # W r i t e t h e s e c r e t .
38 J BasicStateA
39 PWasFound :
40 LOAD 0 , r4
41 DCOPY r3 , r 4 # Zero o u t t h e s t o r e d p
42 ADD r3 , 1 , r 3
43 ICOPY r3 , r 5 # Read t h e s t o r e d s
44 PRINT r5
45 J BasicStateA

variant1A.s

Figure 5: Listing for variant1A.s

[25] David Walker, Lester Mackey, Jay Ligatti, George A. Reis, and David I. August.
2006. Static Typing for a Faulty Lambda Calculus. In Proceedings of the Eleventh
ACM SIGPLAN International Conference on Functional Programming (ICFP ’06).
ACM, New York, NY, USA, 38–49. https://doi.org/10.1145/1159803.1159809

13
 1 c o n s t f r e e _ h e a d 5 # Head o f t h e f r e e l i s t .
2 c o n s t u s e d _ h e a d 6 # Head o f t h e u s e d l i s t .
3 J InitializeFreeList
4 BasicStateA :
5 READ r0 # Read p
6 READ r1 # Read s
7 SUB r2 , r2 , r 2 # I n i t i a l i z e a c o u n t e r f o r number o f e l e m e n t s .
8 CheckForNullSecret :
9 JZ r1 , O u t p u t E r r o r M e s s a g e # Zero s e c r e t n o t a l l o w e d .
10 JZ r0 , O u t p u t E r r o r M e s s a g e # Zero p a s s w o r d n o t a l l o w e d .
11 LOAD used_he ad , r 3 # The l i s t c o n s i s t s o f [ p , s , n x t ] t u p l e s .
12 CheckForPresenceOfP :
13 JZ r3 , E n d O f U s e d L i s t F o u n d
14 ICOPY r3 , r 4 # Load ' p ' o f t h e e n t r y .
15 SUB r4 , r0 , r 4 # Compare a g a i n s t t h e p a s s w o r d
16 JZ r4 , PWasFound # E l e m e n t was f o u n d .
17 ADD r3 , 2 , r 3 # Advance t o ' n e x t ' w i t h i n [ p , s , n x t ]
18 ICOPY r3 , r 3 # Load t h e ' n e x t ' p o i n t e r .
19 J r3 , C h e c k F o r P r e s e n c e O f P
20 EndOfUsedListFound :
21 LOAD free_head , r3
22 JZ r3 , O u t p u t E r r o r M e s s a g e # No more f r e e e l e m e n t s a v a i l a b l e ?
23 ICOPY r3 , r 2 # Get t h e f i r s t e l e m e n t from t h e f r e e l i s t
24 DCOPY r2 , r 0 # Write the [ p , ? , ?]
25 ADD r2 , 1 , r 4
26 DCOPY r4 , r 1 # Write the [ p , s , ?]
27 LOAD used_he ad , r 0
28 ICOPY r0 , r 1 # Load u s e d _ h e a d t o p l a c e i t i n ' n e x t '
29 DCOPY r0 , r 2 # R e w r i t e u s e d _ h e a d t o p o i n t t o new e l e m e n t
30 ADD r2 , 2 , r 4 # P o i n t to ' next ' f i e l d
31 ICOPY r4 , r 2 # Load t h e p t r t o t h e n e x t f r e e e l e m e n t i n t o r 2
32 DCOPY r4 , r 1 # Write the [ p , s , next ]
33 DCOPY r3 , r 2 # W r i t e t h e f r e e _ h e a d −> n e x t f r e e e l e m e n t
34 J BasicStateA
35 PWasFound :
36 ADD r3 , 1 , r 2
37 ICOPY r2 , r 1 # Load t h e s t o r e d s e c r e t .
38 PRINT r 1 # Output t h e s e c r e t .
39 ADD r3 , 2 , r 2 # P o i n t r 2 t o t h e n e x t f i e l d .
40 LOAD free_head , r1
41 ICOPY r1 , r 0 # Read t h e c u r r e n t p o i n t e r t o t h e f r e e l i s t .
42 DCOPY r2 , r 1 # P o i n t n e x t p t r o f c u r r e n t t r i p l e t o f r e e l i s t .
43 DCOPY r1 , r 3 # P o i n t f r e e − head t o c u r r e n t t r i p l e .
44 J BasicStateA
45 InitializeFreeList :
46 LOAD free_head , r0
47 LoopToInitialize :
48 ADD r0 , 3 , r 1 # Advance t o t h e n e x t e l e m e n t .
49 ADD r0 , 2 , r 0 # Advance t o t h e n e x t p o i n t e r i n s i d e .
50 DCOPY r0 , r 1 # Write the next p o i n t e r .
51 ADD r1 , 0 , r 0 # Set current e l t = next element .
52 SUB r0 , 5 0 0 0 ∗ 3 + 7 , r 2 # Have we i n i t i a l i z e d enough ?
53 JNZ r2 , L o o p T o I n i t i a l i z e
54 TerminateFreeList :
55 SUB r0 , 1 , r 0
56 DCOPY r0 , r 2 # S e t the l a s t next −p o i n t e r 0 to t e r m i n a t e
57 # the f r e e l i s t .
58 WriteInitialFreeHead :
59 LOAD used_head +1 , r0
60 LOAD free_head , r1
61 DCOPY r1 , r 0 # S e t t h e f r e e − head t o p o i n t t o t h e f i r s t t r i p l e .
62 J BasicStateA
63 OutputErrorMessage :
64 SUB r0 , r0 , r 0
65 PRINT r 0
66 J BasiceStateA

variant2A.s

Figure 6: Listing for variant2A.s

14