Automated CFI Policy Assessment with Reckon

TL;DR

Reckon is a static analysis tool that systematically models and evaluates various CFI defenses, providing insights into their security levels and residual attack surfaces on real-world programs.

Contribution

The paper introduces Reckon, a novel static source code analysis framework for modeling, comparing, and assessing the effectiveness of static CFI defenses systematically.

Findings

Reckon accurately measures residual attack surfaces of CFI defenses.

It ranks CFI policies based on security levels.

Reckon can identify remaining gadgets even under restrictive CFI policies.

Abstract

Protecting programs against control-flow hijacking attacks recently has become an arms race between defenders and attackers. While certain defenses, e.g., \textit{Control Flow Integrity} (CFI), restrict the targets of indirect control-flow transfers through static and dynamic analysis, attackers could search the program for available gadgets that fall into the legitimate target sets to bypass the defenses. There are several tools helping both attackers in developing exploits and analysts in strengthening their defenses. Yet, these tools fail to adequately (1) model the deployed defenses, (2) compare them in a head-to-head way, and (3) use program semantic information to help craft the attack and the countermeasures. Control Flow Integrity (CFI) has proved to be one of the promising defenses against control flow hijacks and tons of efforts have been made to improve CFI in various ways in the past decade. However, there is a lack of a systematic assessment of the existing CFI defenses. In this paper, we present Reckon, a static source code analysis tool for assessing state-of-the-art static CFI defenses, by first precisely modeling them and then evaluating them in a unified framework. Reckon helps determine the level of security offered by different CFI defenses, and find usable code gadgets even after the CFI defenses were applied, thus providing an important step towards successful exploits and stronger defenses. We have used Reckon to assess eight state-of-the-art static CFI defenses on real-world programs such as Google's Chrome and Apache Httpd. Reckon provides precise measurements of the residual attack surfaces, and accordingly ranks CFI policies against each other. It also successfully paves the way to construct code reuse attacks and to eliminate the remaining attack surface, by disclosing calltargets under one of the most restrictive CFI defenses.

Figures

Tables

Table 1. TABLE I: Mapping of CFI code-reuse defenses into Reckon constraints. Note that all these CFI defenses were published in top tier security conferences.

Defense			Write Constraints	Target Constraints
Class	Subclass	Solutions	Details	Dynamic	Details
	TypeArmor	[12]	None	✘	Bin types
	IFCC/MCFI	[47, 34]	None	✘	Src types
	Safe IFCC/MCFI	[47, 34]	None	✘	Safe src Types
	ShrinkWrap/IVT	[31]	None	✘	Strict sub-hier.
CFI	VTV	[34, 30]	None	✘	Sub-hierarchy
	vTint	[28]	None	✘	All vTables
	Marx/VCI	[27, 64]	None	✘	vTable hierarchy
	HCFI	[55]	None	✓	Computed
	CsCFI	[63]	Segr	✓	None
	vTrust	[29]	None	✘	Strict src types

Table 2. TABLE II: Legitimate calltargets per callsite for each of the eight CFI policies for NodeJS after each CFI defense was individually applied. The values not contained in round brackets are obtained for only virtual callsites and all targets ( i.e., virtual and non-virtual), while the values in round brackets are obtained for all indirect callsites ( i.e., virtual and function pointer based calls) and all targets. For the Bin types , Safe src types , and Src types policies depicted above the targets can be virtual or non-virtual, for the remaining policies the targets inherently can only be virtual functions. Targets median: (minimum and maximum) number of legal function targets per callsite. Target distribution: minimum/90th percentile/maximum number of targets per callsite. This 90p is determined by sorting the values in ascending order, and picking the value at 90%. This means that 90% of the sorted values have a lower or equal value to 90p. P: Policy (Static target constraints), (1) Bin types  [ 12 ] , (2) Safe src types  [ 34 ] , (3) Src types  [ 47 ] , (4) Strict src types  [ 29 ] , (5) All virtual tables  [ 28 ] , (6) virtual Table hierarchy  [ 27 ] , (7) Sub-hierarchy  [ 30 ] , and (8) Strict sub-hierarchy  [ 31 ] .

	Targets Median					Targets Distribution
P						NodeJs			MKSnapshot
	NodeJS	MKSnaphot	Total	Min	Max	Min	90p	Max	Min	90p	Max
(1)	21,950 (21,950)	15,817 (15,817)	15,817 (20,253)	15,817 (15,817)	21,950 (21,950)	12,545 (885)	30,179 (30,179)	32,478 (32,478)	8,714 (244)	21,785 (21,785)	23,376 (23,376)
(2)	2,885 (88)	2,273 (495)	2,273 (139)	2,273 (88)	2,885 (21,950)	0 (0)	5,751 (5,751)	5,751 (5,751)	1 (0)	4,436 (4,436)	4,436 (4,436)
(3)	1,511 (56)	1,232 (355)	1,232 (139)	1,232 (56)	1,511 (355)	0 (0)	5,751 (5,751)	5,751 (5,751)	1 (0)	4,436 (4,436)	4,436 (4,436)
(4)	3	2	3	2	3	0	499	730	0	507	756
(5)	6,128	2,903	6,128	2,903	6,128	6,128	6,128	6,128	2,903	2,903	2,903
(6)	2	1	2	1	2	0	54	243	0	16	108
(7)	2	1	1	1	2	0	7	243	0	11	108
(8)	2	1	1	1	2	0	6	243	0	9	108

Table 3. TABLE III: Legitmate calltargets per callsite for only virtual callsites and for only the C++ programs after each CFI defense was individually applied. Baseline all func. represents the total number of functions, while Baseline virtual func. represents the number of virtual functions. The first four policies, from left to right in italic font ( Bin types , Safe src types , Src types , and Strict src types ) allow virtual or non-virtual targets, while the remaining four policies inherently allow only virtual targets. This is not a limitation of Reckon but rather how these were intended, designed and used in the original tools from where these are stemming. The values in round brackets show the theoretical results after adapting the first four policies to only allow virtual targets. Each table entry contains five aggregate values: minimal, 90p: minimum/90th percentile/maximum, maximal, median and average (Avg) number of targets per callsite. P: program, NJS: NodeJS, TS: Traffic Server, C: Chrome. (1) Bin types, (2) Safe src types, (3) Src types, (4) Strict src types, (5) All virtual tables, (6) virtual Table hierarchy, (7) Sub-hierarchy, and (8) Strict sub-hierarchy.

		Callsites	Targets Baseline		Virtual Function Targets
P	Value	Write cons.	Base. all func.	Base. vFunc.	(1)	(2)	(3)	(4)	(5)	(6)	(7)	(8)
	Min				12,545 (1,956)	0 (0)	0 (0)	0 (0)	6,128	0	0	0
	90p				30,179 (4,078)	5,751 (810)	5,751 (810)	499 (10)	6,128	54	7	6
NJS	Max	none	32,478	6,300	32,478 (4,455)	5,751 (810)	5,751 (810)	730 (243)	6,128	243	243	243
	Median				21,950 (3,106)	2,885 (426)	1,511 (121)	3 (3)	6,128	2	2	2
	Avg				19,395 (2,793)	2,406 (414)	2,113 (354)	86 (12)	6,128	14	8	8
	Min				2,608 (232)	1 (0)	1 (0)	0 (0)	788	0	0	0
	90p				4,085 (546)	1,315 (97)	1,315 (97)	17 (13)	788	34	7	7
TS	Max	none	6,201	796	6,201 (710)	1,315 (159)	1,315 (159)	18 (16)	788	42	18	18
	Median				2,608 (232)	1,315 (97)	1,315 (97)	17 (13)	788	7	1	1
	Avg				3,122 (321)	928 (76)	923 (74)	11 (9)	788	10	3	3
	Min				97,041 (37,873)	0 (0)	0 (0)	0 (0)	68,560	0	0	0
	90p				201,477 (63,816)	64,315 (24,661)	64,315 (24,661)	48 (30)	68,560	192	25	15
C	Max	none	232,593	78,992	232,593 (71,000)	64,315 (24,661)	64,315 (24,661)	3,029 (509)	68,560	4,486	4,486	4,486
	Median				97,041 (37,873)	8,672 (4,593)	7,633 (4,593)	3 (2)	68,560	6	2	2
	Avg				128,452 (45,731)	29,315 (11,119)	29,127 (11,013)	57 (19)	68,560	78	37	32

Table 4. TABLE IV: Normalized results with the Baseline using only virtual callsites. Note that virtual callsites all eight policies can be used as these were designed in the original papers to be used for these types of callsites as well. Baseline: Total number of possible virtual targets. Each entry contains three aggregate values: average-, standard deviation (SD) and 90p-number of targets per callsite. The lower the Average value is the better the CFI defense is. B: baseline, P: program, NJS: NodeJS, TS: Traffic Server, C: Chrome

