Attribute Evaluation on Attack Trees with Incomplete Information

TL;DR

This paper introduces a generalized method for evaluating attack trees with incomplete or inconsistent data, allowing for more flexible and approximate security analysis using constraint programming.

Contribution

It extends existing attack tree evaluation methods by enabling initial values for non-leaf nodes, additional relations, and approximate solutions for inconsistencies.

Findings

Method effectively handles incomplete data scenarios.

Supports approximate solutions in case of inconsistent data.

Case study demonstrates practical applicability.

Abstract

Attack trees are considered a useful tool for security modelling because they support qualitative as well as quantitative analysis. The quantitative approach is based on values associated to each node in the tree, expressing, for instance, the minimal cost or probability of an attack. Current quantitative methods for attack trees allow the analyst to, based on an initial assignment of values to the leaf nodes, derive the values of the higher nodes in the tree. In practice, however, it shows to be very difficult to obtain reliable values for all leaf nodes. The main reasons are that data is only available for some of the nodes, that data is available for intermediate nodes rather than for the leaf nodes, or even that the available data is inconsistent. We address these problems by developing a generalisation of the standard bottom-up calculation method in three ways. First, we allow initial attributions of non-leaf nodes. Second, we admit additional relations between attack steps beyond those provided by the underlying attack tree semantics. Third, we support the calculation of an approximative solution in case of inconsistencies. We illustrate our method, which is based on constraint programming, by a comprehensive case study.

Figures

Tables

Table 1. Table 1: Historical data values identified for some attack tree nodes from the ATM Crime report.

Node		Prob.		Source
$\mathrm{𝑎𝑡𝑚}-\mathrm{𝑓𝑟𝑎𝑢𝑑}$		$0.0046$		ATM Crime Report 2015 (EAST)
$\mathrm{𝑐𝑎𝑟𝑑}-\mathrm{𝑠𝑘𝑖𝑚𝑚𝑖𝑛𝑔}$		$0.0172$		ATM Crime Report 2015 (EAST)
$\mathrm{𝑐𝑎𝑟𝑑}-\mathrm{𝑡𝑟𝑎𝑝𝑝𝑖𝑛𝑔}$		$0.0094$		ATM Crime Report 2015 (EAST)
$\mathrm{𝑐𝑎𝑠ℎ}-\mathrm{𝑡𝑟𝑎𝑝𝑝𝑖𝑛𝑔}$		$0.0150$		ATM Crime Report 2015 (EAST)
$\mathrm{𝑡𝑟𝑎𝑛𝑠}-\mathrm{𝑟𝑒𝑣𝑒𝑟𝑠𝑎𝑙}$		$0.0038$		ATM Crime Report 2015 (EAST)

Table 2. Table 2: Solutions of the ATM fraud attack tree decoration problem found by our tools

Node Label	Probability of attack success for tool and set of predicates
	CSP	CSP	SQP
	hard predicates +	hard predicates +	hard predicates +
	historical data	historical data +	historical data +
		domain knowledge	domain knowledge
$\mathrm{𝑎𝑡𝑚}-\mathrm{𝑓𝑟𝑎𝑢𝑑}$	$0.0046$	$0.0046$	$0.0046$
$\mathrm{𝑎𝑐𝑐𝑒𝑠𝑠}-\mathrm{𝑎𝑡𝑚}$	$0.0068$	$0.0093$	$0.0184$
$\mathrm{𝑏𝑟𝑒𝑎𝑘}-\mathrm{𝑖𝑛}$	$0.0039$	$0.0078$	$0.0092$
$\mathrm{𝑠𝑜𝑐𝑖𝑎𝑙}-\mathrm{𝑒𝑛𝑔𝑖𝑛𝑒𝑒𝑟}-\mathrm{𝑠𝑡𝑎𝑓𝑓}$	$0.0029$	$0.0015$	$0.0092$
$\mathrm{𝑒𝑥𝑒𝑐𝑢𝑡𝑒}-\mathrm{𝑎𝑡𝑡𝑎𝑐𝑘}$	$0.6683$	$0.4914$	$0.2493$
$\mathrm{𝑡𝑟𝑎𝑛𝑠}-\mathrm{𝑟𝑒𝑣𝑒𝑟𝑠𝑎𝑙}$	$0.0038$	$0.0038$	$0.0038$
$\mathrm{𝑔𝑒𝑡}-\mathrm{𝑐𝑟𝑒𝑑𝑒𝑛𝑡𝑖𝑎𝑙𝑠}$	$0.6620$	$0.4847$	$0.2324$
$\mathrm{𝑔𝑒𝑡}-\mathrm{𝑝𝑖𝑛}$	$0.875$	$0.9375$	$0.5780$
$\mathrm{𝑠ℎ𝑜𝑢𝑙𝑑𝑒𝑟}-\mathrm{𝑠𝑢𝑟𝑓}$	$0.5$	$0.75$	$0.3834$
$\mathrm{𝑖𝑛𝑠𝑡𝑎𝑙𝑙}-\mathrm{𝑐𝑎𝑚𝑒𝑟𝑎}$	$0.5$	$0.5$	$0.0973$
$\mathrm{𝑖𝑛𝑠𝑡𝑎𝑙𝑙}-\mathrm{𝑒𝑝𝑝}$	$0.5$	$0.5$	$0.0973$
$\mathrm{𝑔𝑒𝑡}-\mathrm{𝑐𝑎𝑟𝑑}$	$0.7566$	$0.5170$	$0.4021$
$\mathrm{𝑐𝑎𝑟𝑑}-\mathrm{𝑠𝑘𝑖𝑚𝑚𝑖𝑛𝑔}$	$0.0172$	$0.0172$	$0.0172$
$\mathrm{𝑖𝑛𝑠𝑡𝑎𝑙𝑙}-\mathrm{𝑠𝑘𝑖𝑚𝑚𝑒𝑟}$	$0.5$	$0.5$	$0.0973$
$\mathrm{𝑐𝑙𝑜𝑛𝑒}-\mathrm{𝑐𝑎𝑟𝑑}$	$0.0344$	$0.0344$	$0.1768$
$\mathrm{𝑡𝑎𝑘𝑒}-\mathrm{𝑐𝑎𝑟𝑑}-\mathrm{𝑝ℎ𝑦𝑠}$	$0.5047$	$0.0171$	$0.0172$
$\mathrm{𝑐𝑎𝑟𝑑}-\mathrm{𝑡𝑟𝑎𝑝𝑝𝑖𝑛𝑔}$	$0.0094$	$0.0094$	$0.0113$
$\mathrm{𝑠𝑡𝑒𝑎𝑙}-\mathrm{𝑐𝑎𝑟𝑑}$	$0.5$	$0.0078$	$0.0059$
$\mathrm{𝑠𝑜𝑐𝑖𝑎𝑙}-\mathrm{𝑒𝑛𝑔𝑖𝑛𝑒𝑒𝑟}-\mathrm{𝑜𝑤𝑛𝑒𝑟}$	$0.5$	$0.5$	$0.3677$
$\mathrm{𝑐𝑎𝑠ℎ}-\mathrm{𝑡𝑟𝑎𝑝𝑝𝑖𝑛𝑔}$	$0.015$	$0.0094$	$0.0131$

Table 3. Table 3: Weakened predicates found by the optimisation process

Soft Predicate	Weakened Predicate
$\mathrm{𝑐𝑎𝑟𝑑}-\mathrm{𝑡𝑟𝑎𝑝𝑝𝑖𝑛𝑔}$ $\text{leqslant}0.0094$	$\mathrm{𝑐𝑎𝑟𝑑}-\mathrm{𝑡𝑟𝑎𝑝𝑝𝑖𝑛𝑔}$ $\text{leqslant}0.0113$
$\mathrm{𝑐𝑎𝑠ℎ}-\mathrm{𝑡𝑟𝑎𝑝𝑝𝑖𝑛𝑔}$ $\text{leqslant}0.015$	$\mathrm{𝑐𝑎𝑠ℎ}-\mathrm{𝑡𝑟𝑎𝑝𝑝𝑖𝑛𝑔}$ $\text{leqslant}0.0131$
$\mathrm{𝑡𝑎𝑘𝑒}-\mathrm{𝑐𝑎𝑟𝑑}-\mathrm{𝑝ℎ𝑦𝑠}$ $\text{leqslant}$ $\mathrm{𝑐𝑎𝑟𝑑}-\mathrm{𝑠𝑘𝑖𝑚𝑚𝑖𝑛𝑔}$ + $0$	$\mathrm{𝑡𝑎𝑘𝑒}-\mathrm{𝑐𝑎𝑟𝑑}-\mathrm{𝑝ℎ𝑦𝑠}$ $\text{leqslant}$ $\mathrm{𝑐𝑎𝑟𝑑}-\mathrm{𝑠𝑘𝑖𝑚𝑚𝑖𝑛𝑔}$ + $0.0172$
$\mathrm{𝑐𝑎𝑠ℎ}-\mathrm{𝑡𝑟𝑎𝑝𝑝𝑖𝑛𝑔}$ $\text{leqslant}$ $\mathrm{𝑐𝑎𝑟𝑑}-\mathrm{𝑡𝑟𝑎𝑝𝑝𝑖𝑛𝑔}$ + $0$	$\mathrm{𝑐𝑎𝑠ℎ}-\mathrm{𝑡𝑟𝑎𝑝𝑝𝑖𝑛𝑔}$ $\text{leqslant}$ $\mathrm{𝑐𝑎𝑟𝑑}-\mathrm{𝑡𝑟𝑎𝑝𝑝𝑖𝑛𝑔}$ + $0.0018$