P	B	Bin types			Safe src types			Src types			Strict src types			All vTables			vTable hierarchy			Sub-hierarchy			Strict sub-hierarchy
		Avg	SD	90p	Avg	SD	90p	Avg	SD	90p	Avg	SD	90p	Avg	SD	90p	Avg	SD	90p	Avg	SD	90p	Avg	SD	90p
NJS	6,300	59.72	21.0	92.92	7.41	6.32	17.71	6.51	6.44	17.71	0.26	0.54	1.54	97.27	0.0	97.27	0.23	0.63	0.86	0.13	0.46	0.11	0.13	0.46	0.1
TS	796	50.35	15.79	65.88	14.97	8.89	21.21	14.89	9.01	21.21	0.18	0.12	0.27	98.99	0.0	98.99	1.26	1.27	4.27	0.34	0.51	0.88	0.34	0.51	0.88
C	78,992	55.23	19.08	86.62	12.6	12.16	27.65	12.52	12.22	27.65	0.02	0.11	0.02	86.79	0.0	86.79	0.1	0.43	0.24	0.05	0.41	0.03	0.04	0.41	0.02
Avg.	28,696	55.1	18.62	81.8	11.66	9.12	22.19	11.3	9.22	22.19	0.15	0.25	0.61	94.35	0.0	94.35	0.53	0.77	1.79	0.17	0.46	0.34	0.17	0.46	0.33

Table 5. TABLE V: Normalized results using all indirect callsites. B:baseline, a:NodeJS, b:Apache Traffic Server, c:Google’s Chrome, d:Httpd, e:LightHttpd, f:Memcached, g:Nginx, h:Redis.

		Bin types			Safe src types			Src types
P	B	Avg	SD	90p	Avg	SD	90p	Avg	SD	90p
a	32,478	64.0	20.43	92.92	3.82	5.83	17.71	3.38	5.64	17.71
b	6,201	54.03	18.76	87.89	13.54	9.27	21.21	13.46	9.36	21.21
c	232,593	56.83	19.84	86.62	11.71	12.11	27.65	11.64	12.16	27.65
d	1,949	52.18	26.5	92.0	2.7	3.01	8.21	2.46	3.01	8.21
e	594	65.25	27.81	97.98	2.94	3.18	7.41	2.93	3.19	7.41
f	225	69.75	7.11	68.89	1.0	0.97	0.89	1.0	0.97	0.89
g	1,270	54.91	24.85	92.28	6.38	4.56	11.73	6.36	4.57	11.73
h	2,880	65.19	16.51	84.62	1.25	2.52	1.88	1.2	2.52	1.88
Avg	34,773	60.3	34.39	87.9	5.4	5.18	12.09	5.3	5.17	12.08

Table 6. TABLE VI: Results for virtual and pointer based callsites. P: program, Memchd: Memcached, (1) Bin types, (2) Safe src types, (3) Src types. a:NodeJS, b:Apache Traffic Server, c:Google’s Chrome, d:Httpd, e:LightHttpd, f:Memcached, g:Nginx, h:Redis.

				Targets (Non-)vFunctions
P	Value	Callsite write cons.	Baseline all func.	(1)	(2)	(3)
	Min			885	0	0
	90p			30,179	5,751	5,751
a	Max	none	32,478	32,478	5,751	5,751
	Med			21,950	88	56
	Avg			20,787	1,242	1,099
	Min			357	0	0
	90p			5,450	1,315	1,315
b	Max	none	6,201	6,201	1,315	1,315
	Med			2,608	1,315	1,315
	Avg			3,350	840	835
	Min			3,612	0	0
	90p			201,477	64,315	64,315
c	Max	none	232,593	232,593	64,315	64,315
	Med			97,041	8,672	7,394
	Avg			132,182	27,238	27,074
	Min			99	0	0
	90p			1,793	160	160
d	Max	none	1,949	1,915	160	160
	Med			1,070	18	16
	Avg			1,017	53	48
	Min			37	0	0
	90p			582	44	44
e	Max	none	594	582	44	44
	Med			395	6	6
	Avg			388	17	17
	Min			92	0	0
	90p			155	2	2
f	Max	none	225	221	17	17
	Med			155	2	2
	Avg			157	2	2
	Min			422	1	1
	90p			1,172	149	149
g	Max	none	1,270	1,259	149	149
	Med			719	75	75
	Avg			697	81	81
	Min			1,266	1	1
	90p			2,437	54	54
h	Max	none	2,880	2,635	391	391
	Med			1,994	16	14
	Avg			1,877	36	35

Table 7. TABLE VII: Ten controllable callsites and their legitimate targets under the Sub-hierarchy CFI defense. #: passed parameters. CS: Ten controllable callsites, (1) Bin types, (2) Safe src types, (3) Src types, (4) Strict src types, (5) All virtual tables, (6) virtual Table hierarchy, (7) Sub-hierarchy, and (8) Strict sub-hierarchy.

CS				Target Policies
	#	Baseline only vFunc.	Baseline all Func.	(1)	(2)	(3)	(4)	(5)	(6)	(7)	(8)
a	5	6,300	32,478	31,305	4	4	1	6,128	1	1	1
b	2	6,300	32,478	21,950	719	719	49	6,128	57	53	49
c	3	6,300	32,478	27,823	136	136	1	6,128	1	1	1
d	1	6,300	32,478	12,545	810	810	1	6,128	72	12	12
e	1	6,300	32,478	1,956	810	810	1	6,128	72	13	13
f	1	6,300	32,478	1,956	810	810	6	6,128	20	19	19
g	3	6,300	32,478	1,956	810	810	6	6,128	20	19	19
h	2	6,300	32,478	3,106	35	35	8	6,128	48	13	5
i	2	6,300	32,478	3,106	2,984	2,984	49	6,128	53	53	49
j	2	6,300	32,478	3,106	719	719	49	6,128	53	53	19

Full text

Control Flow Integrity (CFI) has proved to be one of the promising defenses against control flow hijacks and tons of efforts have been made to improve CFI in various ways in the past decade. However, there is a lack of a systematic assessment of the existing CFI defenses. In this paper, we present Reckon, a static source code analysis tool for assessing state-of-the-art static CFI defenses, by first precisely modeling them and then evaluating them in a unified framework. Reckon helps determine the level of security offered by different CFI defenses, and find usable code gadgets even after the CFI defenses were applied, thus providing an important step towards successful exploits and stronger defenses. We have used Reckon to assess eight state-of-the-art static CFI defenses on real-world programs such as Google’s Chrome and Apache Httpd. Reckon provides precise measurements of the residual attack surfaces, and accordingly ranks CFI policies against each other. It also successfully paves the way to construct code reuse attacks and to eliminate the remaining attack surface, by disclosing calltargets under one of the most restrictive CFI defenses.

I Introduction

Ever since the first Return Oriented Programing (ROP) attack [61], the cat and mouse game between defenders and attackers has seen several peaks [58]. As defenses improved over time, the attacks progressed with them [58]. While defenders followed several lines of research when building defenses: control flow integrity [29, 63, 55, 27, 64, 28, 34, 30, 31, 47, 12], binary re-randomization [50], information hiding [57], and code pointer integrity [49], the attacks kept up the pace and got more and more sophisticated [3, 4, 5, 6, 39].

In principle, even with the myriad of currently available CFI defenses, performing exploits is still possible. Attackers could search the program for gadgets that are allowed by CFI defenses to conduct Code Reuse Attacks (CRAs) [10, 3]. But the attacks become highly program-dependent, and the applied CFI policies make reasoning about security harder. The attacker/analyst is thus confronted with the challenge of searching (manually or automatically) the protected program’s binary or source code for gadgets which remain useful after CFI defenses have been deployed. Thus, there is a growing demand for defense-aware assessing tools, that assist security analysts to assess CFI defenses.

Existing tools, including static pattern-based gadget searching tools [51, 45] and dynamic attack construction tools [40, 25, 62, 56, 24], all lack deeper knowledge of the protected program. As such, they can find CRA gadgets, but cannot determine if the gadgets are usable after a defense was deployed. A recent work Newton [40] could assess and bypass deployed defenses, but it relies on the real execution of the target program to gather sufficient information.

Consequently, with each applied defense, a more capable assessment tool needs ideally to: (1) model the defense as precisely as possible, (2) use program metadata in order not to solely rely on runtime memory constraints, (3) use precise semantic knowledge about the protected program code, and (4) provide absolute measurement numbers w.r.t. the remaining attack surface. This allows to provide precise and reproducible measurements, to decide which CFI defense is better suited for a given situation, and to defend against or craft CRAs by searching available gadgets.

In this paper, we present Reckon, to our knowledge, the first static source code analysis framework for modeling and assessing static state-of-the-art CFI defenses w.r.t. the security level they offer and the remaining attack surface they have. It provides a unified framework to evaluate different CFI defenses, enabling a head-to-head comparison. Note that, the use of different compilers or platforms would make the results of CFI evaluation incomparable. Reckon relies on the insight that, by carefully modeling a CFI defense into a comprehensive policy, the introduced constraints on call sites and call targets can be assessed during program compile time, by a unified compilation analysis component.

Reckon also provides a set of expressive primitives, which are able to characterize a wide range of static CFI policies. For example, Reckon provides static primitives related to types, class hierarchies and virtual table layouts. These primitives could be used as building blocks to model many CFI policies. Further, Reckon provides the available/legitimate call targets under different CFI defenses. It can be reused by CRA attacks, e.g., the control flow bending attack as described by Carlini et al. [10], or be used to refine the analysis pipelines of existing attack construction or defense tools.

Note that, Reckon only focuses on assessing static CFI defenses, as these are more commonly deployed than dynamic defenses. In addition, Reckon focuses on source code rather than on binary code, as comparing various static CFI defenses against each other is more feasible in this way. Moreover, the binary CFI policy implementations can be expressed precisely in source code. Therefore, there is no need to look at the binary of the protected program since its source code provides more semantic richness and precision w.r.t. the constraints imposed by each CFI defense.

We evaluate Reckon with common open source programs: NodeJS, Bind, Memcached, Httpd, Lighttpd, Nginx, Apache Traffic Server, Google’s Chrome Web browser, and Redis. We show that Reckon can help the assessment of CFI defenses and is effective at finding gadgets, even with highly restrictive state-of-the-art CFI defenses deployed. In addition, we demonstrate how Reckon can be utilized to craft a code reuse attack. We also show how it can be effectively used to empirically measure the real attack surface reduction after a certain static CFI defense policy was used to harden a program’s binary. Applications of Reckon go beyond CFI defense assessment framework, and we envision Reckon as a tool for defenders and software developers to highlight the residual attack surface of a program.

In summary, we make the following contributions:

• •

We present a static CFI attack model that is powerful and drastically lowers the bar for performing CRAs against state-of-the-art CFI defenses. With this model, we also introduce a new CFI defense metric ($CTR$) to more precisely characterize the existing CFI defenses.

• •

We implement Reckon, a novel framework usable for empirically analyzing and comparing CFI defenses against each other, as well as for generating low-effort CRAs by identifying the legitimate target sets under different CFI defenses and highlight how they can be used to craft attacks.

• •

We present general evaluation results based on several real-world programs by comparing existing static CFI defenses on multiple security relevant dimensions. Meanwhile, we also present a NodeJS-based case study with the goal of highlighting how Reckon can be used to craft CRAs against a state-of-the-art defense, e.g., the secure VTV/IFCC [34] implementation.

II Background

II-A CRA Primitives

There are mainly two types of CRA primitives: one exploits the forward-edge, and the other exploits the backward-edge, based on the program control flow graph (CFG).

Forward-edge based CRAs exploit the forward-edges of CFGs. First, at the source code level by performing calls through either function pointers (e.g., single level of indirection) or virtual calls (e.g., double level of indirection). For example, these calls may use an array of function pointers that is accessed by a pointer to a virtual table (vtable) plus an index. Second, at the binary level, jump, and call instructions are used to redirect the program control flow to a different address than the one intended in the original program CFG.

Backward-edge based CRAs violate CFG backward edges. First, at the source code level, the function will not return to the next source code line from where the function was first called. Second, in the program binary, the address located on the stack is modified such that the function’s ret instruction will return to a different address than the one next to the instruction from where the function was initially called (mostly through a call instruction).

Finally, these two types of primitives (forward and backward edges) are used to link gadgets, in order to form a gadget chain with the goal of performing turing-complete malicious computations. Note that in this work we focus only on forward-edge based code reuse attacks and their assessment.

II-B Control-Flow Integrity

Control-Flow Integrity (CFI) is a state-of-the-art technique used successfully along other techniques to protect forward and backward edges against program control-flow hijacking. CFI is used to mitigate CRAs by, for example, pre-pending an indirect callsite with runtime checks that make sure only legal calltargets are allowed by an as precisely as possible computed control flow graph (CFG) [1].

Protection Schemes. Alias analysis in binary programs is undecidable [9]. For this reason, when protecting CFG forward-edges, defenders focus on using other program primitives to enforce a precise CFG during runtime. These primitives are most commonly represented by the program’s: class hierarchy [31], virtual table layouts [11], quasi-class hierarchies [27], binary function types [12] (callsite/calltarget parameter count matching), etc. They are used to enforce a CFG which is as close as possible to the original CFG being best described by the program control flow execution. Note that state-of-the-art CFI solutions use either static or dynamic information for determining legal calltargets.

Static Information. CFI solutions that use static information allow callsites to target: (1) all function entry points e.g., [7], map callsite types to target function types by creating a mask which enforces that the number of provided parameters (up to six) has to be higher than the number of consumed parameters e.g., [12], (2) a quasi-class hierarchy (no root node(s) and the edges are not oriented) can be recuperated from the binary and enforced e.g., [27], (3) all virtual tables that can be recuperated and enforced e.g., [11], only certain virtual table entries are allowed e.g., [29] based on a precise function type mapping, and (4) sub-class hierarchies are enforced e.g., [34, 31, 30].

Dynamic Information. The goal of CFI solutions which use dynamic information is to refine their runtime analysis by leveraging program information which is only available during program execution. In particular, PiCFI [55] restricts the set of calltargets to functions which have their address computed during runtime. Context-sensitive solutions with different levels of context precision rely on hardware features such as the Last Branch Register (LBR) [60] to track a limited range (i.e., 16 up to 32 address pairs) of so called from and to addresses pairs during runtime. They then compare them against a precomputed program CFG. Finally, note that Intel Processor Trace (PT) [59] can be used to build a longer history of address pairs compared to other approaches.

III Design of Reckon

III-A Overview

Reckon is designed as a static gadget detection framework which can be used to assist an analyst evaluating the attack surface after different types of static CFI defenses were applied. To achieve this, Reckon applies a static black box strategy in order to statically retrieve code-reuse gadgets through a set of attacker-controllable forward control flow graph (CFG) edges. The forward-vulnerable CFG edges are expressed as a callsite with a variable number of possible target functions. Further, these edges can be reused by an attacker to call arbitrary functions via arbitrary read or write primitives. To call such series of arbitrary functions, an attacker can chain a number of edges together by dispatching fake objects contained in a vector. See, for example, the COOP [3] attack which is based on a dispatcher gadget used to call other gadgets through a single loop iteration. The COOP attack uses gadgets which are represented by whole virtual functions.

Reckon supports a wide range of code reuse defenses based on user-defined policies, which are composed of constraints about the set of possible calltargets allowed by a particular applied CFI defense. The main idea behind Reckon is to compile the target program with different types of CFI policies and get the allowed target set per callsite for each constraint configuration. Note that we assume the program was compiled with the same compiler as the one on which Reckon is based. Moreover, Reckon’s policies are reusable and extensible; they model security invariants of important CRA defenses. Essentially, under these constraints, virtual pointers at callsites can be corrupted to call any function in the program. Thus, in this paper, we focus on the possibility to bend [10] a pointer to the callsite’s legitimate targets. Further, we assume that large programs contain enough gadgets for successfully performing CRAs. Bending assumes that it is possible for an attacker to reuse protected gadgets during an attack making the applied defense of questionable benefit.

Figure 1 depicts the main components of Reckon and the workflow used for analyze the source code of a potentially vulnerable program in order to determine CRA statistics, as follows. The analyst first provides as input ❶ to Reckon a program’s source code ❷. Based on the previously selected defense, the desired analysis will be performed. The analysis previously mentioned is dependent on the selected defense model and on the available primitives. The analyst does this if he knows that the defense he wants to apply is currently available in the Reckon tool. The user selects the used defense model from the list of implemented defenses. This is done by switching on a flag inside the Reckon source code, which can also be implemented as a compiler flag, if desired. In case the defense is not available, the analyst needs to extend the list of primitives ❸, and model his defense as a policy (set of constraints) in the analysis component of Reckon ❹. In order to do this, he needs to know about the analysis internals of Reckon. After selecting/modeling a defense, the analyst forwards the application’s source code ❺ to Reckon which will analyze it with its static analysis component. During static analysis ❻ the previously selected defense will be applied when compiling the program source code. As the analysis is performed, each callsite is constrained with only the legitimate calltargets. Note that the per callsite, a legitimate calltarget is dependent on the currently selected defense model. The result of the analysis contains information about the residual target set for each individual callsite after a CFI policy was assessed ❼. This list contains a set of gadgets (callsites + calltargets) that can, given a certain defense model, be used to bend the control flow of the application. These target constraints are collected and clustered in the statistics collection component of Reckon ❽. Finally, at the end of the gadget collection phase, a list of calltargets containing potential usable gadgets statistics ❾ based on the currently applied defense(s) will be reported.