Equations

$$t::=\ell \mid \mathtt{OR}(t,\dots ,t{)}_{\ell }\mid \mathtt{AND}(t,\dots ,t{)}_{\ell }\text{.}$$

$$\mathtt{OR}(\mathtt{AND}(\mathrm{card},\mathrm{pin}{)}_{money-atm},hack-account{)}_{money-account}.$$

$$labels(t)=\{money-account,money-atm,hack-account\}\text{.}$$

$$\begin{array}[]{lll}p_{1}&:=&\operatorname{\mathit{money-account}}=\min(\operatorname{\mathit{money-atm}},\operatorname{\mathit{hack-account}})\\ p_{2}&:=&\operatorname{\mathit{money-account}}=5\\ p_{3}&:=&\operatorname{\mathit{hack-account}}=3\\ p_{4}&:=&\operatorname{\mathit{money-atm}}=7\\ \end{array}$$

$$p⟹p^{\prime }\text{ if and only if }$$

$$\forall \alpha \in {VAL}_{labels(t)\to D}:p⊢\alpha ⟹p^{\prime }⊢\alpha \text{.}$$

$$P^{\prime }⪯P⟹(\forall p^{\prime }\in P^{\prime }\exists p\in P:p⟹p^{\prime })\text{.}$$

$$P^{\prime }{⪯}_{M}P⟺(\forall p^{\prime }\in P^{\prime }\exists p\in P:p⟹p^{\prime })\text{.}$$

$$\begin{array}[]{lll}p\equiv\ell_{1}\leq a&\land&p^{\prime}\equiv\ell_{1}\leq a^{\prime}\text{,~{}or}\\ p\equiv\ell_{1}\geq a&\land&p^{\prime}\equiv\ell_{1}\geq a^{\prime}\text{,~{}or}\\ p\equiv\ell_{1}\leq\ell_{2}+a&\land&p^{\prime}\equiv\ell_{1}\leq\ell_{2}+a^{\prime}\text{.}\\ \end{array}$$

$$\begin{array}[]{cll}\{\ell_{1}\leq a\}\preceq_{\!M}\{\ell_{1}\leq a^{\prime}\}&\iff&a\geq a^{\prime}\\ \{\ell_{1}\geq a\}\preceq_{\!M}\{\ell_{1}\geq a^{\prime}\}&\iff&a\leq a^{\prime}\\ \{\ell_{1}\leq\ell_{2}+a\}\preceq_{\!M}\{\ell_{1}\leq\ell_{2}+a^{\prime}\}&\iff&a\geq a^{\prime}\\ \end{array}$$