III-B Reckon’s Analysis Primitives

Reckon provides the following program primitives, which are either collected or constructed during program compile time. These primitives are used by Reckon to implement static CFI policies and to perform calltarget constraint analysis. Briefly, the currently available primitives are as follows:

Virtual table hierarchy (see [31] for more detailed definition) allows performing virtual table inheritance analysis of only virtual classes as only these have virtual tables. Finally, a class is virtual if it defines or inherits at least one virtual function.

Vtable set is a set of vtables corresponding to a single program class. This set is useful to derive the legitimate set of calltargets for a particular callsite. The set of calltargets is determined by using the class inheritance relations contained inside a program.

Class hierarchy (see [43, 44] for a formal definition) can be represented as a class hierarchy graph with the goal to model inheritance relations between classes. Note that a real-world program can have multiple class hierarchies (e.g., Chrome, Google’s Web browser). Note that the difference between virtual table hierarchy and class hierarchy is that the class hierarchy contains both virtual and non-virtual classes whereas the virtual table hierarchy can only be used to reason about the inheritance relations between virtual classes.

Virtual table entries allow Reckon to analyze the number of entries in each virtual table with the possibility to differentiate between virtual function entries, offsets in vtables, and thunks.

Vtable type is determined by the name of the vtable root for a given vtable. A vtable root is the last derived vtable contained in the vtable hierarchy.

Callsites are used by Reckon to distinguish between direct and indirect (object-based dispatch and function-pointer based indirect transfers) callsites.

Indirect callsites are based on: (1) object dispatches or (2) function pointer based calls. Based on these primitives, Reckon can establish different types of relations between callsites and calltargets (i.e., virtual functions). At the same time, we note that it is possible to derive backwards relationships from calltargets to legitimate callsites based on this primitive.

Callsite function types allow to precisely determine the number and the type of the provided parameter by a callsite. As such, a precise mapping between callsites and calltargets is possible.

Function types allow to precisely determine the number of parameters, their primitive types and return type value for a given function. This way, Reckon can generate a precise mapping between compatible calltargets and callsites.

These primitives can be used as building blocks during the various analyses that Reckon can perform in order to derive precise measurements and a thorough assessment of a modeled static CFI policy. We note that in order to model other CFI defenses, other (currently not available) simple or aggregated analysis primitives may need to be added inside Reckon.

III-C Constraints

The basic concept of any CRA is to divert the intended control flow of a program by using arbitrary memory write and read primitives. As such, the result of such a corruption is to bend [10] the control flow, such that it no longer points to the intended (legitimate) calltarget set. This means that the attacker can point to any memory address in the program. While this type of attack is still possible, we want to highlight another type of CRA in which the attacker uses the intended/legitimate per callsite target set. That is, the attacker calls inside this set and performs his malicious behavior by reusing calltargets which are protected, yet usable during an attack. As previously observed by others [40], CRA defenses try to mitigate this by mainly relying on one or two dimensions at a time, as follows:

Write constraints limit the attacker’s capabilities to corrupt writable memory. If there is no defense in place, the attacker can essentially corrupt: pointers to data, non-pointer values such as strings, and pointers to code (i.e., function pointers). In this paper, we do not investigate these types of defenses as these were already addressed in detail by Veen et al. [40]. Instead, we focus on target constraints as these represent a big class of defenses which in our assessment needs separate and detailed treatment. This obviously does not mean that our analysis results cannot be used in conjunction with dynamic write constraint assessing tools. Rather, our results represent a common ground truth on which runtime assessing tools can build their gadget detection analysis.

Target constraints restrict the legitimate calltarget set for a callsite which can be controlled by an attacker. With no target constraints in place, the target set for each callsite is represented by all functions located in the program and any linked shared library. The key idea is to reduce the wiggle room for the attacker such that he cannot target random callsites. As most of these defenses impose a one-to-$N$ mapping, an attacker being aware of said mapping could corrupt the pointer at the callsite to bend [10] the control flow to legitimate targets in an illegitate order to achieve his malicious goals. This essentially means that all static defenses impose target constraints.

Static Analysis. Reckon is based on the static analysis of the program which is represented in LLVM’s intermediate representation (IR). The analysis is performed during link time optimization (LTO) inside the LLVM [37] compiler framework to detect callsites and legitimate callees under the currently analyzed CFI defense. Reckon uses the currently available primitives and the implemented defenses to impose target constraints for each callsite individually. Currently, 8 target defenses are supported, see § V-B, but this list can easily be extended since all defenses are based on the similar mechanisms which assessable during a whole program analysis.

Generic Target Constraints. As mentioned above, Reckon can be used to impose existing generic calltarget constraints (defenses) based on class hierarchy relations and callsites and calltarget type matching with different levels of precision depending on the currently modeled CFI defense. Further, Reckon allows extending and combining existing policies or applying them concurrently.

IV Implementation

IV-A Data Collection and Aggregation

Collection. Reckon collects the virtual tables of a program in the Clang front-end and pushes them through the compilation pipeline in order to make them available during link-time optimization (LTO). For each virtual table, Reckon collects the number of entries. The virtual tables are analyzed and aggregated to virtual table hierarchies in a later step. Other data such as direct/indirect callsites and function signatures are collected during LTO.

Aggregation. Next we present the program primitives which are constructed by Reckon: (1) virtual table hierarchies based on the previously collected virtual tables inside the Clang front-end. The virtual table hierarchies are used to derive relationships between the classes inside a program (class hierarchies), determine sub-hierarchy relationships and count, for example, how many virtual table entries (virtual functions) a certain virtual table sub-hierarchy has. (2) virtual table sets which are used for mapping callsites to legitimate class hierarchy-based virtual calltargets. (3) callsite function types which are composed of the number of parameters provided by a callsite, their types, and if the callsite is a void or non-void callsite. (4) function types which are composed of the function name, the expected number of parameters and their types and if the function is a void or non-void function.

IV-B CFI Defense Modeling

Reckon implements a set of constraints for each modeled CFI-defense, which are defined as analysis conditions that model the behavior of each analyzed CFI-defense. These constraints are particular for each CFI-defense and operate on different primitives. More specifically, different constraints of a CFI-defense are implemented inside Reckon. The steps for modeling a CFI defense are as follows: (1) Which Reckon’s primitives are used by the policy? (2) Is there a nesting or subset relation between primitives? (3) Does the policy rely on hierarchical meta-data primitives? (4) What is the callsite/calltarget matching criteria? (5) How to count a callsite/calltarget match?

Note that there is no effort needed to port Reckon from one policy to another as all policies can operate in parallel during compile time. As such, the measurement results obtained for each policy are written in one pass in an external file for later analysis.

Next, we give a concrete example of how a CFI defense, TypeArmor’s Bin types policy [12], was modeled inside Reckon by following the steps mentioned above. For more details, see Section 2 for a description on how this policy works and the constraint sub-classes depicted in Section V-A1. More specifically, for TypeArmor, (1) The policy uses the: callsite primitive, indirect callsite, callsite function type, and function type primitives provided by Reckon. (2) From all functions contained in the program, we analyze only the virtual functions which expect up to six parameters to be passed by the callsite. Next from all callsites, we filter out the ones which are not calling virtual functions and which provide more than six parameters to the calltarget. Check if the callsite is a void or non-void callsite. Check if each analyzed calltarget is a void or non-void target. (3) The policy does not rely on hierarchical meta-data. (4) A callsite matches a calltarget if it provides less or the same number of parameters as the calltarget expects. (5) In case the matching criteria holds, we count the total count one up for each found match.

Finally, these constraints are implemented as an LLVM compiler module pass performed during LTO. Note that even an analyst with restricted previous knowledge can model the constraints of a CFI policy by observing how other existing policies were implemented inside Reckon.

IV-C CFI Defense Analysis

Reckon performs for each implemented CFI defense a different analysis. Each defense analysis consists of one or more iterations through the program primitives which are relevant for the CFI defense currently being analyzed. Depending on the particularities of a defense, Reckon uses different previously collected program primitives. More specifically, class hierarchies, class sub-hierarchies, or function signatures located in the whole program or in certain class sub-hierarchy are individually analyzed. During a CFI-defense analysis, statistics are collected w.r.t. the number of allowed calltargets per callsite taking into account the previously modeled CFI-defense.

For example, for a certain CFI defense (e.g., TypeArmor’s CFI policy Bin types) it is required to determine a match between the number of provided parameters (up to six parameters) of each indirect callsite and all virtual functions present in the program (object inheritance is not taken into account) which could be the target (may consume up to six parameters) of such a callsite. In order to analyze this CFI defense and collect the statistics, Reckon visits all indirect callsites it previously detected in the program and all virtual functions located in all previously recuperated class hierarchies. Afterwards, each callsite is matched with potential calltargets (virtual functions). Finally, after all virtual callsites and virtual functions were visited, the generated information is presented to the analyst.

IV-D Implementation Details

We implemented Reckon as one link time optimization (LTO) pass by extending the Clang/LLVM (v.3.7.0) compiler [32] framework infrastructure. The implementation of Reckon is split between the Clang compiler front-end (part of the metadata is collected here), and one link-time pass, totaling around 4.2 KLOC. Reckon supports separate compilation by relying on the LTO mechanism built in LLVM [32]. By using Clang, Reckon collects front-end virtual tables and makes them available during LTO. Next, virtual table hierarchies are built which are used to model different CFI defenses. Other Reckon primitives such as function types are constructed during LTO. Finally, each of the analyzed CFI defense is separately modeled inside Reckon by using the previously collected primitives and aggregated data to impose the required defense constraints.

V Analyzing CFI Defenses with Reckon

In this section, we show how to map real-world CFI defenses into Reckon based on available primitives. Similarly to Newton [40], Reckon models the security provided by CRA defenses along two axes: (1) write constraints imposed by the defense, and (2) imposed target constraints. The main motivation for the usage of this modeling technique is that: (1) the majority of CFI techniques do not impose write constraints, with the exception of CFI runtime tools which adjust their analysis by using hardware features, and (2) it serves as a natural extension (i.e., it eases understanding) of existing work. Next, we will map the defenses presented in § II according to these constraints. In our work, we focus only on one class of defense at a time and we add more constraint types to the target constraint axis. As opposed to Newton [40], Reckon helps to derive static constraints imposed on the target program. This mapping allows to define textual descriptions of each CFI policy and reduces the task to a compiler-based counting problem allowing an analyst to determine which callsites and calltargets are protected and which are not.

V-A Deriving Constraints

Table I highlights the constraints imposed by each defense subclass. In our work, we do not consider runtime-based write constraining defenses (HCFI and CsCFI, see Newton [40] for more details), since these runtime constraints are hard to be assessed statically. Instead, Reckon models a comprehensive set of eight defense classes with no write constraints, which we discuss in detail in the next subsection.

V-A1 Constraint Subclasses

Reckon provides the following constraint subclasses. Note that the next three constraint classes (highlighted in bold italic font) were first presented by Newton [40], while the last five classes are presented for the first time in this work.

TypeArmor imposes callsite target constraints based on a function type policy. In particular, for each callsite only targets which fulfill the parameter count based policy are allowed during runtime.

IFCC/MCFI enforces similar constraints as TypeArmor, with the exception that the function type is computed at the source rather than at the binary level.

Safe IFCC/MCFI contains the same defenses as the IFCC/MCFI defense subclass, except that in this case, we distinguish a safe mode, where type information is less strict for compatibility reasons with real-world programs, this is discussed in the original IFCC paper [34].

VTV subclass enforces for each indirect callsite the whole subclass hierarchy Src sub-hierarchy which is precise but leaves wiggle room for the attacker and it enforces too many calltargets as noted in [31].

ShrinkWrap/IVT subclass can enforce a more precise class sub-hierarchy (Strict src types) than IFCC/MCFI. For each indirect callsite (object dispatch) a precise class hierarchy is computed.

vTint subclass operates at the binary level in order to find indirect callsites and virtual tables. This subclass is enforcing for all detected virtual tables (all vtables) all its entries for each callsite.

Marx/VCI subclass operates on binary to recuperate a quasi class hierarchy: (1) the class has no root node, and (2) the edges in the class hierarchy are not oriented.

vTrust subclass enforces matching function types for each indirect callsite. It follows a precise source code callsite-to-targets mapping (Strict src types) based on computing at all calltargets a hash composed of the number, types, and return type of each virtual function. Next, we use an example to show how the calltarget sets differ depending on the used CFI defense.

LABEL:vtrust_vs_cha_policy shows a simple C++ class hierarchy which will be used to show that based on the used CFI policy different functions are accessible after applying a certain policy. For example, under the vTrust CFI policy the indirect call, line seven in LABEL:vtrust_vs_cha_policy can target any of the four get() functions located in the Foo, Bar, Baz, and Bac since the function signatures match since its policy includes function names as well. For example, vTint allows all four get() functions and the set() function as targets, as it allows all entries located in all virtual tables detected in the program. Note that at the binary level vTint cannot distinguish between function name as the information vanishes through compilation. Further, under the class hierarchy based analysis (CHA) of IVT, Bar::get(), Bac::get(), Baz::get() and Bac::set() can be called, since this policy enforces all class sub-hierarchies in the protected program.

Shrinkwrap’s CHA policy allows only Bar::get() and Baz::get() to be called as this policy is aware of primary and secondary inheritance paths inside the program virtual table hierarchy. Note that this holds since Baz class is considered a primary type while the Bac class is a secondary type in this virtual table hierarchy. Further, both ShrinkWrap and IVT policies are based on the type of the object. As such, only some subtypes are allowed. vTrust, for example, relies on the base objects and is therefore less precise than CHA-based policies. IVT, for example, allows all subtypes. Note that with a larger class hierarchy vTrust and IVT policies would allow the same number of targets are allowed. In contrast, ShrinkWrap allows just a sub-part of the class sub-hierarchy (some subtypes).

Finally, these CFI policy based target set constrining examples highlight the fact that the CFI policies have different granularities w.r.t. constraining the calltarget set per callsite.

V-B Describing and Analyzing CFI Defenses

Figure 2 depicts the constraints of the defenses, presented in Table I. The constraints are grouped in two categories in ascending order indicated with two arrows on the $X$ axis according to their precision of determining precise target sets per callsite. The $X$ axis shows the write constraints imposed by each defense subclass, and the $Y$ axis shows the target constraints. Defenses that share both the same write and target constraints impose equivalent security restrictions, thus each ($X$ axis, $Y$ axis) pair depicted in Figure 2 represents an equivalence class.

Note that in this paper, we are interested in only static CFI defenses which do not impose any write constraints. We are aware that these defenses are thought to be accompanied by some type of write constraint but for the sake of simplicity, we abstract these away for now. As such, runtime CFI (black rectangle), re-randomization (yellow circle), pointer integrity (brown diamond), and information hiding (green triangle) depicted in Figure 2 are not taken into consideration as these were thoroughly analyzed by Newton [40]. Our objective is to focus on the details of the static CFI class in order to reveal novel insights of this widely used class of defense. marx:tool Reckon can compile a given program with DWARF [21] information. In this situation, the function name and location inside the program is back-traceable to the exact location in the source file. The same level of detail is possible for the associated callsite.

Important to observe is that all static CFI defenses impose no write constraints and as such it is recommendable to use these defenses with some type of write constraints which for example would impose that the virtual pointer used dur[34, 30]ing object dispatches cannot be overwritten to point to an illegitimate address inside the program. Further, the value of this pointer is determined during runtime. We further assume that there are no implementation specific vulnerabilities of these defenses and as such the equivalence classes hold. Further, our constraint-based classification abstracts away specific implementation details and ignores implementation specific differences across these defenses. For example, we consider the used primitives (e.g., class hierarchy) for enforcing the CFI policy to be ideal with no precision differences between binary and source code based tools. As such, we are able to generate lower bounds w.r.t. the legitimate calltarget set of these defenses and further, our approach is applicable to general gadget generation constraints across many different defenses.

Next, we show how to implement in Reckon the required constraints for the eight assessed defenses, by using the primitives specified in Section III-B. Specifically, we present in detail the constraints imposed at any indirect callsite depending on the target constraint.

Corrupting code pointers. The CFI defenses which do not impose any write constraints are allowing any memory to be corrupted, such as code pointers. This is presented in Figure 2 by abstracting the CFI constraints to a counting problem of legitimate calltargets per callsite. These defenses are located on the left hand side of Figure 2 depicted on the $X$ axis with (None). Note that in general, these type of constraints assume that the callsite is not corruptible since it is located in read-only memory, but since these constraints do not impose any specific code pointer corrupting defense these are regarded in this paper as not defending code pointer at all.