$$d(S,S^{\prime})=\left\{\begin{array}[]{l l}\infty\text{,}&\text{if }\mathcal{F}(S,S^{\prime})=\emptyset\\ \min_{f\in\mathcal{F}(S,S^{\prime})}d_{f}(S,S^{\prime})\text{,}&\text{otherwise}\end{array}\right.$$

$$\begin{array}[]{ll}p_{\alpha}\equiv\ell\leq x_{i}&\mbox{if $p\equiv\ell\leq a$}\\ p_{\alpha}\equiv\ell\geq x_{i}&\mbox{if $p\equiv\ell\geq a$}\\ p_{\alpha}\equiv\ell\leq\ell^{\prime}+x_{i}&\mbox{if $p\equiv\ell\leq\ell^{\prime}+a$}\end{array}$$

$$\underset{\alpha ,x_1,\dots ,x_n}{\mathrm{minimize}}$$

$$\alpha \in [[H(t)\cup S]{]}_t.$$

Full text

K****eywords Attack trees  $\cdot$ Constraint programming  $\cdot$ Historical data  $\cdot$ Risk assessment

1 Introduction

Attack trees are a useful and intuitive graphical modeling language introduced by Bruce Schneier [46, 47] in 1999. Since then, it has enjoyed popularity in the security industry, as well as in the research community. Attack trees have been equipped with various semantics [40, 25, 23] and supported by tools [2, 21]. They have also been enhanced with various methods for quantitative analysis [27, 4, 33, 5, 43, 10, 12, 36, 37, 35], which allow determining for a given attack tree, for example, an organisation’s losses due to an attack, the probability that such an attack succeeds, or the cost of a successful attack [22].

The underlying assumption upon which all these quantification methods are based is similar to the popular divide and conquer paradigm, in which a problem is recursively broken down into smaller problems that are theoretically simpler to reason about and solve.

A quantification method for attack trees often reduces to the assignment of attribute values to basic attack steps (leaf nodes in the tree). Such assignments are used in a bottom-up propagation manner to determine the value at the root node, which is a quantification measure for the scenario expressed in the tree [27]. It is largely believed that it is relatively easy to assign a reliable attribute value to a basic attack step, which is precise and refined enough. Popular tools operating with attack trees, such as ADTool [28, 21] and SecurITree [2], work exactly under this premise.

In practice, the assumption that attribute values for more concrete attack steps are easier to obtain has proven incorrect. Indeed, most companies manage to obtain statistical data for abstract attacks, e.g. frequency of skimming attacks, while they might struggle to come up with similar data for more refined attacks, e.g. frequency of stereo skimming attacks based on audio technology. For security consultants, it might be feasible to obtain reliable estimations for (at least some) abstract attacks in relevant domains, but precise historical data for low-level attack steps might be out of reach. Thus, we observe that there is a tension between the limited availability of data and the requirement to provide data values for all leaves in an attack tree before proceeding with a quantification method.

Today, existing quantitative approaches for attack trees cannot handle values of intermediate nodes in the tree that may become available from historical data. Moreover, they do not support the use of additional constraints over nodes in the tree, which are obtained from external sources of information rather than from the attack tree model itself. For example, the analysts may be confident that card skimming attacks are more frequent than physical attacks on card holders. Such a relation cannot be captured in an attack tree model, because it is not a hierarchical relation, hence it is ignored in current quantitative approaches for attack trees.

There is clearly a need for novel computation methods on attack trees that account for available historical data and domain-specific knowledge. In this paper, we formulate a general attack-tree decoration problem that treats assignment of values to tree nodes as a problem of finding a set of data values satisfying a set of predicates. These predicates arise from the attack tree structure and the target attribute to be computed (i.e. semantics) and from the attainable historical values and domain knowledge (i.e. available data). Our methodology to solve the attack-tree decoration problem accounts for scenarios in which the set of predicates cannot be jointly satisfied, due to inconsistencies or possible noise in the data.

Contributions. In this work

• •

We transform an attack tree semantics together with an attribute interpretation into a constraint satisfaction problem (Section 3). If the attack tree semantics is consistent with the attribute interpretation, this allows us to determine appropriate attribute values for all nodes in the tree.

• •

Because confidence in the available historical data and domain-specific knowledge may vary, we provide a methodology to deal with inconsistencies (Section 4). The usefulness of our approach is that any consistent valuation is better than no valuation, as it will enable the follow up process of using the attack tree for what-if analysis. The standard bottom-up approach would result in absence of any valuation until all leaf node values can be assigned.

• •

We introduce two concrete approaches to deal with inconsistencies (Section 5). The first one determines the smallest subset of constraints that makes the decoration problem inconsistent, which is useful to find contradictory or wrong assumptions. The second one is suitable for constraints that are expressed in the form of inequalities. In this approach constraints are regarded consistent and an optimal decoration is always found. The proposed methodology has been implemented as proof-of-concept software tools111Code available at https://github.com/vilena/at-decorator.

• •

We validate our methodology and the implementations through a comprehensive case study on the security of Automatic Teller Machines (Sections 6-7).

2 Related Work

Research articles on quantitative security analysis with attack trees in all their flavors (attack-defense trees, defense trees, etc. [30]) often focus on providing extensions to attack trees enabling more complex scenarios [31, 5, 26, 19, 3] and defining metrics for evaluating scenarios captured as attack trees. Various metrics have been considered in the literature, for instance, the probability/likelihood of an attack [7, 35], expected time until a successful attack [7], attacker’s utility [34, 12, 36, 37, 35], return on security investment [10], or assessment of risks [20, 42]. Bagnato et al. [7] present a list of metrics found in security literature that can be computed on attack trees. Yet, all these approaches assume that the data values to perform quantitative analysis of system security are readily available. Indeed, to the best of our knowledge, no methodologies have been developed for integrating historical data and domain-specific knowledge in quantitative analysis of attack trees. At the same time, even the inventor of attack trees Bruce Schneier has acknowledged the painstaking work for data collection that is a prerequisite for quantitative analysis on the trees [47, Chap. 21].

Benini and Sicari [9] have proposed a framework for attack tree-based security risk assessment. The approach relies on identification of security vulnerabilities, that are placed in the leaves of an attack tree. Quantitative parameters of the vulnerabilities, such as exploitability and damage potential, allow to estimate security risks to a system. In [9], the exploitability parameters are initially evaluated based on the CVSS scores222Common Vulnerability Scoring System https://www.first.org/cvss of the respective vulnerabilities, and then they are adjusted based on the expert judgement about the system context and mutual effect of vulnerabilities on each other expressed in a vulnerability dependency graph. While this methodology offers more precise quantitative risk assessment with attack trees, it assumes that the attack tree is constructed in a bottom-up manner. All system vulnerabilities have to be identified using a suitable technology, and accommodated in an attack tree. In complex environments it will likely be impractical to apply the bottom-up approach due to the huge amount of potential vulnerability combinations that can be exploited in various attacks. Indeed, in practice attack trees are typically designed in a top-down manner, when the analyst starts by conjecturing the main attacker’s goal and iteratively breaks it down into smaller subgoals [40, 46, 17, 47].

Recently, de Bijl [15] studied the use of historical data values to obtain attribute values for attack tree nodes. He proposed several heuristics to deal with missing data values, including the standard bottom-up algorithm to infer parent node values, the reuse of values for recurring nodes, and the use of various data sources to estimate certain attributes. For example, the paper refers to distance to the police station as a hidden variable influencing probability of attack. Yet, [15] does not define a precise methodology to perform computations on attack trees with missing leaf node values.

Quantitative analysis of fault trees. Fault trees are close relatives of attack trees that are widely used in the reliability domain. There exists a large body of literature dedicated to quantitative analysis of fault trees. Yet, the standard bottom-up approach in attack trees is not the standard approach in fault trees, where min-cut set analysis and translation into more intricate models are common [44].

Fuzzy fault trees address evaluation of fault trees under uncertainty [38], when failure statistics are not fully available. The main difference is that fuzzy fault trees have been developed to serve the needs of the reliability community and fault tree application methods (fuzzy probability functions, error propagation estimates, etc.), while the security community and attack tree application methods have different needs (bottom-up computation for a large variety of attributes). Therefore, solutions designed for fault trees do not fully address the problems in the attack tree space.

Data issues in quantitative risk assessment. Attack trees are typically used for threat modeling and security risk assessment [48]. Thus, it is necessary to evaluate the data availability perspective also in the more general context of security risk assessment. Indeed, the general question of data validity in quantitative security risk assessment (QSRA for short) and the reliability of QSRA results in presence of uncertainty in data values has been raised by many practitioners and researchers [50].

QSRA enables decision making based on quantitative estimations of some relevant variables (e.g. probability of an event, cost, time, vulnerability, etc.). These quantitative estimations are typically aggregated in a model that can then be utilised by a decision maker [50]. Many studies, books on security, and industry reports have acknowledged that the quality of quantitative risk analysis, and, correspondingly, the decisions made based on it, heavily depends on the quality of data used [50, 24, 47, 8]. Notably, it has been established that probabilities of particular loss events and costs associated to security spending can be hard to obtain from historical data [24, 41, 6, 11, 1]. This body of knowledge serves as evidence of inherent difficulty to obtain meaningful estimates for probability and cost of detailed attack steps, i.e., values for leaf nodes in attack trees.

Nevertheless, it has been acknowledged that, for instance, for insurance companies it might be feasible to get meaningful data, because they have access to an entire population, i.e. they have good statistics [41]. It has also been demonstrated, for example, that breach statistics can be used to predict future breaches in different segments [45], and that statistics pertinent to different user profiles can be applied to estimate success rates of intrusions [14].

Furthermore, for security assessment, it has been long established that external data sources, such as threat level indicators (e.g. malware numbers) can be helpful to update quantitative risk assessment models [11]. Therefore, enabling better usage of available historical data, which may not directly correspond to information about low-level attack events (leaf nodes), will be a valuable enhancement for quantitative analysis of attack trees. From this review of the relevant scientific literature, we can conclude that there is a strong need for an approach to perform quantitative analysis on attack trees in case the analyst cannot confidently assign values to all leaf nodes. Furthermore, this approach needs to integrate available historical data that can come in form of values for some abstract attacks (intermediate nodes) or constraints (equalities and inequalities) on combinations of attack tree node values. In the remainder of this paper, we propose such an approach.

3 Attack-Tree Decoration

In this section we give, to the best of our knowledge, the first formulation of the attack-tree decoration problem as a constraint satisfaction problem. We start by introducing the necessary attack tree basics. The interested reader can find more details about the attack tree formalism in the paper by Mauw and Oostdijk [40].

3.1 Attack Trees

In an attack tree the main goal of the attacker is captured by the root node. This goal is then iteratively refined into subgoals, represented by the children of the root node. Leaf nodes in an attack tree are called atomic subgoals, as they are not refined any further. Non-leaf nodes, instead, can be of two types: disjunctive ($\mathtt{OR}$) or conjunctive ($\mathtt{AND}$). A conjunctive refinement expresses that all subgoals must to be achieved in order to succeed on the main goal, while in a disjunctive refinement the achievement of a single subgoal is already enough.

Example 1**.**

Consider the simple attack tree in Figure 1. The root node of this tree represents the main goal of the attack: to steal money from a bank account. This goal is disjunctively refined into two alternative sub-attacks: the attacker may try to get money from an automated teller machine (ATM), or they might attempt to hack the online bank account system. The sub-goal that explores getting money at an ATM is further conjunctively refined into two complementary activities: the attacker must steal the credit card of the victim and they also needs to obtain the PIN code by shoulder-surfing. Note that a conjunctive refinement is denoted graphically with an arc spanning the child nodes.

Definition 1** (Attack tree).**

Given a set of labels $\mathcal{L}$, an attack tree (ATree) is constructed according to the following grammar (for $\ell\in\mathcal{L}$):

[TABLE]

Our grammar above slightly differs from the grammar used in other notations to represent attack trees [40, 29], as we require every node in the tree to be annotated with a label $\ell$. The reason for this is that, as opposed to standard attack tree semantics that focus on the leaf nodes, we render every node in the tree equally important.

To provide a definition of our running example we will use shorter labels than those in Figure 1. The actual mapping between labels should become clear through a quick visual inspection.

[TABLE]

We say that an attack tree has unique labels if it does not contain two distinct nodes with the same label. We use $\mathbb{T}$ to denote the universe of attack trees. We also use the auxiliary functions $\mathit{root}\colon\mathbb{T}\rightarrow\mathcal{L}$ and $\mathit{labels}\colon\mathbb{T}\rightarrow\mathcal{P}(\mathcal{L})$ to obtain, respectively, the root node’s label and all labels of a given tree. Formally,

• •

$\mathit{root}(t)=\ell\iff t\equiv\ell\vee t\equiv\mathtt{OR}(t_{1},\ldots,t_{n})_{\ell}\vee t\equiv\mathtt{AND}(t_{1},\ldots,t_{n})_{\ell}$ for some $t_{1},\ldots,t_{n}\in\mathbb{T}$

• •

$\mathit{labels}(t)=\{\ell\}$ if $t\equiv\ell$, otherwise $\mathit{labels}(t)=\{\ell\}\cup\mathit{labels}(t_{1})\cup\dots\cup\mathit{labels}(t_{n})$ when $t\equiv\mathtt{OR}(t_{1},\ldots,t_{n})_{\ell}\vee t\equiv\mathtt{AND}(t_{1},\ldots,t_{n})_{\ell}$ for some $t_{1},\ldots,t_{n}\in\mathbb{T}$

For example, given the tree from Fig. 1, we have that $\mathit{root}(\mathtt{AND}(\operatorname{\mathit{card}},\operatorname{\mathit{pin}})_{\operatorname{\mathit{money-atm}}})=\operatorname{\mathit{money-atm}}$ and $\mathit{labels}(\mathtt{AND}(\operatorname{\mathit{card}},\operatorname{\mathit{pin}})_{\operatorname{\mathit{money-atm}}})=\{\operatorname{\mathit{card}},\operatorname{\mathit{pin}},\operatorname{\mathit{money-atm}}\}$.

3.2 The Attack-Tree Decoration Problem

We proceed by formulating the attack-tree decoration problem as a constraint satisfaction problem. Intuitively, we map an attack tree to a set of boolean expressions whose variables are drawn from the set of labels of the tree. Such a set of boolean expressions, defined over a given domain, can be seen as a constraint satisfaction problem whose solutions correspond to solutions of the attack-tree decoration problem. The remainder of this section is dedicated to formalising this intuition.

Decorating an attack tree is a process whereby nodes in the tree are assigned with values. Given an attack tree $t$, we use a total function $\alpha\colon\mathit{labels}(t)\rightarrow D$ from labels of the tree to values in a domain $D$ to represent the decoration process, and $\mathit{VAL}_{\mathit{labels}(t)\to D}$ to denote the universe of such functions. To that effect, we often refer to labels as variables and to $\alpha$ as a valuation. The co-domain $D$ of a valuation is determined by the attribute of the tree under evaluation. For example, minimum time of a successful attack uses the natural number domain $\mathbb{N}$ to express discrete time, while required attacker skill to succeed typically uses a discrete and categorical domain, such as $\{\textsf{low},\textsf{medium},\textsf{high}\}$.

Definition 2** (Attribute semantics).**

Given an attack tree $t$ and a domain $D$, an attribute semantics is a set of valuations with domain $\mathit{labels}(t)$ and co-domain $D$.

A semantics provides an attribute with the set of valuations that the attribute regards as valid in a given tree. Because defining an attribute semantics by exhaustive enumeration of its valuations might be cumbersome, we consider in this article attributes whose semantics can be derived from a constraint satisfaction problem.

An attribute constraint is defined as a boolean expression over the set of labels of a tree. To that effect, when we use labels in expressions we will consider them as variables over a given domain $D$. For example, if the attribute minimum time taken by an attack is being computed over an attack tree of the form $t\equiv\mathtt{OR}(t_{1},\ldots,t_{k})_{\ell}$, it is typically required that $\ell=\min(\mathit{root}(t_{1}),\ldots,\mathit{root}(t_{n}))$ [31]. The intuition for such constraint is that, because $\ell$ is disjunctively refined, the minimum time needed by an attacker to meet the goal $\ell$ is considered to be the least time required by any of $\ell$’s children.

We use predicates as short-hand notations for boolean expressions. For example, $\textsf{min-time}(\ell,\ell_{1},\cdots,\ell_{n})$ can be used to denote the boolean expression $\ell=\min(\ell_{1},\ldots,\ell_{n})$. We say that a predicate $p(\ell_{1},\ldots,\ell_{n})$ is valid under interpretation $\alpha$, denoted $p(\ell_{1},\ldots,\ell_{n})\vdash\alpha$, if $p(\alpha(\ell_{1}),\ldots,\alpha(\ell_{n}))$ evaluates to true. Likewise, a set of predicates $A$ is said to be valid under $\alpha$, denoted $A\vdash\alpha$, if all predicates in $A$ are valid under $\alpha$. When it does not lead to confusion, we will often refer to a predicate $p(\ell_{1},\ldots,\ell_{n})$ as $p$.

Definition 3** **(Attribute

constraint-set).

Given an attack tree $t$ and a domain $D$, an attribute constraint-set is a set of predicates $\{p_{1},\ldots,p_{n}\}$ over $\mathit{labels}(t)$ whose variables range over $D$. Its semantics is defined by $[\![\{p_{1},\ldots,p_{n}\}]\!]_{t}=\{\alpha\in\mathit{VAL}_{\mathit{labels}(t)\to D}\mid\{p_{1},\ldots,p_{n}\}\vdash\alpha\}$.

There exist in literature various ways to relate the value of a parent node in an attack tree to the values at its children [31], of which the bottom-up approach is the most common one [40, 29]. This bottom-up approach starts from an assignment of concrete values to the leaf nodes of the tree and uses two functions (one for disjunctive refinement and one for conjunctive refinement) to recursively calculate the value of a parent node from the values of its children. We will next define how an attribute constraint-set can be recursively derived from two unranked aggregation operators associated with a bottom-up approach. The actual values of the leaf nodes will have to be defined by the analyst through additional constraints.

Definition 4** **(Bottom-up attribute

constraint-set).

Let $t$ be an attack tree, and $\vee$ and $\wedge$ two unranked function symbols (symbols without fixed arity) with domain $D$. We use $\check{p}(\ell_{1},\ldots,\ell_{n+1})$ to denote the boolean expression $\ell_{1}=\vee(\ell_{2},\ldots,\ell_{n+1})$. Similarly, the predicate $\hat{p}(\ell_{1},\ldots,\ell_{n+1})$ denotes the boolean expression $\ell_{1}=\wedge(\ell_{2},\ldots,\ell_{n+1})$. The bottom-up attribute constraint-set $P(t)$ of $t$ is recursively computed as follows:

• •

If $t\equiv\ell$ for some label $\ell$, then $P(t)=\emptyset$.

• •

If $t\equiv\mathtt{OR}(t_{1},\ldots,t_{n})_{\ell}$ with $\mathit{root}(t_{i})=\ell_{i}$ for $i\in\{1,\ldots,n\}$, then $P(t)=P(t_{1})\cup\cdots\cup P(t_{n})\cup\{\check{p}(\ell,\ell_{1},\ldots,\ell_{n})\}$;

• •

If $t\equiv\mathtt{AND}(t_{1},\ldots,t_{n})_{\ell}$ with $\mathit{root}(t_{i})=\ell_{i}$ for $i\in\{1,\ldots,n\}$, then $P(t)=P(t_{1})\cup\cdots\cup P(t_{n})\cup\{\hat{p}(\ell,\ell_{1},\ldots,\ell_{n}\})$.

Definition 4 is based on the standard bottom-up approach [40, 29] for attack trees where child nodes are aggregated together based on two functions: $\wedge$ for children of a conjunctive refinement and $\vee$ for children of a disjunctive refinement. In literature there exist concrete definitions of $\wedge$ and $\vee$ for various attributes. For example, when computing probability of success it is usually considered that $\wedge=\times$ and $\vee=+$, for cost $\wedge=+$ and $\vee=\min$, and for minimum time $\wedge=\max$ and $\vee=\min$.

Definition 5** **(The attack-tree decoration

problem).

Given an attack tree $t$ and an attribute constraint-set $\{p_{1},\ldots,p_{n}\}$ for $t$, the attack-tree decoration problem consists in finding a valuation in $[\![\{p_{1},\ldots,p_{n}\}]\!]_{t}$.

The attack-tree decoration problem corresponds to the well-known Constraint Satisfaction Problem (CSP) [49], where a solution is a valuation that satisfies a set of constraints. Finding a solution or even deciding whether there exists a solution for CSP is a well-known and complex computational problem.

We say that the attack-tree decoration problem is:

• •

Determined: If the cardinality of $[\![\{p_{1},\ldots,p_{n}\}]\!]_{t}$ is one, i.e. there exists a single valid valuation only.

• •

Inconsistent: If $[\![\{p_{1},\ldots,p_{n}\}]\!]_{t}=\emptyset$, i.e. there does not exist a valid valuation.

• •

Undetermined: If the cardinality of $[\![\{p_{1},\ldots,p_{n}\}]\!]_{t}$ is larger than one, i.e. the problem is neither inconsistent nor determined.

We illustrate these concepts with the following example that utilises a subtree from our running example. Consider the tree $t$ depicted in Figure 2a whose set of labels is

[TABLE]

Further, we consider subsets of the following set of constraints:

[TABLE]

Predicate $p_{1}$ follows from the standard interpretation of minimum attack time in an attack tree [27], where $\wedge=\max$ and $\vee=\min$ defined over the natural numbers $\mathbb{N}$. This leads to the bottom-up attribute constraint-set $\{p_{1}\}$. The attack-tree decoration problem with this attribute constraint-set is clearly undetermined given that, for example, the valuations $\{\operatorname{\mathit{money-account}}\mapsto 3,\operatorname{\mathit{money-atm}}\mapsto 3,\operatorname{\mathit{hack-account}}\mapsto 5\}$ and $\{\operatorname{\mathit{money-account}}\mapsto 3,\operatorname{\mathit{money-atm}}\mapsto 3,\operatorname{\mathit{hack-account}}\mapsto 4\}$ both satisfy $p_{1}$.

Now, consider predicates $p_{2}$, $p_{3}$ and $p_{4}$. This type of boolean expressions represent variable assignments. We observe that the attribute constraint-set $\{p_{1},p_{2},p_{3}\}$ leads to an inconsistent decoration problem (see Figure 2b), while the decoration problem defined by $\{p_{1},p_{2},p_{4}\}$ is determined as there exists a unique valuation satisfying all three predicates, namely $\{\operatorname{\mathit{money-account}}\mapsto 5,\operatorname{\mathit{money-atm}}\mapsto 7,\operatorname{\mathit{hack-account}}\mapsto 5\}$ (see Figure 2c). Finally, we remark that the attribute constraint-set $\{p_{1},p_{3},p_{4}\}$ also leads to a decoration problem that is determined. Moreover, it corresponds to the standard bottom-up calculation in attack trees.

This last example illustrates the general observation that, given an assignment of values to the leafs of an attack tree and a bottom-up attribute constraint-set (Def. 4), the attack-tree decoration problem is determined. This is formalized in the following proposition, which can be easily proved by induction on the structure of the tree.

Proposition 1**.**

Let $t$ be an attack tree with unique labels, let $L=\{l_{1},\ldots,l_{n}\}$ be the set of labels of its leaf nodes and let $D$ be a domain. Let $P_{L}=\{l_{1}=v_{1},\ldots,l_{n}=v_{n}\}$ be a set of constraints assigning values $v_{1},\ldots,v_{n}\in D$ to the leaf nodes and let $P(t)$ be the bottom-up attribute constraint-set of $t$. Then the attack-tree decoration problem for $t$ and constraint-set $P_{L}\cup P(t)$ is determined.

4 A Methodology for Attack-Tree Decoration

As indicated above, our approach extends the rather rigid bottom-up way in which attack trees are currently decorated. Our methodology consists of two main steps that complement each other: (1) generation of the attribute constraint-set and (2) analysis of valid valuations. The former boils down to the definition of predicates over the set of labels of a tree. We make a distinction between two types of predicates: hard predicates and soft predicates.

4.1 Hard Predicates

Hard predicates are derived from the attack tree refinement structure rather than from knowledge databases or an expert’s opinion. This choice establishes that all predicates derived from the attack tree structure should be satisfied, as otherwise the attribute semantics and the tree contradict each other. The term hard stems from the notion of hard and soft constraints in satisfaction problems. Soft constraints represent desirable properties, while hard constraints are a must.

In this article, we consider hard predicates those contained in the bottom-up attribute constraint-set of the tree (see Def. 4). This is a conservative choice that allows us to extend existing bottom-up quantification methods based on the refinement relation of the tree [40, 29]. In fact, it follows from Prop. 1 that, if all labels in a tree are unique, then the resulting attack-tree decoration problem based on this bottom-up attribute constraint-set is either undetermined or determined. We remark, nonetheless, that our methodology can also be used to model other computational approaches such as the Bayesian reasoning proposed by Kordy, Pouly, and Schweitzer [32]. It is ultimately the analyst who decides what constitutes a set of hard predicates, although we require the analyst to come up with hard predicates that are satisfiable; as we do in this article.

4.2 Soft Predicates

Statistical data and constraints extracted from industry-relevant knowledge-bases and experts are too valuable to ignore. And our methodology treats them as first-class citizens. As usual, we encode this information in predicates. For example, assume that comprehensive empirical data indicates that the probability of a bank account being hacked is less than $0.01$. The semantics of such attribute in our running example tree can be defined by a set containing the predicate $\texttt{hack-prob}(\operatorname{\mathit{hack-account}}):=\operatorname{\mathit{hack-account}}\leq 0.01$.

In our methodology, predicates obtained from experts and knowledge-bases are regarded as soft. The reason is that, when it comes to opinion and empirical data, inconsistencies are common. Hence we do allow these predicates to be violated up to some extent. For example, consider that for a particular attack tree we obtain that the probability that an account is hacked is $0.02$. Although such an outcome violates the predicate $\texttt{hack-prob}(\operatorname{\mathit{hack-account}})$, one may find it acceptable and not far from the considered empirical data.

4.3 Analysis of Attribute Semantics with Hard and Soft Predicates

Given an attack tree $t$ and attribute constraint-set $\{p_{1},\ldots,p_{n}\}$ over labels of $t$ and domain $D$, we use $H(t)$ and $S(t)$ to denote the partition of $\{p_{1},\ldots,p_{n}\}$ into hard and soft predicates, respectively. As described in the previous section, we analyse an attribute constraint-set by looking at solutions of the corresponding constraint satisfaction problem. Formally, given an attribute constraint-set $H(t)\cup S(t)$, we aim at finding a valuation $\alpha\in\mathit{VAL}_{\mathit{labels}(t)\to D}$ such that $H(t)\cup S(t)\vdash\alpha$. However, such formulation makes no distinction between hard and soft predicates, which is a feature we regard important in our methodology. For example, it may be the case that no valuation $\alpha$ satisfying $H(t)\cup S(t)\vdash\alpha$ exists, while we can still find $\alpha^{\prime}\in\mathit{VAL}_{\mathit{labels}(t)\to D}$ such that $H(t)\vdash\alpha^{\prime}$. Note that, although the constraint-set $H(t)$ is an oversimplification of the original attribute constraint-set with all soft constraints being removed, $\alpha^{\prime}$ satisfies all hard constraints and thus may be worth considering.

In our methodology, when the original attack-tree decoration problem has no solution we propose to solve a weaker version: the relaxed attack-tree decoration problem. This new problem allows soft predicates to be weakened, which consists in replacing any soft predicate $p\in S(t)$ by a predicate $p^{\prime}$ that logically follows from $p$. We define this type of entailment on predicates over an attack tree $t$ by:

[TABLE]

Using this notation, we can define the notion of a weakening relation on sets of predicates.

Definition 6** (Weakening relation).**

Let $\preceq$ be a partial order on sets of predicates. Then we say that $\preceq$ is a weakening relation if and only if for all sets of predicates $P$ and $P^{\prime}$ it holds that

[TABLE]

If $P^{\prime}\preceq P$, we say that $P^{\prime}$ is a weakening of $P$ under the weakening relation $\preceq$. We provide three examples of weakening relations.

Set equality ($=$), which is the trivial weakening relation. 2. 2.

Set inclusion ($\subseteq$), which allows one to weaken a set of predicates by deleting one or more of its elements. 3. 3.

The maximal weakening relation ($\preceq_{\!M}$), which is defined by

[TABLE]

The proofs that these are indeed weakening relations and that $\preceq_{\!M}$ is maximal are straightforward.

Using this notion of a weakening relation we reformulate the attack-tree decoration problem as an optimisation problem in the following way.

Definition 7** (The relaxed attack-tree decoration problem).**

Let $t$ be an attack tree and $H(t)\cup S(t)$ an attribute constraint-set over $\mathit{labels}(t)$ and domain $D$, where $H(t)$ and $S(t)$ are hard and soft predicates, respectively. Let $\preceq$ be a weakening relation. The relaxed attack-tree decoration problem consists of two stages:

Finding a set of predicates $S$ over $\mathit{labels}(t)$ and domain $D$ such that:

• •

$S\preceq S(t)$,

• •

$[\![H(t)\cup S]\!]_{t}\neq\emptyset$, and

• •

$\forall S^{\prime}\colon S\preceq S^{\prime}\preceq S(t)\implies([\![H(t)\cup S^{\prime}]\!]_{t}=\emptyset\vee S^{\prime}\preceq S)$. 2. 2.

Solving the attack tree decoration problem with constraint-set $H(t)\cup S$.

A solution is a pair $(S,\alpha)$, such that $\alpha\in[\![H(t)\cup S]\!]_{t}$.

The choice of the weakening relation is relevant in an instantiation of the relaxed attack tree decoration problem, as we show in the next section. In particular, we analyse two relevant decoration problems resulting from two concrete weakening relation definitions, namely the set inclusion ($\subseteq$) and maximal weakening relation ($\preceq_{\!M}$).

5 Decoration Algorithm for Specific Classes of Predicates

Solving a constraint satisfaction problem is in general NP-hard. Thus, this section is devoted to instantiating each component of the developed theory into concrete predicate languages that can be used in standard solver tools to find solutions for the relaxed attack-tree decoration problem. In Section 7 below we show how those instantiations of the theory can be used to analyse a comprehensive attack tree case study.

5.1 Maximal weakening over inequality relations

Here we address the question of whether there exists a meaningful predicate language and constraint satisfaction solver that can be used to solve the relaxed attack tree decoration problem with respect to the maximal weakening relation. Note that, among all possible weakening relations the maximal one is the less restrictive. Hence it leads to more fine-grained solutions than other weakening relations.

The chosen predicate language defines predicates of three types, all based on comparing one or two labels to a constant value. The three types of predicates are:

$\ell\leq a$ 2. 2.

$\ell\geq a$ 3. 3.

$\ell\leq\ell^{\prime}+a$

where $\ell$ and $\ell^{\prime}$ are labels and $a$ is a real number (positive or negative). We denote the set of all such predicates by $\mathcal{P}_{\mathit{ineq}}$ and we will often use $s_{a}\in\mathcal{P}_{\mathit{ineq}}$ to denote a predicate in this set with constant value $a$. It is easy to verify that $\{p\}\preceq_{\!M}\{p^{\prime}\}$ can only hold if predicates $p$ and $p^{\prime}$ are of the same type.

Lemma 2**.**

Let $p,p^{\prime}\in\mathcal{P}_{\mathit{ineq}}$ be two predicates, then $\{p\}\preceq_{\!M}\{p^{\prime}\}$ implies that, for some labels $\ell_{1}$, $\ell_{2}$, and some real numbers $a$, $a^{\prime}$,

[TABLE]

The three types of predicates have been chosen in such a way that the maximal weakening relation $\preceq_{\!M}$ on single predicates can be easily characterised by the numerical order of their constant values $a$. This characterisation will allow us later to define the distance between two predicates as the difference between their constant values $a$ and $a^{\prime}$.

Lemma 3**.**

Let $\ell_{1}$, $\ell_{2}$ be labels and $a$, $a^{\prime}$ be real numbers. Then the following properties hold.

[TABLE]

From this lemma it follows, for instance, that for $S,S^{\prime}\subseteq\mathcal{P}_{\mathit{ineq}}$, if $S\preceq_{\!M}S^{\prime}$ and $(\ell_{1}\leq a)\in S$, then there exists $(\ell_{1}\leq a^{\prime})\in S^{\prime}$, such that $a\geq a^{\prime}$. Hence we consider the set $\mathcal{F}(S,S^{\prime})$ containing all total functions $f\colon S\rightarrow S^{\prime}$ such that $\forall p\in S\colon f(p)\implies p$. The Euclidean distance between two predicate $s_{a},s_{a^{\prime}}\in\mathcal{P}_{\mathit{ineq}}$ is given by $d(s_{a},s_{a^{\prime}})=|a-a^{\prime}|$ if $s_{a}$ and $s_{a^{\prime}}$ are of the same type, $d(s_{a},s_{a^{\prime}})=\infty$ otherwise. Given $f\in\mathcal{F}(S,S^{\prime})$, we define $d_{f}(S,S^{\prime})=\sqrt{\sum_{p\in S}d^{2}(p,f(p))}$, and the Euclidean distance $d(S,S^{\prime})$ between two sets of predicates by

[TABLE]

We restrict the distance measure above to bijective functions only. That is to say, we consider from now on $\mathcal{F}(S,S^{\prime})$ to be the set containing all bijective functions $f\colon S\rightarrow S^{\prime}$ such that $\forall p\in S\colon f(p)\implies p$. A consequence of such restriction is that predicate sets with different cardinality have distance $\infty$, which simplifies the proof of Theorem 4 below.

Next we provide sufficient conditions for a set of predicates to be part of a solution of the relaxed attack-tree decoration problem. It states that a set $S$, which minimizes its distance $d(S,S(t))$ to $S(t)$, where $S(t)$ is the set of soft predicates for a given tree $t$, and that satisfies $[\![H(t)\cup S]\!]_{t}\neq\emptyset$, where $H(t)$ is the set of hard predicates, leads to a solution of the relaxed attack-tree decoration problem.

Theorem 4**.**

Let $t$ be an attack tree and $H(t)\cup S(t)$ an attribute constraint-set for $t$, where $S(t)\subseteq\mathcal{P}_{\mathit{ineq}}$. Let $S\subseteq\mathcal{P}_{\mathit{ineq}}$ be a set of predicates such that $[\![H(t)\cup S]\!]_{t}\neq\emptyset$ and $d(S,S(t))$ is minimum and defined, i.e. $d(S,S(t))\neq\infty$. Then there exists a valuation $\alpha\in[\![H(t)\cup S]\!]_{t}$ such that $(S,\alpha)$ is a solution of the relaxed attack-tree decoration problem with respect to $\preceq_{\!M}$.

Proof.

First, if $[\![H(t)\cup S(t)]\!]_{t}\neq\emptyset$, then there exists $\alpha\in[\![H(t)\cup S(t)]\!]_{t}$ and $d(S(t),S(t))=0$, which is minimum. Thus in the remainder of the proof we assume that $[\![H(t)\cup S(t)]\!]_{t}=\emptyset$.

Now, notice that $S(t)\not\preceq_{\!M}S$, otherwise $[\![H(t)\cup S]\!]_{t}=\emptyset$. Thus we obtain that $S\preceq_{\!M}S(t)$, implying that $S$ satisfies the first condition of the relaxed attack tree decoration problem. Moreover, we also conclude that $|S|=|S(t)|$, given that $d(S,S(t))\neq\infty$. Next, we will show that $S$ satisfies the third condition of the problem definition as well.

Suppose we have $S\preceq_{\!M}S^{\prime}\preceq_{\!M}S(t)$, but $S^{\prime}\not\preceq_{\!M}S$. Because $S^{\prime}\not\preceq_{\!M}S$, there must exist $p^{\prime}\in S^{\prime}$ such that no $p\in S$ satisfies that $p\implies p^{\prime}$. Let us analyse the three possible predicate types of $p^{\prime}$.

Assume $p^{\prime}\equiv\ell\leq a^{\prime}$. Because $S^{\prime}\preceq_{\!M}S(t)$, there must exist $p^{\prime\prime}\equiv\ell\leq a^{\prime\prime}$ in $S(t)$ with $a^{\prime\prime}\leq a^{\prime}$. Now, let $f:S\rightarrow S(t)$ be a bijective function such that $d_{f}(S,S(t))=d(S,S(t))$. Such a function exists given that $d(S,S(t))\neq\infty$ and $S\preceq_{\!M}S(t)$. Let $p\equiv\ell\leq a$ be the predicate in $S$ such that $f(p)=p^{\prime\prime}$. Overall we obtain that $a^{\prime\prime}\leq a^{\prime}$ and $a^{\prime\prime}\leq a$. Now, given that $p$ does not imply $p^{\prime}$, according to Lemma 3 it must be the case that $a>a^{\prime}$. Therefore we obtain the order $a>a^{\prime}\geq a^{\prime\prime}$. Consider the set of predicates $S^{\prime\prime}=S\setminus\{p\}\cup\{p^{\prime}\}$. On the one hand, because $a^{\prime}\geq a^{\prime\prime}$ it follows that $S^{\prime\prime}\preceq_{\!M}S(t)$ and $f\in\mathcal{F}(S^{\prime\prime},S(t))$. On other hand, because $a>a^{\prime}$ and $a^{\prime}\geq a^{\prime\prime}$, we obtain that $d_{f}(S,S(t))>d_{f}(S^{\prime\prime},S(t))$. Considering that $d_{f}(S,S(t))=d(S,S(t))$, then $d(S,S(t))>d_{f}(S^{\prime\prime},S(t))\geq d(S^{\prime\prime},S(t))$, which contradicts the assumption that $d(S,S(t))$ is minimum. 2. 2.

The case $p^{\prime}\equiv\ell=\ell^{\prime}\leq a^{\prime}$ is analogous to the previous one. 3. 3.

Finally assume $p^{\prime}\equiv\ell\geq a^{\prime}$. As in the first case we obtain that there exist predicates $p\equiv\ell\geq a$ and $p^{\prime\prime}\equiv\ell\geq a^{\prime\prime}$ in $S$ and $S(t)$, respectively, such that $p^{\prime\prime}\implies p^{\prime}$ and $f(p)=p^{\prime\prime}$. Given that $p$ does not imply $p^{\prime}$, then we obtain the following order, $a^{\prime\prime}\geq a^{\prime}>a$. Again, such an order implies that $d(p,p^{\prime\prime})>d(p^{\prime},p^{\prime\prime})$. Therefore, the set of predicates $S^{\prime\prime}=S\setminus\{p\}\cup\{p^{\prime}\}$ satisfies that $d(S,S(t))>d(S^{\prime\prime},S(t))$, which contradicts the assumption that $d(S,S(t))$ is minimum.

The proof concludes by remarking that $S$ satisfies the second condition of the relaxed attack tree decoration problem, as stated in the body of the theorem. ∎

This theorem demonstrates a reduction of the relaxed attack-tree decoration problem for the maximal weakening relation $\preceq_{\!M}$ on the given types of predicates to an optimisation problem that we solve via nonlinear programming. The formulation of the optimisation problem is given below.

Corollary 5**.**

Let $t$ be an attack tree and $H(t)\cup S(t)$ an attribute constraint-set for $t$ where $S(t)=\{p_{1},\ldots,p_{n}\}$ contains only predicates from $\mathcal{P}_{\mathit{ineq}}$. We create the set of predicates $S$ by replacing every predicate $p_{i}\in S(t)$ by.

[TABLE]

where $x_{1},\ldots,x_{i}$ are variables. A solution $\alpha,x_{1},\ldots,x_{n}$ to the following optimisation problem leads to a solution $(S,\alpha)$ of the relaxed attack tree problem.

[TABLE]

Implementation. To find a valuation function $\alpha$ and a set of weakening predicates $S^{\prime}$ so that the distance function $d(S,S(t))$ is minimised, we relied on the Sequential Quadratic Programming (SQP) problem interpretation of the relaxed attack-tree decoration problem. We further refer to this tool as the SQP-based tool. It is implemented using the Python scipy library that provides the Sequential Least Squares Programming (SLSQP) algorithm for solving optimisation problems of this type. Our implementation333Code available at https://github.com/vilena/at-decorator/tree/master/SQP_decorator does not impose any burden on the analyst, as it allows a loose interpretation of all constraints together. In case the set of constraints is satisfiable, our tool finds an optimal solution. In case of an unsatisfiable set of constraints, our implementation will find an optimal solution that minimises the distance function between set of predicates.

5.2 Set inclusion weakening over propositional logic

As the analyst may require a predicate language richer than the one described above, we provide tool support for predicates written in the propositional logic. We do so via a transformation of a relaxed attack tree-decoration problem instance into a Satisfiability Modulo Theories (SMT) instance [16]. SMT is the problem of determining whether a formula in the first-order logic, where some operator symbols are provided with a theory, is satisfiable.

Given a set of predicates $S$, we use $\Gamma(S)$ to denote the first-order logic formula formed by all predicates in $S$ in the conjunctive form. Then the SMT instance resulting from the relaxed attack-tree decoration problem instance with the attribute constraint-set $H(t)\cup S(t)$ is defined by $\Gamma(H(t)\cup S(t))$. If $\Gamma(H(t)\cup S(t))$ is satisfiable, it follows that the decoration problem does not need to be relaxed. Otherwise, we use Algorithm 1 to find a subset of soft predicates $S\subset S(t)$ that solves the relaxed attack tree decoration problem with respect to the inclusion relation.

Initially, the set $S$ is empty. Algorithm 1 works by iteratively adding predicates to the set $S$, until the formula $\Gamma(H(t)\cup S)$ is satisfiable, while the formula $\Gamma(H(t)\cup S^{\prime})$ is unsatisfiable for any $S^{\prime}\supset S$. It is easy to prove that such procedure provides a solution to the relaxed attack-tree decoration problem with respect to the subset inclusion weakening relation, based on the assumption that hard predicates are satisfiable.

Implementation. We implemented our transformation relying on the well-known theorem prover Z3 from Microsoft444https://github.com/Z3Prover/z3. Z3 can be utilised as a constraint solver, i.e., it can find a solution satisfying a set of constraints expressed as equalities and inequalities. Our current implementation555Code available at https://github.com/vilena/at-decorator/tree/master/CSP_decorator can handle all attribute domains on real numbers that are defined in the ADTool [28], e.g. probability, minimal cost of attack, and minimal time; and it is trivially extensible to attribute domains defined on Boolean values, e.g. satisfiability of a scenario. The analyst can further specify additional constraints, if desired. The resulting set of constraints is passed to the Z3 prover, which reports whether the problem is solvable or not. In case the constraint satisfaction problem is solvable, the prover will report a complete consistent valuation for the given tree. This valuation will satisfy the tree structure and the constraints expressed by the analyst, and it will agree with the given initial valuation. If the constraint satisfaction problem is not solvable (i.e. the initial valuation is inconsistent), we use Algorithm 1 to find a subset of soft predicates of maximum cardinality that is satisfiable, and report a solution satisfying the found maximal predicate set.

6 ATM Case Study

We now proceed to show how our approach to attack-tree decoration can be applied to a real-life security scenario. The goal is to show that decoration can be performed in a systematic way even when the analyst only has partial information about attribute values.

In this section, we introduce a case study related to capturing automated teller machine fraud scenarios as an attack tree, and we describe the historical data available for decorating this tree.

6.1 ATM Security: a Case Study

Automated teller machines (ATMs) are complex and expensive systems used daily by millions of bank customers worldwide. Because each carries a significant amount of cash, ATMs are the target of large-scale criminal actions. Only in 2015 more than $16,000$ ATM incidents were reported in Europe, causing over $300$ million Euros loss666https://www.association-secure-transactions.eu/tag/atm-crime-report/.

In an attempt to provide structure to the risk assessment process and catalogue ATM threats, Fraile et al. created a comprehensive attack-defence tree capturing the most dangerous attack scenarios applicable to ATMs [17]. The tree modelled in [17] contains three main branches: brute-force attacks, fraud attacks, and logical attacks. The attacks of the logical type make use of malicious software, while a brute-force attack typically ends up destroying the ATM. Differently from these two attack scenarios, ATM fraud attacks involve conventional electronic devices (such as card skimmers) and require the participation of the victim.

In this empirical evaluation section we focus on ATM fraud, because more empirical data is available for these attacks than for the other types of attacks. Figure 3 presents an attack tree characterising such attacks that is loosely based on the attack-defence tree published by Fraile et al. [17]. In ATM fraud, criminals need covert access to the ATM, as this attack typically requires opening the machine’s case either by force or with a generic key, and installing a special device (e.g. a skimmer). Then the attacker waits until a victim uses the ATM and, as a consequence, enables the installed device. Lastly, the attacker gets cash from the victim’s account by means of various techniques, such as cash trapping, card cloning, etc.

6.2 Decorating the ATM Fraud Attack Tree

The decoration process we propose in this paper consists of three independent steps that are executed for a given attack tree. First, an attribute is chosen. In this case study, we focus on probability of success, that is, the probability that a given ATM machine is used to successfully execute ATM fraud. The attack tree structure jointly with the attribute rules determine the hard constraint set, i.e. the standard bottom-up constraints derived from the attack thee structure. Second, statistical information (historical data) related to the chosen attribute is gathered. Such statistical values are used to provide tree nodes with probability values. For the ATM fraud scenario, the available statistical data is presented in Section 6.2.1. Lastly, relations among nodes in the tree are established based on the analyst’s insight and domain knowledge. Section 6.2.2 presents the corresponding analysis for the ATM fraud scenario. The full set of constraints for the ATM fraud scenario is summarised in Section 6.3.

6.2.1 Statistical Analysis

The statistical values we consider here have been derived from the ATM Crime Report 2015 (EAST). In our case, we analyse ATM fraud incidents in Lisbon, which hosts 300 ATMs. We remark, however, that these values have been derived for illustrative purposes only and may not be accurate.

Between $2010$ and $2015$, $83$ ATM fraud attacks have been reported in Lisbon. This gives a $0.0461$ probability of an ATM to be the target of fraud within a calendar year, if we assume the uniform distribution of these attacks. Because the report categorises ATM fraud into different attack types, we can provide probability values for some attack types by analysing the attack frequency as reported in the EAST report. The results can be found in Table 1. For the results reported in this table, we assume that historical attacks were uniformly distributed, and we rely on frequencies of attacks over long time periods to estimate probabilities, like in the OCTAVE method [13].

6.2.2 Domain Knowledge Constraints

In the previous subsection, we have shown how available statistical data can be used as a constraint in our decoration process. Another novelty of our approach is that we allow for domain knowledge constraints, that is, facts that must be additionally satisfied in the attack tree. The following list of facts is based on the previously mentioned ATM Crime Report 2015 and also on the European Central Bank report on card fraud (2015).

• •

$\operatorname{\mathit{card-skimming}}$ is more likely than $\operatorname{\mathit{take-card-phys}}$. Moreover, $\operatorname{\mathit{get-credentials}}$ is more likely than $\operatorname{\mathit{cash-trapping}}$, which is more likely than $\operatorname{\mathit{trans-reversal}}$.

• •

$\operatorname{\mathit{shoulder-surf}}$ is more likely than $\operatorname{\mathit{install-camera}}$.

• •

$\operatorname{\mathit{install-camera}}$, $\operatorname{\mathit{install-epp}}$ and $\operatorname{\mathit{install-skimmer}}$ are all equally likely.

• •

$\operatorname{\mathit{cash-trapping}}$ and $\operatorname{\mathit{card-trapping}}$ are equally likely.

6.3 Full Set of Predicates

We now list the full set of predicates that will be used by the tools to solve the decoration problem. To simplify the presentation, we use a short-hand notation. All predicates listed in this section can be straightforwardly transformed into our predicate notation.

Hard predicates. Considering the attribute domain of probability of success, the attack tree shown in Fig. 3 corresponds to the following set of hard predicates:

• •

$\operatorname{\mathit{atm-fraud}}$ = $\times$($\operatorname{\mathit{access-atm}}$, $\operatorname{\mathit{execute-attack}}$),

• •

$\operatorname{\mathit{access-atm}}$ = $+$($\operatorname{\mathit{break-in}}$, $\operatorname{\mathit{social-engineer-staff}}$),

• •

$\operatorname{\mathit{execute-attack}}$ = $+$($\operatorname{\mathit{trans-reversal}}$, $\operatorname{\mathit{get-credentials}}$, $\operatorname{\mathit{cash-trapping}}$),

• •

$\operatorname{\mathit{get-credentials}}$ = $\times$($\operatorname{\mathit{get-pin}}$, $\operatorname{\mathit{get-card}}$),

• •

$\operatorname{\mathit{get-pin}}$ = $+$($\operatorname{\mathit{shoulder-surf}}$, $\operatorname{\mathit{install-camera}}$, $\operatorname{\mathit{install-epp}}$),

• •

$\operatorname{\mathit{get-card}}$ = $+$($\operatorname{\mathit{card-skimming}}$, $\operatorname{\mathit{take-card-phys}}$, $\operatorname{\mathit{social-engineer-owner}}$),

• •

$\operatorname{\mathit{card-skimming}}$ = $\times$($\operatorname{\mathit{install-skimmer}}$, $\operatorname{\mathit{clone-card}}$),

• •

$\operatorname{\mathit{take-card-phys}}$ = $+$($\operatorname{\mathit{card-trapping}}$, $\operatorname{\mathit{steal-card}}$).

Soft predicates. Historical data values from Table 1 are encoded in the form of soft predicates:

• •

$\operatorname{\mathit{atm-fraud}}$ = $0.0046$,

• •

$\operatorname{\mathit{card-skimming}}$ = $0.0172$,

• •

$\operatorname{\mathit{card-trapping}}$ = $0.0094$,

• •

$\operatorname{\mathit{cash-trapping}}$ = $0.0150$,

• •

$\operatorname{\mathit{trans-reversal}}$ = $0.0038$.

We will subsequently refer to the soft predicates listed above as historical data constraints.

Domain knowledge from the ATM Crime report is encoded in the form of soft predicates as well:

• •

$\operatorname{\mathit{take-card-phys}}$ $\leqslant$ $\operatorname{\mathit{card-skimming}}$,

• •

$\operatorname{\mathit{cash-trapping}}$ $\leqslant$ $\operatorname{\mathit{get-credentials}}$,

• •

$\operatorname{\mathit{trans-reversal}}$ $\leqslant$ $\operatorname{\mathit{cash-trapping}}$,

• •

$\operatorname{\mathit{install-camera}}$ $\leqslant$ $\operatorname{\mathit{shoulder-surf}}$,

• •

$\operatorname{\mathit{install-camera}}$ = $\operatorname{\mathit{install-epp}}$,

• •

$\operatorname{\mathit{install-skimmer}}$ = $\operatorname{\mathit{install-epp}}$,

• •

$\operatorname{\mathit{install-skimmer}}$ = $\operatorname{\mathit{install-camera}}$,

• •

$\operatorname{\mathit{cash-trapping}}$ = $\operatorname{\mathit{card-trapping}}$,

Subsequently, we will refer to the set of soft predicates above as domain knowledge predicates.

6.4 Goals of the Analysis

We consider that the analyst has designed an attack tree covering ATM fraud scenarios as presented in Figure 3. This attack tree gives them the set of hard constraints given in Section 6.3. Furthermore, the analyst has elicited a set of soft constraints based on their knowledge of the problem space and the information available in the ATM Crime Report (also listed in Section 6.3). However, the analyst is not able to find enough data to estimate probabilities for all leaf nodes in the attack tree, what prevents them from straightforwardly applying the bottom-up evaluation procedure to compute the probabilities for all intermediate nodes and, ultimately, for the root node.

The analyst can, however, apply our methodology and decorate the attack tree. We consider the following possible analysis questions that can be investigated with our approach:

• •

Are the attack tree and the set of constraints elicited by the analyst compatible? I.e. does the corresponding decoration problem have a solution? In our notation, for an attack tree $t$, and attribute constraint-set $H(t)\cup S(t)$, is $[\![H(t)\cup S(t)]\!]_{t}\neq\emptyset$?

• •

What is a solution for the given decoration problem? In our notation, the analyst is interested in finding a solution $\alpha\in[\![H(t)\cup S(t)]\!]_{t}$.

• •

If the decoration problem has no solution, what is a solution that is the closest to satisfying all constraints? This question corresponds to solving the relaxed attack tree decoration problem formulated in Definition 7, for a chosen weakening relation.

We will demonstrate in the next section how our two implementations solve the relaxed attack tree decoration problem of the ATM case study, for the maximal and set inclusion weakening relations.

Note that one may argue that in our case study the analyst already has the probability of ATM fraud (the root node) from the historical data, and therefore, they can skip decorating the whole tree. However, the analyst may still want to perform the so-called what-if analysis, which consists in analyzing different but related scenarios. For example, the analyst could answer questions such as: What if the probability of this attack is in fact higher than I envisage? How will this affect my security posture? The what-if analysis requires a fully annotated tree, which can be provided using our decoration technique even over partially available data. Furthermore, in general, it cannot be assumed that the root node value will always be available from the historical data.

7 Empirical Evaluation Results

We now show how our two implementations can be applied to analyse the ATM case study introduced previously.

7.1 The CSP-based Implementation Showcase

We first exemplify the results of the CSP-based implementation on the ATM case study tree presented in Fig. 3. The first solution in Table 2 presents a possible valuation for this attack tree found by the CSP-based tool with the hard predicates and the historical data predicates listed in Section 6.3. Figure 4 visualises this solution in the ATM fraud attack tree. We have used the open source ADTool software [28, 21] for visualising attack trees.

If the analyst introduces the domain knowledge predicates as an additional set of constraints, the CSP tool indicates that the constraint satisfaction problem becomes unsatisfiable. Indeed, the constraints on $\operatorname{\mathit{card-trapping}}$ and $\operatorname{\mathit{cash-trapping}}$ are contradictory, because historical data does not indicate that the probabilities of these attacks are exactly equal.

The Z3 solver that we use as the underlying constraint satisfaction engine is capable of finding an unsatisfiable core of the problem. In the ATM fraud case, the solver reports that three predicates constitute the unsatisfiable core:

• •

$\operatorname{\mathit{card-trapping}}$ $=$ $\operatorname{\mathit{cash-trapping}}$,

• •

$\operatorname{\mathit{card-trapping}}$ $=0.0094$,

• •

$\operatorname{\mathit{cash-trapping}}$ $=0.015$.

The solver then proceeds to identify a maximal set of predicates that is still satisfiable. In our case, the solver is able to satisfy all predicates but $\operatorname{\mathit{cash-trapping}}$ $=0.015$. The second solution in Table 2, illustrated in Figure 5, shows a possible valuation found by the CSP-based tool after adding the set of domain knowledge constraints to the original assignment predicate set (i.e. excluding the constraint on equality of $\operatorname{\mathit{cash-trapping}}$ to 0.015).

Analysing this valuation, we can see that, for example, the probability of $\operatorname{\mathit{take-card-phys}}$ has dropped significantly, and the probability of $\operatorname{\mathit{steal-card}}$ has decreased with the new constraint set. Indeed, in the first assignment set there was no constraint that the probability of $\operatorname{\mathit{take-card-phys}}$ is less than the probability of $\operatorname{\mathit{card-skimming}}$ (which is statistically a rare event itself). When we added this constraint found in the domain knowledge catalogue, the valuation for this subtree has changed. This result demonstrates that even if the analyst cannot obtain a valuation for some attack such as $\operatorname{\mathit{steal-card}}$, they can get an estimation for it by using other known parameters and domain knowledge.

7.2 The SQP-based Implementation Showcase

When running the relaxed tree decoration method considering the historical data values in Table 1 and the domain knowledge constraints from Section 6.2.2, the optimisation task converged to the solution presented in the third solution of Table 2. Figure 6 presents the decorated attack tree.

Three of the soft constraints stemming from the historical data values ($\operatorname{\mathit{atm-fraud}}$, $\operatorname{\mathit{card-skimming}}$, $\operatorname{\mathit{trans-reversal}}$) were satisfied precisely without weakening. $\operatorname{\mathit{cash-trapping}}$ and $\operatorname{\mathit{card-trapping}}$ constraints were satisfied by weakened predicates. The probability of $\operatorname{\mathit{card-trapping}}$ in historical data was $0.0094$, and the optimised value is $0.0113$. The probability of $\operatorname{\mathit{cash-trapping}}$ was $0.015$ in historical data, and the optimised value is $0.0131$.

Six out of seven domain knowledge constraints were satisfied precisely without weakening. The remaining constraint that was not satisfied precisely is the knowledge that $\operatorname{\mathit{cash-trapping}}$ and $\operatorname{\mathit{card-trapping}}$ are equally likely. In the optimised solution they have a small difference, the probability of $\operatorname{\mathit{cash-trapping}}$ is $0.0131$ while the probability of $\operatorname{\mathit{card-trapping}}$ is $0.0113$.

In the result of this process, four weakened predicates were found. The soft and weakened predicates for these four cases are shown in Table 3. It is the task of the analysts to decide on whether such weakened predicates fit their analysis. For example, except for the $\operatorname{\mathit{take-card-phys}}$ predicate, all other predicates in Table 3 satisfy that their distance to their weakening predicate is lower than $10^{-2}$, and one may argue that in the probability domain a $10^{-2}$ discrepancy is acceptable.

7.3 Discussion

We have showcased the application of our methodology on a practical scenario of ATM security. We have established in this empirical validation that the attack-tree decoration methodology is versatile, as it can be realised differently depending on the analyst’s needs. In particular, the analyst can choose a suitable weakening relation and ask the solver to tackle the decoration problem depending on their confidence in the tree structure and the historical data available.

When the confidence in the predicate set is high, the analyst will work with the relaxed attack-tree decoration problem, e.g. using our CSP and SQP-based tools, to obtain a solution that is the closest one to satisfying all available data points. When the analyst has low confidence in the data, they can work with a constraint solver, for example, starting from our CSP-based implementation, to identify whether there is inconsistency in the data. If the constraint satisfaction problem is not satisfiable, the reported unsatisfiable core of the predicates can be the first candidate to be reviewed with other experts in order to revise the corresponding data points.

The limitation of our methodology is that it does not allow to draw precise conclusions about data accuracy. For example, an unsatisfiable core reported by the CSP-based implementation in case of inconsistency does not guarantee that this is indeed the set of wrong predicates. It might be that the real problem lies within another, co-dependent set of predicates, where considered data values are inaccurate. We plan to investigate the means to evaluate the decoration accuracy considering e.g. analyst’s confidence level for each data point and the size of the solution space in future work.

Our methodology does not fully remove the intellectual burden from the analyst, but it equips them with an insight into conformity of the historical data with the given attack tree structure, and with an initial, complete attack-tree decoration. This decoration can be further improved by the analyst by incorporating more historical data or engaging more domain experts whenever needed.

Our two implementations demonstrate that the methodology is practical and it works on real attack trees. In general, the non-linear constraint satisfaction problem used by the CSP-based implementation and the SQP problem are NP-hard [39, 49]. Note that the complexity of the attack-tree decoration task itself is unknown. Therefore, our implementations will not scale to very large attack trees. To the best of our knowledge, there is no statistics on the average or maximal sizes of attack trees in practice. However, manually designed attack trees, in our own experience, rarely have more than 100 nodes, because they quickly become incomprehensible for humans [18]. Therefore, we expect that our implementations will work reasonably well with the majority of attack trees created by practitioners.

8 Conclusions

In this article we proposed the first quantitative attribute approach for attack trees that is able to deal with incomplete information. On the one hand, we have well-known classical attributes on attack trees expressing relations between nodes in a tree. On the other hand, we recognise that reliable information can be obtained from historical data and domain knowledge. This type of information is typically not included in the semantics of attack trees, and so it has been largely ignored until now. We take these two views on the world and we verify that they are consistent. Since Schneier’s definition of attack trees, bottom-up evaluation of attributes was the norm. We are the first to introduce a complete view on attribute values, including missing values and approximation.

The main benefit of our computational methodology is that it allows to obtain a consistent valuation for all attack tree nodes, even if some leaf nodes data is missing. This is not possible with the standard bottom-up decoration approaches. We have shown that the distinction between hard and soft constraints can be handy, as it allows the analyst to better understand the solution space and to interactively engage with the decoration problem. Lastly, we provide two implementations and we demonstrate the feasibility of the suggested approach on a case study. Our proof-of-concept implementations demonstrate the viability of the method, and they can be easily introduced into the established tools working with attack trees, such as the SecurITree tool and the ADTool.

Acknowledgments

The research leading to these results has received funding from the European Union Seventh Framework Programme under grant agreement number 318003 (TREsPASS), and from the Fonds National de la Recherche Luxembourg under grant C13/IS/5809105 (ADT2P).