The particular constraint-based counts are obtained by computing for each constraint the target set counts with our Reckon tool. Next, Reckon compiles any given program in order to obtain the target set and performs counts according to the currently used constraint. Note that while in § V-A1, we provide the general description of how the constraint classes work, in this section, we describe how the target constraints work in detail by associating them to the Reckon primitives.

In the following, we will present eight static CFI defense classes modeled inside Reckon. These defenses are stemming from published research papers and are used to constrain forward edge program control flow transfers to point to only legitimate calltargets. Note that each CFI defense description is an idealized and very close to how the original CFI defense policy which was implemented in each tool. Finally, note that each modeled defense was previously thoroughly discussed with the original authors and only after the authors agreed with these descriptions we modeled them into Reckon. Next we give the formal definitions of each of the CFI defenses as these were modeled inside Reckon and the description of the performed analysis.

Notation. The used notation is as follows: $P$ represents the analyzed program, $Cs$ is the set of program indirect callsites (virtual and non-virtual), $Cs_{virt}$ is the set of program virtual callsites, $V$ is a virtual table hierarchy, $V_{sub}$ is a virtual table sub-hierarchy, $v_{t}$ is a virtual table, $v_{e}$ is a virtual table entry (virtual function), $vc_{s}$ is a virtual callsite, $nv_{f}$ is a non-virtual function, $v_{f}$ is a virtual function (virtual table entry), $C$ is a program class hierarchy, $C_{sub}$ is a program class sub-hierarchy, $c_{s}$ is a indirect callsite (object dispatch or indirect pointer based function call), $nt_{pcs}$ represents the number and type of parameters provided by a callsite, $nt_{pct}$ represents the number and type of parameters provided by a calltarget, $F$ set of all virtual and non-virtual functions contained in the program, $S$ is the set of function signatures, $M$ is the policy matching set of rules. Note that $M$ is determined by all rules defined by a CFI defense and represents, at the same time, the matching criteria for each policy. This means that Reckon increments the count of his analysis by one when such a match is found.

Bin Types. (TypeArmor) [12]

We formalize this policy $\psi$ as the tuple \big{\langle}Cs,F,V,M\big{\rangle} where the relations hold: (1) $V\subseteq F$, (2) $v_{e}\in V$, (3) $nv_{f}\in F$, (4) $c_{s}\in C$, and (5) $M\subseteq Cs\times V\times F$.

Reckon*’s Analysis.* For each indirect callsite $c_{s}$ (1) count the total number of virtual table entries $v_{e}$ which reside in each virtual table hierarchy $V$ contained in program $P$, and also, (2) count the number of non-virtual functions $nv_{f}$ residing in $F$, which need at most as many function parameters as provided by the callsite and up to six parameters. Further, if $F$ contains multiple distinct virtual table hierarchies (islands) then continue to count them too and take them also into consideration for a particular callsite. An island is a virtual table hierarchy which has no father child relation to another virtual table hierarchy contained in the program $P$.

Safe src types. (Safe IFCC) [34] We formalize this policy $\psi$ as the tuple \big{\langle}Cs,F,F_{virt}S,M\big{\rangle} where the relations hold: (1) $V\subseteq F$, (2) $v_{f}\in F_{virt}$, (3) $nv_{f}\in F$, (4) $nt_{pcs}\in S$, (5) $nt_{pct}\in S$, (6) $f_{rt}\in S$, (7) $c_{s}\in Cs$, and (8) $M\subseteq Cs\times F\times S$.

Reckon*’s Analysis.* For each indirect callsite $c_{s}$ count the number of virtual functions $v_{f}$ and non-virtual functions $nv_{f}$ located in the program $P$ for which the number and type of parameters required by the calltarget $nt_{p}ct$ matches with the number and type of parameters provided at the callsite $nt_{p}cs$. The function return type $f_{rt}$ of the matching function is not taken into consideration. All parameter pointer types are considered interchangeable, e.g., int* and void* pointers are considered interchangeable.

Src types. (IFCC/MCFI) [47] We formalize this policy $\psi$ as the tuple \big{\langle}Cs,F,F_{virt}S,M\big{\rangle} where the relations hold: (1) $V\subseteq F$, (2) $v_{f}\in F_{virt}$, (3) $nv_{f}\in F$, (4) $nt_{pcs}\in S$, (5) $nt_{pct}\in S$, (6) $f_{rt}\in S$, (7) $c_{s}\in Cs$, and (8) $M\subseteq Cs\times F\times S$.

Reckon*’s Analysis.* For each indirect callsite $c_{s}$ count the number of virtual functions and non-virtual functions located in the program $F$ for which the number and type of parameters required at the calltarget $nt_{pct}$ matches the number and type of arguments provided by the callsite $nt_{pcs}$. The return type of the matching function is ignored. Compared to Safe src types this policy distinguishes between different pointer types, this means that these are not interchangeable and that the function signatures are more strict. Neither the return value of the matching function nor the name of the function are taken into consideration.

Strict src types. (vTrust) [29] We formalize this policy $\psi$ as the tuple \big{\langle}Cs,V,F,F_{virt},S,M\big{\rangle} where the relations hold: (1) $V\subseteq F$, (2) $v_{f}\in F_{virt}$, (3) $ntf_{pcs}\in S$, (4) $f_{rt}\in S$, (5) $c_{s}\in Cs$, and (6) $M\subseteq Cs\times S\times F_{virt}\times V$.

Performed Analysis. For each indirect callsite $c_{s}$ compute the function signature of the function called at this particular callsite using the number of parameters, their types, and the name of the function $ntf_{pcs}$ (the literal name used in C/C++ without any class information attached). Match this function type identifier with each virtual function $v_{f}$ contained in each virtual table hierarchy $V$ of $P$. The name of the function is taken into consideration when building the hash but not the function return type $f_{rt}$ as this can be polymorphic. Note that we have a match when the signature of a function called by a callsite matches with the signature of a virtual function $v_{f}$.

All vtables. (vTint) [28] We formalize this policy $\psi$ as the tuple \big{\langle}P,Cs,F_{virt},V,M\big{\rangle} where the relations hold: (1) $V\subseteq F$, (2) $v_{e}\in V$, (3) $v_{f}\in F_{virt}$, (4) $c_{s}\in Cs$, and (5) $M\subseteq Cs\times V$.

Reckon*’s Analysis.* For each indirect callsite $cs$ count each virtual function $v_{f}$ corresponding to a virtual table entry $v_{e}$ contained in each virtual table present in the program $P$.

vTable hierarchy/island. (Marx) [27] We formalize this policy $\psi$ as the tuple \big{\langle}P,F_{virt},C,Cs,V,M\big{\rangle} where the relations hold: (1) $V\subseteq F$, (2) $v_{e}\in V$, (3) $v_{f}\in F_{virt}$, (4) $v_{t}\in V$, (5) $V\in C$, (6) $C\in P$, (7) $c_{s}\in Cs$, and (8) $M\subseteq Cs\times V\times C$.

Reckon*’s Analysis.* For each indirect callsite $c_{s}$ count each virtual function $v_{f}$ corresponding to each virtual table $v_{t}$ entry $v_{e}$ having the same index in the virtual table as the index determined at the callsite $c_{s}$ by Marx. Perform this matching for each virtual table $v_{t}$ where the index matches with the index determined at the callsite $c_{s}$ and which is located in the class hierarchy $C$ which contains the class type of the dispatched object. Note that abstract classes are not taken in consideration within this policy, this can be recognized though by virtual tables having pure virtual function entries.

Sub-hierarchy. (VTV) [34] We formalize this policy $\psi$ as the tuple \big{\langle}P,F_{virt},C,C_{sub},V,M\big{\rangle} where the relations hold: (1) $v_{t}\in V$, (2) $V\subseteq C$, (3) $C\subseteq P$, (4) $C_{sub}\in C$, (5) $v_{f}\in F_{virt}$, (6) $vc_{s}\in P$, and (7) $M\subseteq Cs_{virt}\times C_{sub}\times V\times F_{virt}$.

Reckon*’s Analysis.* For each virtual callsite $vc_{s}$ build the class sub-hierarchy $C_{sub}$ having as root node the base class (least derived class that the dispatched object can be of) of the dispatched object. From the classes located in the sub-hierarchy consider, for the currently analyzed callsite, each virtual table $v_{t}$. Further within this virtual tables $v_{t}$’s consider only the virtual function $v_{f}$ entries located at the offset used by the virtual object dispatch mechanism. Next count the number of virtual functions to which these entries point to.

Strict sub-hierarchy. (ShrinkWrap) [31] We formalize this policy $\psi$ as the tuple \big{\langle}P,F_{virt},C,V,V_{sub},M\big{\rangle} where the relations hold: (1) $V\subseteq C$, (2) $v_{e}\in V$, (3) $v_{f}\in F_{virt}$, (4) $v_{t}\in V$, (5) $V\subseteq C$, (6) $V_{sub}\subseteq V$, (7) $C\subseteq P$, (8) $c_{s}\in P$, and (9) $M\subseteq Cs_{virt}V\times V_{sub}\times F_{virt}$.

Reckon*’s Analysis.* For each virtual callsite $vc_{s}$ identify the virtual table $v_{t}$ type used. Take this virtual table $v_{t}$ from the base class $C$ of the dispatched object and build the virtual table $v_{t}$ sub-hierarchy $V_{sub}$ having this virtual table $v_{t}$ as root node. From the virtual tables in this $v_{t}$ sub-hierarchy find the virtual function $v_{f}$ entries located at the offset used by the virtual object dispatch mechanism for this particular callsite $c_{s}$. Next count each virtual function $v_{f}$, to which these virtual table entries $v_{e}$ point to. Finally, after Reckon computes for each callsite the total calltarget set count, as above described for each policy, it sums up all results for each callsite to generate several statistics.

VI Evaluation

In this Section, we show Reckon usefulness by addressing the following research questions (RQs): RQ1: What is the residual attack surface of NodeJS (we performed an use case) after eight state-of-the-art CFI policies are independently applied (§ VI-A)? RQ2: What score would each of the analyzed CFI defenses get (§ VI-B)? RQ3: How can Reckon be used to rank CFI policies based on the offered protection level (§ VI-C)? RQ4: What is the residual attack surface for several real-world analyzed programs (§ VI-D)? RQ5: How can Reckon be used to construct code reuse attacks? (§ VI-E)?

Test Programs. In our evaluation, we used the following real-world programs: Nginx [17] (Web server, usable also as: reverse proxy, load balancer, mail proxy and HTTP cache, v.1.13.7, C code), NodeJS [15] (cross-platform JavaScript run-time environment, v.8.9.1, C/C++ code), Lighttpd [16] (Web server optimized for speed-critical environments, v.1.4.48, C code), Httpd [18] (cross-platform Web server, v.2.4.29, C code), Redis [19] (in-memory database with in-memory key-value store, v.4.0.2, C code), Memcached [20] (general-purpose distributed memory caching system, v.1.5.3, C/C++ code), Apache Traffic Server [22] (modular, high-performance reverse proxy and forward proxy server, v.2.4.29, C/C++ code), and Chrome [23] (Google’s Web browser, v.33.01750.112, C/C++ code).

Experimental Setup. The experiments were performed on an Intel i5-3470 CPU with 8GB of RAM running on the Linux Mint 18.3 OS. All experiments were performed ten times to provide reliable values. If not otherwise stated, we modeled each of the eight CFI defenses inside Reckon according to the policy descriptions provided in Section V.

Reckon’s Metric. Let $ics_{i}$ be a particular indirect callsite in a program $P$, $ctr_{i}$ is the total number of legitimate calltargets for an $ics_{i}$ after hardening a program with a certain CFI policy. Then the CTR metric is: $CTR=\sum_{i=1}^{n}ctr_{i}$. Note that the lower the value of $CTR$ is for a given program, the more precise the CFI policy is. We used this metric to compute the residual attack surface after a CFI defense was applied.

VI-A Detailed Analysis of NodeJS

In this Section, we analyze the residual attack surface after each of the eight CFI policies was applied individually to NodeJS. Note that three out of the eight assessed CFI policies used in the following Tables are the same as used by Veen et al. [40] (we share the same names). For the other five CFI policies we use names which reflect their particularities. We selected NodeJS as this is a very popular real-world application and it contains both C and C++ code. As such, Reckon can collect results for the C and C++ related CFI polices.

Table II depicts the static target constraints for the NodeJS program under different static CFI calltarget constraining policies. Table II provides the minimal and maximum values of virtual calltargets which are available for a virtual callsite after one of the eight CFI policies is applied. MKSnapShot contains the Chrome V8 engine and is used as a shared library by NodeJS after compilation. We decided to add MKSnapshot in Table II as this component is strongly used by NodeJS and represents a source of potential calltargets. The NodeJS results were obtained after static linking of MKSnaphot.

The targets median entries in Table II (left hand side) indicate the median values obtained for independently applying one of the eight CFI policies to NodeJS. For both NodeJS and MKSnaphot, the best median number of residual targets is obtained using the following policies: (1) vTable hierarchy, (2) Sub-hierarchy, and (3) Strict sub-hierarchy. These results indicate that these three CFI policies provide the lowest attack surface while the highest attack surface is obtained for the Bin types policy, which allows the highest number of virtual and non-virtual targets.

The targets distribution in Table II (right hand side) shows the minimum, maximum and 90 percentile results for the same eight policies as before. While the minimum value is 0 the highest values for both NodeJS and MKSnapshot are obtained for the Bin types policy, while the lowest values are obtained for the following policies: (1) vTable hierarchy, (2) Sub-hierarchy, and (3) Strict sub-hierarchy. Further, the 90p results show that on the tail end of the distribution, a noticeable difference between the three previously mentioned policies exists. We can observe that for these critical callsites the Strict sub-hierarchy policy provide the least amount of residual targets and therefore the best protection against CRAs. Meanwhile, the 90p results for the Strict src type and vTable hiearchy policies indicate that the residual attack surface might still be sufficiently large for the attacker.

VI-B CFI Defenses Scores

Figure 3 depicts the scores obtained by each of the eight policies which were analyzed for the Chrome Web browser. We opted to depict the values for only the Chrome browser since this represents the largest (approx. 10 Mil. LOC) analyzed program. The numbers on the gray shaded bars represent the 90p values while the values on the black shaded bars represent the average values for the Chrome Web browser. These values can be observed in Table III on the last row from top to bottom for the Chrome browser as well. The optimal score is one and means that each callsite is allowed to target a single calltarget. This is the case only during runtime. The lower the bar is or the closer the value is to one the better the score is.

The best score w.r.t. the 90p and average values is obtained for the Strict sub-hiearchy which is the best CFI defense from the eight analyzed policies. Interestingly to note that the best function signature based policy Stric src types has a slightly worse score than the second based class based CFI defense (Sub-hierarchy). Finally, we note that these CFI-based forward edge policies are not optimal (provide values larger than one) and the desired goal is to have such policies which provide a one-to-one mapping as shadow stack based techniques.

VI-C Ranking of CFI Policies

In this Section, we normalize the results presented in RQ2 using the Baseline values, (i.e., the number of possible target functions), in order to be able to compare the assessed CFI policies against each other w.r.t. calltarget reduction. This allows to compare the analyzed CFI defenses on programs with different sizes and complexities which would be not possible otherwise.

Table IV depicts the average, standard deviation and 90th percentile results obtained after analyzing only virtual callsites. Unless stated otherwise, we use the $CTR$ metric introduced at the beginning of this section. For these callsites, all eight CFI policies can be assessed.

We calculated the average over the three C++ programs after normalization. By considering these aggregate average values, the eight policies can be ranked (from best (smallest aggregate average) to worst (highest aggregate average)) as follows: (1) Strict src types (0.15), (2) Strict sub-hierarchy (0.17), (3) Sub-hierarchy (0.17), (4) vTable hierarchy (0.53), (5) Src types (11.3), (6) Safe src types (11.66), (7) Bin types (55.1), and (8) All vTables (94.35).

From the class hierarchy-based policies Strict sub-hierarchy perform best in all three aggregate results (Avg, SD and 90p). In comparison, Strict sub-hierarchy performs better w.r.t. average and standard deviation but worse w.r.t. 90p. These results indicate that these two policies are the most restrictive, but a clear winner in all evaluated criteria cannot be determined.

Table V depicts (similarly to Table IV) normalized results with the difference that all indirect callsites (both virtual and pointer based) are analyzed. Thus, the Baseline values used for normalization include virtual and non-virtual targets. By taking into account the aggregate averages and the standard deviation of the three policies in Table V, we can rank the policies as follows (from best to worse): (1) Src types (Avg 5.3 and SD 5.17), (2) Safe src types (Avg 5.4 and SD 5.18), and (3) Bin types (Avg 60.3 and SD 34.39).

By considering the 90p values we conclude that for the most vulnerable 10% of callsites, Bin types only restricts the target set to 87.9% of the unprotected target set. These callsites essentially remain unprotected. Meanwhile, the Safe src type and Src type policies restrict to only around 12% of the unprotected target set.

VI-D Generalized Results

Table VI provides results for the three policies which can provide protection for both C and C++ programs. In contrast to Table III, all indirect calls are taken into account (including virtual calls). Therefore, the targets can be virtual or non-virtual. Intuitively, the residual attack surface grows with the size of the program. This can be observed by comparing the results for large (e.g., Chrome) with smaller (e.g., Memcached) programs.

Table III depicts the overall results obtained after applying the eight assessed CFI policies to virtual callsites only. The first four policies (italic font) cannot differentiate between virtual and non-virtual calltargets. Therefore, for these policies the baseline of possible calltargets includes all functions (both virtual and non-virtual). This is denoted with Baseline all func. Since the remaining four policies can only be applied to virtual callsites, they restrict the possible calltargets to only virtual functions. Thus, the baseline for these policies includes only virtual functions (Baseline virtual function). For a better comparison between the first and second categories of policies, we also calculated the target set when restricting the first four policies to only allow virtual callsites. For Bin types, Safe src types, Src types, and All vTables the results indicate that there is no protection offered. The three-class hierarchy-based policies perform best when considering the median and average results. In addition, the Strict src type policy performs surprisingly well, especially after restricting the target set to only virtual functions. Med: median.

VI-E Towards Automated CRAs Construction

In this Section, we show how Reckon is used to build an attack which bypasses a state-of-the-art CFI policy-based defense, namely VTV’s Sub-hierarchy Policy. This case study is architecture independent, since Reckon’s analysis is performed at the IR level during LTO time in LLVM. Note that LLVM IR code represents a higher level representation of machine code (metadata), thus our results can be applied to other architectures (e.g., ARM) as well. Our case study assumes an ideal implementation of VTV/IFCC. Breaking the ideal instrumentation shows that the defense can be bypassed in any implementation.

In this case study, we present the required components for a COOP attack by studying the original COOP attack against Mozilla’s Firefox web browser and demonstrate that such an attack is easier to perform when using Reckon. Thus, we discuss the importance of the CRA construction with Reckon at hand.

The original COOP attack presented by Schuster et al. [3] used: (1) a buffer overflow filled with six fake counterfeit objects by the attacker, (2) precise knowledge of the Firefox libxul.so layout, (3) where an COOP dispatcher gadget (ML-G) resides, and (4) several other useful gadgets in order to open an Unix shell.

In general terms, to pursue a CRA the attacker needs: (1) an exploitable memory corruption, (2) attack starting point (i.e., callsite) becomes corruptible due to (1), (3) program binary memory layout leak, (4) appropriate (usable and available) gadgets, (5) the possibility to read and write into memory, (6) the possibility to link gadgets and pass information from one to each other, and (7) the possibility to perform calls into the system stdlib or any other reach functionality library.

As demonstrated, the attacker first has to find an exploitable memory corruption (e.g., buffer overflow, etc.) and fill it with fake objects. Next, the attacker calls different gadgets (virtual functions) located in the program binary. As such, we assume that NodeJS contains an exploitable memory vulnerability (i.e., buffer overflow), and that the attacker is aware of the layout of the program binary. The attacker would then want to bend the control flow to only per callsite legitimate calltargets since he does not know if other defenses are in place. He would also want to avoid calling into other program class hierarchies. Therefore, he needs to know which calltargets are legitimate for all callsites in the main NodeJS binary.

Table VII depicts ten controllable callsites (in total Reckon found thousands of controllable callsies) for which the legitimate target set, depending on the used CFI policy, ranges from one to 31,305 calltargets. a:debugger.cpp:13 29:33, b:protocol.cpp:839:60, c:schema.cpp:133:33, d:handle_wrap.cc:127:3, e:cares_wrap.cc:642:5, f:node_platform.cc:25:5, g:node_http2 _core.h:417:5, h:tls_wrap.cc:771:10, i:protocol.cpp:839:60, and j:protocol.cpp:836:60.

For each calltarget, Reckon provides: file name, function name, start address and source code line number such that it can be easily traced back in the source code file. The calltargets (right hand side in Table VII in italic font) represent available calltargets for each of the eight assessed policies.

For our case study, we decided not to use the most restrictive CFI policy (i.e., Strict sub-hierarchy) as it enforces the same function in the virtual table sub-hierarchy. As such, only through inheritance, chances are that the implementation of the function may vary from the initial implementation. Thus, the number of useful gadgets would be low.

Consequently, we assume that the attacker knows that the NodeJS binary is protected with the Sub-hierarchy policy. The attacker ranks all callsites depending on the number of usable calltargets. By ranking the callsites w.r.t. their residual target set, the attacker wants to know the precise functions (calltargets) which are allowed for each callsite. Further, in order to perform the attack, he has to access the source code of the application. After searching through the source code, he finds several callsites where vector-based object dispatches are performed. The attacker next finds out that the detected calltarget set contains several usable gadgets. Note that for the COOP attack to be performable, the only hard constraint is that at least one usable ML-G gadget must exist in the program. This constraint was addressed by the attacker at the beginning of their source code search since they decided to only look for callsites which are part of an ML-G COOP gadget. As such, the attacker knows exactly which gadgets are available for each controllable callsite. As none of the static CFI policies impose write constraints by default (i.e., none) the attacker can overflow a buffer at a certain callsite with fake objects. Further, they start to call their gadgets one by one and passing information over the stack through scratch registers from one gadget to the next one. Note that their attack does not violate the CFI check in place at the selected object dispatch location since this is contained in a ML-G gadget. Further, he can deliberately avoid violating the original program control flow by calling into other program class hierarchies or other illegitimate calltargets as the original COOP attack does. Eventually, the attacker succeeds in opening an Unix shell.

Finally, this shows the usefulness of Reckon for an analyst, when searching for legitimate gadgets that available for each callsite after a certain CFI policy was applied. Thus, this helps to better tailor his attack w.r.t. the deployed CFI-based defense.

VII Discussion

Reckon*’s Metrics vs. other CFI Metrics.* Existing CFI-defense assessing metrics (e.g., AIR, fAIR and AIA) are designed to reason about CFI based defenses by providing average values obtained mostly by dividing the total number of control flow transfers to the total number of callistes for example. Also, when computing these values the ground truth numbers w.r.t. available calltargets, total number of calltargets, total number of unprotected calltargets are in most cases not provided. Thus, it is hard for any researcher which looks for reproducibility of these results to compare his results with other research results. Further, these metrics do not reason about other aspects of CFI-based defenses such as the forward check runtime overhead, return site target reduction, return site target runtime overhead and availability of gadgets at the end of the forward or backward edges. Thus the only benefit of these metrics are some average numbers which are hard to reproduce because of the above mentioned reasons. Finally, similar to Reckon these three metrics do not reason about gadget link-ability which would help to shed light in areas of optimal CFI-based protection schemes which then could be effectively used to protect applications without the need to enforce a strict CFI-policy on the whole program binary or libraries. More specifically, think as if the defender could harden a C++ based application such that all main loop gadgets (and alike) are made unusable for any attacker. This would remove a crucial building block for a COOP attack and thus the attacker would not have an important building block in his arsenal. Thus, the COOP attack would not be possible.

Reckon’s metrics are superior compared to AIR, fAIR and AIA metrics since these allow to quantify static CFI-based defenses w.r.t. to more dimensions. Further, Reckon allows to precisely reason about the forward edge based calltarget reduction by allowing to better compare the obtained results with ground truth numbers, by for example not averaging the results and providing the first framework which allows to comprehensively reason about a CFI defense. Finally, Reckon can be used to reason quantitatively and consistently about object-oriented programing (OOP) concepts which represent the building blocks for many CFI defenses.

VIII Limitations

Evaluation Results. We are aware that our evaluation results reflect the measurements obtained by applying Reckon on several real-world open source programs which may not generalizable. We therefore believe that more programs should be evaluated with the help of Reckon (the first CFI-based consistently reasoning framework for static CFI defenses). Thus, we urge other researchers to use Reckon’s CFI-based metrics when assessing their defense and comparing it with other existing tools. Finally, we envisage that Reckon could become the de-facto-standard benchmarking framework for assessing static CFI-based defenses.

IX Conclusion

We have presented Reckon, a CFI defense assessment and gadget search framework which allows for the first time to thoroughly compare CFI defenses against each other. We implemented Reckon, on top of the Clang/LLVM compiler framework which offers the possibility to precisely analyze real-world programs. By using Reckon, an analyst can drastically cut down the time needed to search for gadgets which are compatible with state-of-the-art CFI defenses contained in many real-world programs. Our experiment results indicate that most of the CFI defenses are too permissive. Further, if an attacker does not only rely on the program binary when searching for gadgets and has a tool such as Reckon at hand to analyze the source code of the vulnerable application, then many CFI defenses can be easily bypassed. Finally, in order to support further research we plan to release Reckon’s source code as open source upon paper acceptance.