Extending Attack Graphs to Represent Cyber-Attacks in Communication Protocols and Modern IT Networks

TL;DR

This paper enhances attack graph modeling by extending MulVAL to include network protocol vulnerabilities, wireless communication, and industrial architectures, enabling comprehensive cyber-attack analysis on modern networks.

Contribution

It introduces an extended MulVAL model supporting protocol vulnerabilities, wireless, and industrial communication, improving attack representation in diverse network environments.

Findings

Successfully modeled attacks like spoofing, MITM, and DoS.

Demonstrated the extended model on a mixed IT and industrial testbed.

Enhanced attack graph coverage for modern communication protocols.

Abstract

An attack graph is a method used to enumerate the possible paths that an attacker can execute in the organization network. MulVAL is a known open-source framework used to automatically generate attack graphs. MulVAL's default modeling has two main shortcomings. First, it lacks the representation of network protocol vulnerabilities, and thus it cannot be used to model common network attacks such as ARP poisoning, DNS spoofing, and SYN flooding. Second, it does not support advanced types of communication such as wireless and bus communication, and thus it cannot be used to model cyber-attacks on networks that include IoT devices or industrial components. In this paper, we present an extended network security model for MulVAL that: (1) considers the physical network topology, (2) supports short-range communication protocols (e.g., Bluetooth), (3) models vulnerabilities in the design of network protocols, and (4) models specific industrial communication architectures. Using the proposed extensions, we were able to model multiple attack techniques including: spoofing, man-in-the-middle, and denial of service, as well as attacks on advanced types of communication. We demonstrate the proposed model on a testbed implementing a simplified network architecture comprised of both IT and industrial components.

Tables

Table 1. TABLE I : Information collected by the agent

Type	Information collected	Tools (Windows/Linux)
Topology	IP address, netmask, etc.	nmap
OS information	Type and version	nmap
Software and services	Network: port number, protocol, service name, etc.	nmap, netstat
	Local: ID, name, executable, user, etc.	WMI / dpkg-query, rpm, ps (login)
Users and groups	ID, name, type, access permissions, etc.	WMI/passwd or sudo file (login)
Firewall	Host-based firewall rules	netstat firewall, advfirewall/ iptables-save, iptables-xml
Vulnerability	CVE-ID, CVSS score, CWE, related CPEs, etc.	OpenVAS, NVD

Work	Vulnerability Modeling	Host Modeling	Network Modeling	Data Modeling	User Modeling	Safeguard Modeling
Ou et al. [6] (baseline)	Characterized by exploitation range (local or remote) and consequence (impacting CIA, DoS, or privilege escalation); Associated with a specific program running on a host	Characterized by running programs	Connectivity among hosts is represented by the hacl predicate which is an abstraction of routing information and access controls	Associated with paths in a specific host and principals’ access to files	User accounts to hosts and their privileges; Principal characteristic (malicious or incompetent)	–
Bacic et al. [21]	–	Model host classification (derived from the assets it contains) and software availability	Model subnets and inter-subnet communication	Model assets/data value (in terms of CIA) and classification	Model principal’s clearance level	–
Froh et al. [22]	–	Model the value of IT services (in terms of CIA) and associate them with host and program	Associate hosts to networks; Represent network components (routers)	Model assets/data value (in terms of CIA)	–	Represent security requirements (e.g., applicationAccount) and incorporate them in the interaction rules; Consider their (or other primitives) absence an indication to safeguard deployment
Liu et al. [liu2015logic]	Represent vulnerability exploitation based on evidence collected from hosts	–	–	–	–	–
Acosta et al. [9]	Model ARP spoofing attack; Model null/weak authentication in OLSR	–	Model network components (gateways; Model cross-subnet network access	Represent data flows (traffic generated by a user in a specific protocol that is exchanged between two hosts)	–	–
Our approach	Represent protocol design vulnerabilities; Represent data vulnerabilities (e.g., lack of encryption); Model spoofing attacks, MITM, DoS, and attacks on wireless and bus communication	Represent local services	Represent hosts connectivity at different network layers; Represent wireless and serial communications; Distinguish between host and network-based firewall rules	Represent specific data types (e.g., credentials); Distinguish between data at rest and data in motion	Represent user access to hosts at different network layers	–

Fact	Generation method	Description
isLoginService	Knowledge, Manual	Utilizing common knowledge or expert input to classify a service as a login service. For example: SSH and Remote Desktop are known services that enable users to log in to a machine.
networkService	Assumption, Scan	Identifying network services directly from scan results. If the Protocol or Port arguments could not be detected, they are set to unknown; if the User argument is not detected, it is set to a wildcard.
localService	Scan	Identify local services directly from host scans.
isCredential	Assumption, Manual	Categorize data as containing credentials, for example: if some host runs a program that is defined as both isLoginService and networkService, an isCredential fact is generated for each existing hasAccount fact involving that host to indicate that the login data flow contains credentials (i.e., the remote login attempt): the User and Host arguments get the values of the User and Host arguments of hasAccount predicate, and the DataName argument is set to ”user_hostCredentials” (where user and host correspond to the User and Host arguments of hasAccount predicate).
dataFlow, flowBind	Knowledge, Manual	Generate data flows according to common knowledge, for example: the port number can provide an indication about the protocol used to send some data flow.
dataBind	Assumption, Knowledge	Associating data with a specific path, for example: we know that a DNS server holds an IP to naming mapping in its cache, but we cannot get this memory mapping from a scan. Thus, in order to represent this knowledge, this data is associated with a generic representation of this path.
existingProtocol	Scan, Manual	Specify which protocol is used within different parts of the network (e.g., the usage of ARP within a subnet) directly from scan results or from expert’s input.
located	Scan	Identify the position of each device in the network directly from scan results.
vulLinkProtocol, vulE2EProtocol	Knowledge	Associate protocol vulnerabilities to communications identified in the network by using a predefined knowledge base (e.g., NIST NVD).
vulHost	Scan	Identify the vulnerabilities in each host directly from scan results (e.g., using Nessus).
vulData	Manual	Associate vulnerabilities with data (e.g., unencrypted or unsinged) based on expert’s input.
hasAccount	Assumption, Scan	Associate user accounts to hosts directly from scans. If the Principal argument could not be detected, it is set to: ”host_nameUser” (where host_name is the value of the Host argument); if the User argument could not be detected, it is set to admin.
localAccess	Assumption, Scan	Infer a principal’s access to hosts directly from scans. If the Principal argument could not be detected, it is set as the hasAccount predicate.
aclNW	Assumption, Scan	Infer network-based firewall rules directly from scans. If a networkService fact with an unknown protocol and port was generated, a corresponding aclNW with an unknown protocol and port arguments is generated.
aclH	Assumption, Scan	Infer host-based firewall rules directly from scans. Similar to aclNW; if a network service with an unknown protocol and port was generated, a corresponding aclH is generated, and the User argument is set to a wildcard.

Equations

$$p(t_1,...,t_k)$$

$$vulExists(dbServer,VulID,oracleDB).$$

$$P_0:-P_1,...,P_n$$

$$\begin{array}{rl}can& AccessHost(H):-\\ & logInService(H,Protocol,Port),\\ & netAccess(H,Protocol,Port)).\end{array}$$

Full text

I Introduction

Risk assessment is a process that enables system stakeholders to assess the risks to their system and select suitable countermeasures. An attack graph is a risk assessment method used to enumerate the possible attack paths that an attacker can take in order to compromise an organization [1]. This is done by modeling the prerequisites and consequences of exploiting software vulnerabilities, as well as the attacker’s potential lateral movements. Using attack graphs, system stakeholders can identify potential attack paths, assess their risk, visualize an exhaustive attack surface, and plan efficient countermeasures.

Various types of attack graphs have been proposed in the literature, including state attack graphs [2], dependency attack graphs [3], multi-prerequisite graphs [4], and logical attack graphs [5]. In this research, we focus on the logical attack graph: a directed and-or graph in which the root represents an attacker’s goal, nodes represent subgoals (attack steps), and leafs represent facts about the system. Both facts and subgoals can be disjunctively or conjunctively connected to the next subgoals or a final goal.

MulVAL, a logic-based network security analyzer [6], is a well-known open-source framework for automatically constructing attack graphs. MulVAL models the interactions of software vulnerabilities with system and network configurations, while automatically extracting information from formal vulnerability databases (such as the National Vulnerability Database – NVD [7]) and network scanning tools (such as Nessus [8]).

While the MulVAL framework is a very powerful tool for generating attack graphs, it currently suffers from the following major limitations. First, it is broadly focused on application (software) vulnerabilities and does not properly incorporate weaknesses in network architectures and protocols. For instance, ARP poisoning, DNS spoofing, and SYN flooding are network attacks that cannot be properly modeled using only application vulnerabilities. Thus, MulVAL is likely to create an incomplete view of the possible attacks and attack paths in an organizational network. Second, MulVAL is specifically designed to model traditional IT environments and does not support advanced communication types such as wireless and bus communication. Thus, it cannot be used to model cyber-attacks on modern enterprise networks, such as those that include IoT or industrial components.

Previous attempts to augment MulVAL for representing vulnerabilities in network protocols did not provide a comprehensive (general) network model but addressed and modeled specific network attacks (e.g., ARP poisoning in [9]). In this paper we extend the MulVAL framework with a comprehensive network modeling. The proposed extension considers the seven layers of the OSI network model (including the physical network topology), supports short-range communication protocols which are very common in IoT environments, and models specific industrial communication architectures. Consequently, the extended version of MulVAL supports the modeling of various network attacks, including attacks on the physical layer (e.g., bus spoofing, WEP cracking, Bluetooth PIN cracking), data link layer (e.g., ARP poisoning), network layer (e.g., IP spoofing, ICMP flooding), and application layer (e.g., DNS spoofing). We demonstrated the proposed modeling in a testbed implementing a simplified network architecture, which is comprised of both IT and industrial components. Finally, in order to maintain an end-to-end attack graph generation process (that is provided by the MulVAL framework), we present our dedicated agent that was implemented for automatically scanning the network and translating the scan results into our extended modeling.

To summarize, the contributions of this paper are as follows. First, we present comprehensive network modeling that considers the seven layers of the OSI network model (including the physical network topology, wireless networks and bus architecture), which are currently not supported by the MulVAL framework. Second, we model multiple attack scenarios that are not addressed by current attack graph frameworks (e.g., spoofing and wireless attacks). Third, we present the implementation of a dedicated agent which is used to automatically collect network configurations and generate the input for the extended model.

II Preliminaries

II-A The Evolution of Attack Graph Generation Methods

Forward exploration for attack graph generation. The use of attack graphs for security assessment started almost 30 years ago. Fundamental studies in this domain include the works of Philips and Swiler [1, 10], which introduced the concept of graph-based network vulnerability analysis, and presented an automated tool for generating attack graphs. Their tool constructs the attack graph using the forward exploration method, starting from the initial state (the initial position of the attacker) to any goal state (target). This approach, however, is not efficient in terms of complexity, since it evaluates all existing vulnerabilities, including those that are not relevant to the goal state; therefore, it is impractical for applying on large-scale networks.

Model checking for efficient security assessment. Ritchey and Ammann [11] suggested a simple network security model (consisting of hosts and their vulnerabilities, network connectivity, current state of the attacker, and available exploits), on which they apply a model checking technique (model checker SMV), in order to evaluate the security of a system by considering the relationships between different hosts in a network. Ritchey *et al. * [12] extended the simple network security model to represent TCP/IP connectivity. Within their model, which is called topological vulnerability analysis, the representation of a host was extended to include network services and configurations, and the network connectivity model was extended to support link, transport, and application layer security. Based on Ritchey’s connectivity model, Jajodia *et al. *developed a framework which automates the vulnerability analysis process by deploying an open-source version of the Nessus scanner [8] and combining its reports with a global exploits knowledge base.

Model checking methods are more efficient than generating an attack graph using forward exploration. However, their main drawback is that they can only represent one attack path from source to target, while attack graphs enumerate all possible attacks.

Model checking for attack graph generation. To address this limitation, Sheyner *et al. * [2] introduced the attack graph toolkit, which utilizes model checking tools for automatically generating attack graphs, thus improving the efficiency and completeness of the model compared to previous works. Jha *et al. *also suggested to use model checking for attack graph generation [13]. Similar to [2], the authors modified the model checker NuSMV in order to produce a complete attack graph.

However, for the construction of attack graphs, model checking algorithms doesn’t scale well; for example, in the work of Sheyner *et al. *[2] the construction of attack graph for a network with five hosts and eight exploits took two hours and resulted in 5948 nodes and 68364 edges. Ammann *et al. *suggested to use a layered model to improve the scalability [14]. They modeled facts (privileges, connectivity, and vulnerabilities) as generic attributes (e.g., the attacker has ftp access to a specific host) and exploits as transformations that map a set of preconditions to a set of postconditions. Then, they arranged the attributes in layers according to amount of exploits required to obtain them.

Nevertheless, the main shortcoming of the above studies is that none of them automatically integrates vulnerability and network connectivity information into the attack graph generation process, and therefore none of them can support the analysis of large-scale networks.

End-to-end attack graph generation frameworks. The first framework to provide automatic end-to-end attack graph generation and analysis is MulVAL [6], a logic-based network security analyzer. MulVAL leverages exiting vulnerability databases (e.g., the National Vulnerability Database – NVD) and network vulnerability assessment tools (e.g., Nessus) to automatically derive the inputs for the attack graph generation process. This is done by using Datalog as the modeling language, which makes the integration of vulnerability databases and security assessment tools straightforward. Another benefit of Datalog over model checking tools is its efficiency. The complexity for model checking tools to enumerate all possible attack paths is exponential in the size of the network [6]. In contrast, Datalog programs are polynomial in the size of network.

Following MulVAL, Ingols *et al. *presented NetSPA, an end-to-end framework for attack graph generation [4]. NetSPA improves the input generation process by automatically extracting information from additional data sources such as Check Point firewalls and the CVE repository [15].

In 2013, Yi *et al. * [16] compared several academic attack graph generation tools (TVA, Attack Graph Toolkit, NetSPA, and MulVAL), as well as commercial software (Cauldron [17, 18] which is based on TVA, Firemon [19] which is based on NetSPA, and Skybox [20]) and concluded that: (1) MulVAL is the most extendable and scalable framework; (2) TVA and NetSPA are also scalable, however they are not open-source; and (3) commercial tools are more scalable and provide an intuitive graphical user interface, however they are not suitable for research. Therefore, in this study, we focus on the MulVAL attack graph framework.

II-B The MulVAL Framework

MulVAL is a logic-based security analyzer that models the interactions between software bugs and network configurations (i.e., connectivity), while automating the information gathering process by deploying host-based scanners. The modeling language used by MulVAL is Datalog [6], which is a subset of the Prolog logic programming language. We demonstrate MulVAL’s modeling using the simple attack scenario illustrated in Figure 1: the attacker aims to execute malicious code in the database server by abusing the free access from the Internet to the server and the vulnerable database software that allows privilege escalation (CVE-2012-3132).

Datalog primitives and syntax. The Datalog language consists of facts and rules, which are defined using predicates. Predicate is an atomic formula of the form:

[TABLE]

where, each $t_{i}$ can be either a constant (starting with a lower-case) or a variable (starting with an upper-case); wild cards are also supported and are marked with underscore (”_”). For example, the following predicate states that: some vulnerability is present in the oracleDB program running on dbServer.

[TABLE]

Rules (referred to as interaction rules in MulVAL) are represented using Horn clauses as follows:

[TABLE]

which essentially tells that if the predicates $P_{1},...,P_{n}$ are true, then predicate $P_{0}$ is also true. The left part of the clause ($P_{0}$) is called the head and the right part ($P_{1},...,P_{n}$) is called the body. Facts are clauses with no body. For example, the following rule tells that a host can be remotely accessed if it runs a login service using specific port and protocol and it is accessible via the same protocol and port.

[TABLE]

The XSB system. In order to execute a Datalog program, MulVAL uses the XSB environment, which is an extended implementation of the Prolog programming language that supports tabled execution. Tabled execution prevents the recalculation of previously calculated facts (i.e., each fact is calculated only once). Since the number of facts is polynomial in the size of the network, executing a Datalog program has a polynomial time complexity.

Attacks are simulated according to the attackerGoal(p) facts (where $p$ is a predicate defined in the Datalog program) that are specified in the input to MulVAL (the complete example input is given in Appendix B). The simulation is performed by querying the Datalog program for the predicate $p$; the attack graph is constructed based on the trace generated by this query. A detailed description of the Datalog trace analysis and attack graph construction is provided by Ou *et al. *in [5].

Attack graph representation. MulVAL generates a logical attack graph as defined in [5]: $AG=(N_{r},N_{p},N_{d},E,\mathcal{L},\mathcal{G})$, where $N_{r},N_{p},N_{d}$ are the sets of nodes (derivations, primitive facts, and derived facts correspondingly), $E$ is the set of edges, $\mathcal{L}$ is a mapping from a node to its label (i.e., the predicate it represents), and $\mathcal{G}$ is the node representing the attacker’s goal. Figure 2 presents the attack graph generated by the MulVAL tool111MulVAL tool: http://www.arguslab.org/software/mulval.html for the attack scenario described above.

Derivation nodes (visualized as circles) correspond to interaction rules and represent the reason for a fact to become true, they can be viewed as attack steps ($N_{r}=\{2,4\}$). Primitive facts (visualized as rectangles) correspond to the information given as input ($N_{p}=\{5,6,7,8\}$), while derived facts (visualized as diamonds) are the results of applying interaction rules on the primitive facts (can be viewed as attack step consequences; i.e., $N_{d}=\{1,3\}$). An edge $e\in E$ can connect between a primitive or derived fact and a derivation ($e\in\{(N_{p}\cup N_{d})\times N_{r}\}$), or between a derivation and a derived fact ($e\in\{N_{r}\times N_{d}\}$). The derivation nodes imply an and relation between their incoming nodes, which represent the preconditions for performing the corresponding actions; while the derived fact nodes imply an or relation between their incoming nodes, which represent the various actions that result in the same consequence.

III Related Work

The main limitation of MulVAL is that it only considers software vulnerabilities and does not address vulnerabilities in the design of network protocols. Previous studies focused on extending the expressibility of MulVAL’s security model. Appendix A presents a comparison between MulVAL’s modeling, previously suggested extensions, and our proposed extensions.

Froh *et al. * [21, 22] developed two extensions for MulVAL. The first extension includes three main improvements: a more realistic network model that includes subnets and routers; modeling of data authorization policies; and an algorithm for prioritizing attack paths based on their impact on the organization. The second extension includes modeling of additional safeguards (e.g., application level authentication) and a definition of high-level IT services for better attack graph analysis. Although these extensions produce more realistic modeling, they are limited to software vulnerabilities and cannot be used to model vulnerabilities in network protocols or modern IT networks (such as those that include wireless communication).

These works, however, focus on the efficiency and post-assessment of the attack graph and not on extending the framework to represent additional scenarios.

Acosta *et al. * [9] extended MulVAL to represent a specific data link vulnerability through which the ARP spoofing attack can be modeled. In this study, we propose a comprehensive network model, which considers the seven layers of the OSI model, supports wireless and short-range communication protocols, and models specific industrial communication architectures. Our proposed modeling enables the representation of various attacks on the physical, data link, network, and application layers. Furthermore, we develop a prototype system that automatically collects network configurations, converts them to MulVAL’s input, and generates the attack graph.

IV Network Modeling

IV-A Overview

In order to support more realistic network modeling, we added new predicates and interaction rules to MulVAL’s original rule set (presented in [23]). These predicates can be categorized into: physical network topology, network communication, principal access, host configuration, and vulnerability.

In our extended modeling, IT networks are modeled using the following three layers: link, end-to-end, and application, as presented in Figure 3. The link layer integrates the network topology, users’ actions, protocols, and vulnerabilities that are associated with a specific network zone (e.g., ARP spoofing in a subnet or WEP cracking). The end-to-end layer represents communication between specific hosts and services in remote hosts (OSI layers 3-7); it models the ability of two hosts to communicate using various protocols (e.g., FTP, HTTP) and the vulnerabilities existing in these protocols. The application layer represents the user data and the data generated as a result of an end-to-end communication (e.g., the transmission of an e-mail). To represent the connectivity between hosts in each layer, we defined the $l2Connection$, $aclNW$, and $dataFlow$ predicates. We also defined predicates that bind the different layers of communication. The $flowBind$ predicate associates an end-to-end protocol with a data flow, and the $relay$ predicate associates a physical host with a data flow or an end-to-end communication. Since $l2Connection$ and $relay$ represent physical connections and components, they are categorized as physical network topology; $aclNW$, $dataFlow$, and $flowBind$ are related to end-to-end and application communications, thus, are categorized as network communication. It is important to bind between the different layers because attacks on a lower layer can affect the upper layers of the communication. For example, transmitting plain-text data over an encrypted end-to-end protocol can be considered safe; however, if an attacker succeed to break the end-to-end encryption he/she can read the transmitted data.

We also model principals’ access to hosts in each layer. The $l2Access$ and $netAccess$ predicates express a principal’s access to a host in the link and end-to-end layers, respectively, while the $accessLinkFlow$, $accessE2EFlow$ and $acessDataFlow$ predicates express the principal’s access to the corresponding layer’s communication.

Vulnerabilities are classified into host, protocol, and data, according to their range of impact, and they are represented by the following predicates: $vulHost$, $vulLinkProtocol$, $vulE2EProtocol$, and $vulData$. A detailed description of the proposed extended network modeling follows.

IV-B Physical Network Topology

Network Architecture and Components (see Listing 1). In order to bind an entity (e.g., a user or a host) to a network zone, MulVAL uses the located predicate (line 1). We find this coarse definition of zone insufficient for modeling the physical network topology. Hence, we extend the located predicate to specify the type ($Type$) of a network zone (line 2): an IP subnet to which $Host$ belongs ($ipSubnet$), a serial bus to which $Host$ is physically connected ($bus$), or the physical location (position) of $Host$.

To indicate the usage of a specific link layer protocol in a zone (e.g., serial Modbus in a bus) we introduce the existingProtocol predicate (line 3). For example, $existingProtocol(subnet1,arp)$ indicates that hosts in $subnet1$ use ARP.

To be able to model network components (e.g., switch or router) in the physical network topology, we define the relay predicates. We distinguish between three types of network relays: a link layer relay that controls the entire communication between $SrcHost$ and $DstHost$ (line 4); a network layer relay that controls the communication of $SrcHost$ and $DstHost$ on a specific protocol ($Prot$) and port ($Port$) (line 5); and an application layer relay that controls the communication of a specific application data flow (line 6).

We also define predicates that provide an indication about specific roles of network components (lines 7-11). The $isGateway$ predicate indicates that $Router$ is the gateway of $Subnet$ (line 7). The $isAP$ predicate provides an indication regarding an access point that broadcasts to a $WirelessRange$ and is connected to a $DstZone$ (line 8); whereas, the $Prot$ argument specifies which protocol is used to establish the wireless connection (e.g., WEP), and the $SecurityConf$ argument specifies whether the access point uses a secured protocol ($SecurityConf=secured$) or is open to any connection request ($SecurityConf=open$). The $isNameResolver$ predicate indicates that $ResolverHost$ is the name resolver that is queried by $UserHost$ for finding the IP address associated with the name denoted by $Searched$ (line 9).

Finally, the $isMaster$ and $isSlave$ predicates are used to indicate master/slave components that are common in serial buses. The master device issues commands to others (i.e., initiates the communication), and the slave components respond to the master’s commands (lines 10-11). It is important to distinguish between these two roles, since they affect the attacker’s capabilities in a serial bus.

Network Connectivity (see Listing 2). Within MulVAL, the communication between hosts is represented by the $hacl$ predicate, which represents an abstraction of some host’s ability to reach another after considering the network’s topology and security configurations [23] (e.g., if there is a firewall denying the communication between two hosts, an hacl fact will not be generated). We find this abstraction unsuitable for modeling the link and physical layers connections. As mentioned, we distinguish between the link layer connectivity (which is not addressed by the original MulVAL modeling), and the end-to-end connectivity (which is originally addressed by the $hacl$ predicates). A link layer connectivity relates to the connections between hosts through a shared medium (e.g., Ethernet, Wi-Fi, Bluetooth, bus, etc.). We represent this type of connectivity using the l2Connection predicate (line 1), which indicates that two devices ($Dev1$ and $Dev2$) are connected via the same link ($LinkId$) of $Type$ and can communicate using protocol $Prot$. We consider the following three medium types:

Ethernet: an Ethernet link ($ipSubnet$) enables the connectivity between two devices ($Dev1$ and $Dev2$) located in the same IP subnet (lines 2-5). 2. 2.

Bus: a serial link ($bus$) enables the connectivity between two devices ($Dev1$ and $Dev2$) connected to it (lines 6-9). 3. 3.

Wireless: a wireless link ($Type=wireless$) enables the connectivity between two devices that are located within the same wireless range ($WirelessRange$). We support two wireless technologies: Wi-Fi and Bluetooth.

Wi-Fi enables the connectivity between a wireless device ($Dev$) and an access point ($AP$). We distinguish between an open access point (lines 10-12) and a secured access point (lines 13-16), in which the principal ($Principal$) is authenticated. When a host connects to an access point it becomes part of the subnet that the access point is connected to (denoted by $DstZone$); thus, we define the $located$ interaction rule (lines 17-20).

Bluetooth enables the direct connection between two devices ($MasterDevice$ and $SlaveDevice$) using the Bluetooth technology ($Type=bluetooth$). In this type of connection the two devices must be physically located within each other’s range ($BluetoothRange$). In addition, the $SlaveDevice$ must be in discovery mode (lines 21-25).

IV-C Network Communication

Application Layer Communication (see Listing 3). In our proposed modeling, the application layer represents data exchange between two entities. We model the communication in this layer using the $dataFlow$ predicate (lines 1-2). This predicate associates an application layer communication ($FlowName$) with the two hosts ($SrcHost$ and $DstHost$) that generated it (line 1). For bidirectional communication, the $Direction$ parameter is set to $twoWay$; otherwise, it should be set to $oneWay$. Subsequently, in some cases it is sufficient to associate only one communication end with $FlowName$; thus, we also define a shorter version of the $dataFlow$ predicate (line 2), where $Host$ is either the source or destination of the communication represented by $FlowName$. Communication (data) flows are also associated with end-to-end protocols (e.g., the transmission of an email can be associated with SMTP). To express this association, we define the $flowBind$ predicate (line 3).

Some attack scenarios rely on the attacker’s ability to exploit a specific type of data flow. For example, in order to execute a Bluetooth PIN cracking attack, the attacker needs to capture the packets transmitted during the pairing process. Thus, we include the definition of specific data flow types. An example is $isPairingProcess$ (line 4), which indicates that the data flow ($FlowName$) is the sequence of packets transmitted during a Bluetooth pairing process.

Access Control (see Listing 3). MulVAL represents the network access control policy by $hacl$ predicates, which take the physical topology of the network into account [23]. In our proposed modeling, we separate between the representation of physical topology and access control. We represent the network-based access control rules by the $aclNW$ predicate (line 6), which indicates that packets of protocol $Prot$, originating in host/subnet ($SrcHostOrsubnet$) and designated for a specific port ($Port$) in the host/subnet denoted by $DstHostOrsubnet$, are allowed. Host-based access control modeling will be described in Section IV-E.

IV-D Principal Access

The human aspect must also be taken into account when modeling network access. To be consistent with our three-layer network modeling, we define a principal access predicate for each layer: host access, network access, and data access.

Host Access (see Listing 4). Refers to the ability of a principal to login to a host. This type of access is represented by the $localAccess$ predicate (line 1), which indicates that a principal ($Principal$) can access a host ($Host$) using the user account denoted by $User$. A principal access to a host can also be inferred from the following two scenarios: (1) an attacker who is located in a host has access to that host (lines 2-3), and (2) a principal that has local access to a host ($HostA$) can use it to gain access via the network to a remote host ($HostB$) by using a network login service and a previously obtained account (lines 4-9).

Network Access (see Listing 5). Similar to the network topology and communication, we distinguish between the principal’s direct access to a host through the link layer (e.g., access a component via a serial bus) and by using an end-to-end protocol (e.g., sending an email using SMTP).

Link layer access is represented by the $l2Access$ predicate (line 1) which indicates that a principal ($Principal$) can access $DstHost$ from $SrcHost$ via the medium denoted by $LinkID$. The $Type$ argument refers to the type of medium (similar to the $l2Connection$ predicate), and the $Prot$ argument specifies the protocol used in that medium (e.g., Modbus, WEP). The ability of a principle to access a host via a shared communication medium is inferred by the interaction rule in lines 2-4: a principal ($Principal$) with local access to $SrcHost$ can access $DstHost$, assuming that they are both connected to a shared medium $LinkID$.

In the end-to-end layer, the ability of a principal to access hosts is represented by the $netAccess$ predicate (line 6), which indicates that $Principal$ can use $SrcHost$ to communicate with $DstHost$ on a specific port ($Port$) using the protocol $Prot$. This fact is inferred by the interaction rule in lines 7-10: a principal ($Principal$) with local access to $SrcHost$ can communicate with $DstHost$ on $Port$ using the protocol $Prot$ if this communication is enabled by the network access control mechanisms (represented by $aclNW$) as well as the $DstHost$’s access control mechanisms (represented by $aclH$).

Data Access (see Listing 6). We distinguish between two types of data: data at rest and data in motion. Access to data at rest is modeled in MulVAL by the $accessFile$ predicate (line 1), which indicates that $Principal$ can access files in $Path$ present in $Host$ with $AccessPerm$ permissions (read, write, or execute). We extend MulVAL to model access to data in motion as well by defining the $accessDataFlow$ predicate (line 3), which indicates that $Principal$ has access to the data flow denoted by $FlowName$. There are three possible access types: (1) view - the principal is able to view $FlowName$ but not necessarily read its content, (2) read - the principal can read the content of $FlowName$, i.e., see it in plain text, and (3) write - the principal can manipulate the data in $FlowName$. These access types can contain each other: if a principal can read a data flow, he/she can also view it; and if a principal can write to a data flow, he/she can also read it.

The interaction rules in lines 4-8 and 9-14 describe the ability to view wireless traffic. Lines 4-8 describe a scenario in which a principal’s host ($SideHost$) is located in the wireless range ($WirelessRange$) of the communication between $HostA$ and $HostB$. Based on the assumption that $SideHost$ is equipped with a network interface, $Principal$ can capture the wireless traffic in that range. Similarly, lines 9-14, describe a scenario in which the $SideHost$ is positioned in the broadcast range of a device (e.g., access point) that is a relay to the communication that the principal wishes to capture.

To be consistent with the three-layer network model, we also defined accessLinkFlow and accessE2EFlow predicates (lines 16-17) in order to represent a principal’s access to the communication in these layers. We also included interaction rules to bind protocol vulnerabilities with the data access level they permit across the network layers. These definitions are important, since actual attacks tend to be executed in this step-by-step manner, thus they make our model realistic and practical.

Figure 4 presents an example of this. In the first step (denoted by ①), an attacker who can access the link layer (e.g., by connecting his/her laptop to a layer two switch) can try to exploit link layer vulnerabilities (specified by the $vulLinkProtocol$ predicate). If the attacker succeeds, he/she will be able to view the end-to-end layer flow (represented by $accessE2EFlow$ with the $view$ access type). In the next step (denoted by ②), the attacker can try to exploit an end-to-end protocol vulnerability (represented by the $vulE2EProtocol$ predicate). If the attacker succeeds, he/she can read the end-to-end layer flow (represented by $accessE2EFlow$ with the $read$ access type), which means that the attacker can view the data flow (represented by $accessDataFlow$ with the $view$ access type). In the final step (denoted by ③), the attacker can try to read the data flow (represented by $accessDataFlow$ with the $read$ access type) by attempting to exploit data vulnerabilities (represented by the $vulData$ predicate).

IV-E Host Configuration

To represent host-based attacks we need to be able to indicate the characteristics of programs (e.g., login service), data (e.g., credentials), and access control configuration that are present on the host. All of the predicates related to host configuration are presented in Listing 7.

Data. Some attack scenarios rely on the attacker’s ability to access sensitive content. Therefore, we introduce specific predicates to represent special data types. The $isCredential$ predicate indicates that the data denoted by $DataName$ is the credentials of $User$ on $Host$ (line 1). This predicate can also be used to indicate that a data flow contains credentials (e.g., in the case of remote login).

Another sensitive data type relates to name resolvers (e.g., DNS servers), i.e., the binding between a naming and an IP address. This data is represented by the $isNameResolverRecord$ predicate (line 2), which is used in the modeling of the DNS spoofing attack (see subsection V-A).

In addition, we provide the $dataBind$ predicate (line 3) to associate data ($DataName$) with a specific path ($Path$) in a host ($Host$).

Program. MulVAL defines two types of programs: network services and login services. A network service is a program running under some user permissions on the host while listening on a specific port and communicates with other instances using a specific protocol (line 5). A login service is a program that provides a user the ability to access the host (line 6).

We introduce a third type of program, local service, which represents any program running on a host, regardless of its ability to communicate over the network (line 7). This way we can model multistep attacks that exploit vulnerabilities in ”offline” services (e.g., exploit a vulnerable PDF reader by providing it with a malformed file).

In addition, we include the $dependsOn$ (line 8) and $bugHype$ (line 9) predicates. The $dependsOn$ predicate indicates that a program (denoted by $Prog$) running on $Host$, depends on some library (denoted by $Library$). This predicate is important for representing vulnerabilities that come from third party libraries or programs.

The $bugHype$ predicate indicates that a software bug is present in the program (denoted by $Prog$) running on a host (denoted by $Host$). The meaning of the $Range$ and $Consequence$ arguments is similar to those specified in the vulnerability predicates, and are explained in the following Section.

Access Control. The host-based access control rules are represented by the $aclH$ predicate (line 11), which indicates that the local access control mechanism on $Host$ allows $User$ to communicate from the host/subnet denoted by $SrcHostOrsubnet$ with the host/subnet denoted by $DstHostOrsubnet$ on $Port$ using the protocol $Prot$.

IV-F Vulnerability

Vulnerabilities are modeled in MulVAL using the $vulExists$ and $vulProperty$ predicates [23]. These predicates, however, do not provide a clear distinction between different types of vulnerabilities; thus, we define three vulnerability predicates according to the assets they affect: $host$, $network$, and $data$.

Host (see Listing 8). A host vulnerability (e.g., a vulnerability in a software running on the host) is represented by the $vulHost$ predicate (line 1) defining a specific vulnerability ($VulID$) in a program ($Prog$) that exists in $Host$. The $Range$ argument refers to the context in which the vulnerability can be exploited and can be set to $localExploit$, $adjacent$, or $remoteExploit$ - similar to the attack vector (AV) metric of CVSS.222https://www.first.org/cvss/ We also include interaction rules that represent a host vulnerability due to an implementation bug (lines 2-3) or dependency in a vulnerable library (lines 4-6), similar to their basic definition in MulVAL [23].

Network (see Listing 9). A network vulnerability (i.e., a vulnerability in a communication protocol) is represented by the vulLinkProtocol (lines 1-2) and $vulE2EProtocol$ (lines 9-10) predicates. The $vulLinkProtocol$ predicate in line 1 defines a vulnerability in a link layer protocol denoted by $Protocol$ (e.g., ARP, Bluetooth, WEP) that is used in some communication medium ($LinkID$) and contains the vulnerability $VulID$ that can be exploited via $Range$, and results in $Consequence$ (e.g., eavesdropping, data falsification). The predicate in line 2 has a similar meaning, except that it provides an indication of a directed communication between two specific hosts ($SrcHost$ and $DstHost$).

We also define the $vulLinkProtocol$ interaction rule in lines 3-7, which infers a vulnerable link layer communication between $SrcHost$ and $DstHost$ from the fact that they are connected to the same communication medium ($LinkID$), in which a vulnerable link layer protocol ($Protocol$) is used. Note that this interaction rule only holds for $ipSubnet$ or $bus$ medium types.

The $vulE2EProtocol$ predicate represents the use of an end-to-end protocol denoted by $Protocol$ (e.g., HTTP, SMTP) in the communication between two hosts on port $Port$ which contains the vulnerability $VulID$ that can be exploited via $Range$ and results in $Consequence$. The predicate in line 9 indicates that $Host$ is either the source or destination of the vulnerable communication, and the predicate in line 10 represents a directed vulnerable communication.

Data (see Listing 10). Representing vulnerable data (e.g., unencrypted/unsigned communication between two hosts or unencrypted files on a host) is important to avoid detection of false attack paths. For example, an encrypted sensitive document will be protected from an eavesdropping attacker even if it is being exchanged between two hosts over FTP. We distinguish between vulnerable data at rest (e.g., a file stored on a host) and vulnerable data in motion (e.g., network traffic exchanged between two hosts).

Vulnerable data at rest is represented by the $vulData$ predicate (line 1), where $Data$ (e.g., a file) has the vulnerability $VulID$ (e.g., unsigned) which can result in $Consequence$ (e.g., data falsification). We also provide the ability to associate a vulnerability with a specific range in some host’s memory by defining the $vulBind$ predicate (line 2). This predicate indicates that upon successful exploitation of $VulID$, all of the data stored in $Path$ in $Host$ will be affected (e.g., read by the attacker).

Vulnerable data in motion (i.e., a data flow) is represented by the $vulFlow$ predicate (line 4), which indicates that $FlowName$ contains a vulnerability denoted by $VulID$ (e.g., unencrypted) that enables $Consequence$ (e.g., eavesdropping). Since data flows are related to the communication between two hosts via the network, we infer their vulnerabilities from communication protocol vulnerabilities. We consider two vulnerability types: lack of encryption and lack of a signature.

The interaction rule in lines 5-10 describes a scenario of an insecure data flow between $SrcHost$ and $DstHost$ (represented by the $dataFlow$ and $flowBind$ predicates) that is exchanged using an insecure end-to-end protocol and an insecure link protocol (represented by the $vulE2EProtocol$ and $vulLinkProtocol$ predicates), while the payload itself (e.g., a file) is not encrypted (represented by the $vulData$ predicate).

Similarly, in lines 11-17 the flow is only vulnerable within a specific zone. This situation can occur when: (1) the flow is transmitted via a relay host (e.g., a router or proxy) that is connected to the same zone as $SrcHost$, in which a vulnerable link protocol that enables eavesdropping is used (represented by the $vulLinkProtocol$ predicate); (2) the flow is transmitted using a vulnerable end-to-end protocol that can be exploited from the relay host and enable eavesdropping (represented by the $vulE2EProtocol$ predicate). The symmetric case (where the vulnerability exists in the zone of $DstHost$) can be defined in the same manner.

The interaction rule in lines 18-22 describes the scenario of eavesdropping on an unencrypted link (e.g., bus). In order for data to be vulnerable to link eavesdropping, it should be unencrypted (represented by the $dataFlow$ and $vulData$ predicates) and it should also be transmitted via a vulnerable link protocol (represented by the $vulLinkProtocol$ and $flowBind$ predicates).

The interaction rule in lines 23-27 describes a scenario in which unsigned data (represented by the $dataFlow$ and $vulData$ predicates) is transmitted via a vulnerable end-to-end protocol that enables data falsification (represented by the $vulE2EProtocol$ and $flowBind$ predicates).

V Attack Modeling

In this section, we demonstrate how the proposed network modeling can be used to model network attacks, including: spoofing attacks, denial of service attacks (DoS), man-in-the-middle (MITM) attacks, attacks on wireless communication, and attacks on bus network architecture.

V-A Spoofing Attacks

We distinguish between two types of spoofing attacks: spoofing in the link layer, in which the attacker can spoof the entire communication between the two hosts, and spoofing in the end-to-end layer, in which the attacker can spoof a specific service. These two scenarios are represented using two predicates: $spoofLinkHost$ (Listing 11, line 1) and $spoofE2EHost$ (Listing 12, line 1), which specify that a principal ($Principal$) can impersonate $ImpersonatedHost$ and fool $FooledHost$ using the $SpoofingHost$ by utilizing a vulnerability in a link/end-to-end protocol. The $Consequence$ argument provides an indication about the outcome of the spoofing attack: (1) the traffic is routed via $SpoofingHost$, e.g., in an ARP spoofing scenario ($Consequence=trafficTheft$); (2) $Principal$ can only deceive $FooledHost$, e.g., in bus spoofing scenarios ($Consequence=deception$). We modeled the ARP and DNS spoofing attacks using these two predicates.

ARP Spoofing (see Listing 11). ARP spoofing is a technique by which an attacker can route the traffic intended for some host to the attacker’s machine. The attacker achieves this by sending fake ARP messages to a local area network (LAN) in order to associate the attacker’s MAC address with the IP address of the victim’s host. In order to perform an ARP spoofing attack, two preconditions must be satisfied: (1) the impersonated host must use the vulnerable ARP protocol; and (2) the attacker must be able to access the impersonated host via the link layer.

In our modeling we consider two ARP spoofing scenarios: a scenario in which the impersonated and fooled hosts reside in the same subnet (lines 3-5), and a scenario in which they reside in different subnets (lines 6-10). The two preconditions for performing this attack are represented in both scenarios by the $vulLinkProtocol$ and $l2Access$ predicates.

DNS Spoofing (see Listing 12). In our modeling, we consider three DNS spoofing scenarios: (1) a scenario in which the attacker spoofs as the name server and provides malicious binding for legitimate requests, (2) a scenario in which the attacker provides a fake response by utilizing a race condition (i.e., answers faster than the legitimate server), and (3) a scenario in which the attacker changes DNS records in the name server/host cache.

The first DNS spoofing scenario can be represented directly by the $spoofE2EHost$ interaction rules that result in $trafficTheft$, in which the argument $ImpersonatedHost$ matches the identifier of the DNS server.

The second DNS spoofing scenario is more complicated, since the attacker utilizes the response time of a higher DNS resolver in order to send a fake response to the querying DNS server, binding the attacker’s host’s IP address to the queried naming. Hence, in order to execute this attack, the DNS server should communicate using a vulnerable version of the DNS protocol. As can be seen in lines 3-6, this prerequisite is represented by the $isNameResolver$ and $netAccess$ predicates. Following the successful execution of this attack, the querying host ($FooledHost$) will initiate communication with the attacker’s host (which can be $AttackerHost$ or any other host) instead of the real host.

The third DNS spoofing scenario can be executed by gaining access to the DNS server with admin privileges. We modeled this scenario in lines 7-11; as can be seen, the attacker ($Principal$) can log in using local access ($localAccess$ predicates) to the DNS server and modify the DNS records to associate the attacker’s host with a naming of his/hers choice. The success of the attack depends on the ability of the fooled host to access the attacker’s host through the network (expressed by the $netAccess$ predicate). Alternatively, this scenario can be executed by gaining $write$ access permission to some path in the DNS server, which happens to contain a DNS record. We modeled this scenario in lines 12-16.

V-B Denial of Service Attacks

We extend MulVAL’s dos predicate in order to indicate who is performing the attack (see Listing 13, line 1) as well as to support host-based (lines 3-7) and network-based (lines 8-13) DoS attacks. In a host-based DoS attack, the attacker $Principal$ (represented by the $malicious$ predicate) exploits his/her login access to $Host$ (represented by the $localAccess$ predicate) which runs a vulnerable service that allows DoS (represented by the $localService$ and $vulHost$ predicates). In a network-based DoS attack, the attacker $Principal$ exploits his/her access to a network service running on $DstHost$ (represented by the netAccess, aclH, and networkService predicates), which contains a vulnerability that enables DoS upon successful exploitation (represented by the $vulHost$ predicate).

V-C Man-in-the-Middle Attacks

A man-in-the-middle (MITM) attack is a scenario in which the attacker manages to pose as a relay of the communication between two hosts. We distinguish between a MITM attack in the link layer (Listing 14, lines 1-6), in which the entire communication between $SrcHost$ and $DstHost$ is routed through the attacker’s host ($AttackerHost$); and a MITM attack in the end-to-end layer (Listing 14, lines 8-12), in which only a specific application layer protocol (represented by the $Port$ and $Prot$ arguments) is routed through the attacker’s host.

V-D Attacks on Wireless Communication

One of the main contributions of this work is the ability to model attacks on wireless communication. Specifically, we model two common attacks on wireless protocols: WEP cracking and Bluetooth PIN cracking, both of which enable the attacker to derive the encryption key used for the secured communication.

WEP Cracking (see Listing 15). The Wired Equivalent Privacy (WEP) algorithm is based on the RC4 stream cipher which has weak key scheduling and uses a small initial vector (IV) of 24 bits [24]. In order to crack WEP’s encryption, the following two preconditions must be satisfied: (1) the attacker must capture a large amount of legitimate packets transmitted to/from the access point; and (2) the access point must use the vulnerable WEP protocol. Afterwards the attacker can crack the encryption key by performing offline analysis [24]. These two preconditions are modeled by the $crackAPEncKey$ interaction rule (lines 1-6), which utilizes the $accessDataFlow$, $relay$, $isAP$, and $vulLinkProtocol$ predicates.

By cracking the encryption key, the attacker can (1) eavesdrop on all of the traffic broadcasted by the compromised access point; and (2) authenticate to the access point. These two different consequences are represented by the $accessDataFlow$ and $isAuthenticated$ interaction rules (lines 8-22).

WPA2 Key Reinstallation. (see Listing 16). The Wi-fi Protected Access II (WPA2) protocol is widely used for protecting wireless networks. The Key Reinstallation Attack on the WPA2 protocol, which exploits a vulnerability in the 4-way handshake and tricks the victim into reinstalling an already in-used key, was published in 2017 by Vanhoef and Piessens [25]. The 4-way handshake is used for assuring that both client and access point has the correct credentials, and to negotiate an encryption key for encrypting future communication. The encryption key is installed in the client after receiving the \nth3 handshake message. If no acknowledgment is received (i.e., the \nth4 handshake message), the access point might retransmit the \nth3 handshake message to handle messages loss. Upon receiving this message, the client reinstalls the same encryption key and resets the nonce, which is also used in the derivation of the encryption key. As a result, an already used encryption key with a previously used nonce is used to further encrypt packets. Then, the attacker can derive the WPA2’s encryption protocols keystream by using an encrypted message with a known content (or other methods when no such messages are found). In short, the key reinstallation attack is performed by the following two steps: (1) The attacker becomes a MITM between the host and the access point (e.g., by channel-based MITM technique [26]); and (2) the attacker prevents the \nth4 handshake message from reaching the access point, which causes the retransmission of the \nth3 message.

This scenario is represented by the interaction rule in lines 1-9. Lines 1-4 and 9 describe that the attacker’s host ($AttackerHost$) and the victim’s host ($Host$) are located in the same zone, so that the attacker is able to perform the first step of the attack (MITM). The $flowBind$ predicate in line 5 suggests that a data flow is transmitted using a specific protocol; in addition, the $isCredential$ predicate in line 6 provides indication that this data flow is part of the protocol’s handshake (which the attacker plans to interrupt). Lines 7-8 describe that the access point that defined the zone ($WirelessRange$), in which both the attacker’s host and victim’s host are locates, uses a vulnerable communication protocol version that allows the execution of the key reinstallation attack. Thus, enabling the attacker to decipher future communication between the victim’s host and the access point.

Furthermore, the authors in [25] found an additional vulnerability in several WPA2 implementations that reinstall an all-zero encryption key upon retransmission of \nth3 handshake message. The corresponding interaction rule is presented in lines 10-15. This rule uniquely described this version of the key reinstallation attack by requiring that the communication protocol will be vulnerable to key reinstallation attack and that the victim’s host ($Host$) will run a vulnerable version of the process (wpa_supplicant) that enables for reinstalling the all-zero key. The $accessLinkFlow$ in line 12 implies that the attacker ($Principal$) managed to crack the encryption of the communication protocol ($Protocol$) that is used to communicate with the access point; together with the requirement vulnerability requirement in line 14, the $accessLinkFlow$ predicate should represent the successful exploitation of the key reinstallation attack (i.e., the rule in lines 1-9 is derived). Note that since the attacker knows the actual key after performing this attack (sequence of zeros), this scenario is represented by a $CrackAPEncKey$ rather than an $acessLinkFlow$ predicate.

Bluetooth PIN Cracking (see Listing 17). In 2005, Shaked *et al. *[27] presented a method for cracking the shared secret (referred to as PIN code) of two devices establishing a Bluetooth communication (using offline analysis). In order to execute the attack, the attacker must eavesdrop on the entire pairing process between the two devices. This precondition is represented by the $crackPINCode$ interaction rule (lines 1-6). As can be seen, the attacker $Principal$ (represented by the $malicious$ predicate) can read the messages exchanged by two devices (represented by the $accessDataFlow$, $dataFlow$, and $flowBind$ predicates) during their pairing process (represented by the $isPairingProcess$ predicate). After capturing the messages, the attacker can perform the offline analysis presented in [27]. The consequence of this attack is that the attacker acquires the capability to decipher the communication between $SrcHost$ and $DstHost$; we represent this capability using the accessDataFlow interaction rule (lines 8-13).

V-E Attacks on Bus Communication

Another major contribution of our work is the definition of serial bus topology, which can be found in critical infrastructure. In this section, we describe how DoS and spoofing attacks can be applied to bus architecture and how they can be modeled using our suggested network modeling.

Denial of Service. In bus topology, all of the devices are physically connected to the same physical medium in order to communicate. A DoS attack on a serial bus can be executed in several ways, e.g., a compromised device can continually broadcast data and cause collisions on the bus, or a compromised device can broadcast data when detecting a data transfer to/from a specific device in order to prevent it from requesting service or transmitting data (i.e., DoS for a specific device). Therefore, just one of the devices connected to a bus needs to be compromised in order to cause a DoS for all of the other connected devices.

To represent these scenarios, we define the $dos$ interaction rule (Listing 18, lines 1-3), which reflects the fact that the attacker $Principal$ (represented by the $malicious$ predicate) can utilize his/her local access (i.e., login or ability to execute code) to a device connected to a bus in order to deny service to any other device connected to that bus (represented by the $l2Access$ predicate).

Master/Slave Spoofing. Spoofing attacks on serial protocols are largely feasible due to the lack of authentication (e.g., serial Modbus used in OT systems). In our current modeling, we only consider master/slave buses. We distinguish between two spoofing scenarios: (1) a compromised device connected to the bus masquerades as the master and sends fake data and commands, and (2) a compromised device connected to the bus masquerades as a slave and sends false data. We distinguish between these two cases, since the abilities of the attacker can be affected by the role of the compromised component (i.e., a master or slave). Since we represent serial bus communication, the bus spoofing attack scenarios are represented as $spoofLinkHost$ interaction rules.

The master spoofing scenario is represented by the interaction rule in Listing 18, lines 5-9. In this scenario, the attacker $Principal$ can log in to the $AttackerHost$ (represented by the $localAccess$ predicate) which is connected to the same bus as $FooledHost$ (represented by the $l2Connection$ predicate). By exploiting a vulnerability in the communication protocol used by $ImpersonatesHost$ and $FooledHost$ (represented by the $vulLinkProtocol$ predicate), $Principal$ is able to impersonate as $ImpersonatesHost$, which is the master in the bus ($isMaster$).

The slave spoofing scenario is represented by the interaction rule in Listing 18, lines 10-14, which is similar to the master spoofing scenario, except for the fact that $ImpersonatesHost$ is a slave in the bus (represented by the $isSlave$ predicate) and not the master.

VI Prototype Implementation of Automatic Fact Generation Process

The main advantage of MulVAL over other attack graph solutions is that it provides an end-to-end framework for attack graph generation. In order to preserve this strength, we developed a prototype system which automatically collects relevant information from the target system and generates the facts about the system with respect to the new network modeling (presented in Section IV). This prototype implements the following four fact generation methods:

Scan: facts that are generated directly from scan results; i.e., there is a complete mapping between the predicate’s arguments and data in the scan results. A summary of the various tools that are used by the prototype system is presented in Table I. It should be noted that the current version of the prototype implementation supports the scanning of IP networks only.

Knowledge: facts that are generated using a knowledge base. The knowledge base contains general and system specific information, such as program characteristics, system configuration, etc.

Assumption: facts that are generated with default values (e.g., unknown or a wildcard).

Manual: facts that are generated manually, based on information provided by the operator/security expert, such as attackerLocated, attackGoal and malicious(attacker).

A complete mapping of the four methods to predicates is presented in Appendix C.

VII Evaluation

In order to evaluate the application of our proposed modeling in a real environment, we established an operational testbed simulating a simple thermal power plant process (see Figure 5).

The testbed consists of: five generators, a boiler, a control panel, three programmable logic controllers (PLCs), an engineering work station (EWS), a historian, a human machine interface (HMI), a Windows workstation, a Windows server, a DNS server, an access point, and a laptop. There are two subnets: IT Network (the enterprise environment) and OT Network (the OT environment) which are connected by a firewall. IT Network is also connected to the Internet. Bluetooth Zone defines the range in which PLC#1 can communicate with Generator#3 using Bluetooth. IT Wifi Zone is defined by the access point (denoted by AP), which provides access to IT Network for each authorized wireless device (e.g., the laptop) within IT Wifi Zone. DNS Server is the name resolver in IT Network, which uses a vulnerable DNS protocol and accepts incoming communication from any host in IT Network.

The enterprise hosts, HMI, EWS, and historian are virtual machines, that run a Windows Operating System, except for the historian which runs Linux. The behavior of the boiler and generators is simulated in the PLCs. In order to collect real data from the testbed, we connect an instance of the prototype system to each network switch (denoted by agent in Figure 5).

To ease readability, the graphs’ nodes are marked as follows: blue nodes are associated with the system’s topology and connectivity; red nodes are associated with vulnerabilities and the attacker’s state; orange nodes are associated with software and services; and purple nodes are associated with data flows.

In this section, we evaluate the attack scenarios presented in Section V.

VII-A ARP Spoofing Attack

Commonly used in IP networks, ARP is also used in the OT Network. For simplicity and readability of the attack graph, we assume that the attacker has already managed to gain access to the HMI in order to execute the attack. After placing him/herself in the OT Network, the attacker can further exploit the use of ARP to impersonate any of the components in the subnet and eventually obtain a MITM position in the communication between the components. The attack graph presented in Figure 6 illustrates the attacker’s steps in this attack scenario, where the attacker’s goal is to become a MITM in the communication between EWS and PLC#1. Since the attacker is located in HMI (nodes 7-9), which resides in the OT network as EWS and PLC#1 (nodes 15, 18, 23), he/she can access them both utilizing ARP that is used in this subnet (nodes 5-6, 10-12, 29-32). Then, by exploiting the vulnerable ARP bidirectional communication between EWS and PLC#1 (nodes 19-20, 26, 33-34), the attacker is able to impersonate both EWS and PLC#1 (nodes 3-4, 27-28). Finally, as a result of this bidirectional spoofing which causes the entire communication between EWS and PLC#1 to be routed via the attacker, we infer that the attacker is a MITM (nodes 1-2).

VII-B DNS Spoofing Attack

In this scenario, an attacker that placed his/her host in the IT Wifi Zone, manages to connect to the IT Network via AP. Then, the attacker exploits the vulnerable DNS protocol used by DNS Server to poison its cache and bind Windows Server’s naming to the attacker’s IP address; the next time that someone queries for Windows Server’s address, the attacker’s IP will be returned, and the user will communicate with the attacker thinking it is really Windows Server.

The attack graph generated for this scenario is presented in Figure 7. The attacker can become a part of IT Network (nodes 10-11) by connecting to AP (nodes 15-17, 20, 23), which is linked to that subnet. In so doing, the attacker can communicate with DNS Server (nodes 3-4), since they are both connected to the same subnet (nodes 5-6, 9-10), and the attacker controls his/her device’s configuration (nodes 26-29). Then, the attacker can exploit the vulnerability in the DNS protocol (nodes 32-33) and execute the DNS spoofing attack.

VII-C SYN Flooding Attack

SYN flooding is a network-based DoS attack in which an attacker starts multiple TCP connections with the target host but doesn’t complete them. In the vulnerable TCP implementation, the target host saves all of the half-open connections, which eventually exhausts the host’s resources and makes it unresponsive to other connections.

Within the testbed, the Historian supports remote connection via SSH, which relies on TCP, and contains a vulnerable TCP implementation that allows the execution of the SYN flooding attack. In this scenario we assume that the attacker managed to gain access to Windows Server and execute the attack from it. The attack graph for this scenario is presented in Figure 8. The attacker, who is located on Windows Server (nodes 16-18), can utilize it to start a TCP connection with Historian on port 22 (nodes 3-4), since both the network-based and the host’s host-based firewalls allow this connection (nodes 5-6, 9, 12 15). The SSH service executed by Historian (node 29) is vulnerable to the SYN flooding attack (nodes 20-22, 25), and together with the facts that (1) Historian allows incoming communication from Windows Server on port 22 (node 28), and (2) the attacker is able to initiate this communication (nodes 3-4), we conclude that the attacker can perform an SYN flooding attack on Historian (nodes 1-2).

VII-D WEP Cracking Attack

In this scenario, the attacker physically places his/her host in the range of the access point (i.e., in IT Wifi Zone), which is connected to IT Network. Based on the assumption that the attacker’s host is adequately equipped to execute this attack, we infer that the attacker can capture the wireless signals transmitted in IT Wifi Zone. The access point uses WEP, which has a known vulnerability that allows key extraction, as its security protocol. One of Laptop’s uses is to browse emails which results in communication with Windows Server.

The attack graph for this scenario is presented in Figure 9. As can be seen, AP connects IT Network with IT Wifi Zone (node 12). Since Windows Server is connected to AP in IT Network (nodes 26-28, 31, 34), and Laptop can connect to AP in IT Wifi Zone (nodes 11-12, 35-36, 39), we can infer that AP is a relay to the communication between Laptop and Windows Server (nodes 21-23). Since the attacker physically located his/her device in IT Wifi Zone (nodes 3-5 and 8), the attacker can capture the communication between Laptop and Windows Server that is transmitted in the wireless zone (nodes 45-46). Now, the attacker can exploit WEP’s the weak encryption, which is used by AP (node 44), and perform offline analysis on the captured traffic in order to extract AP’s encryption key (nodes 40-41). There are two consequences of this attack: (1) the attacker’s device is authenticated by AP, thus he/she is able to communicate freely with other hosts in IT Network (nodes 48-49); (2) the attacker can decipher the communication between any host and AP (nodes 1-2, 18).

VII-E Bluetooth PIN Cracking Attack

In this attack scenario, the attacker uses his/her device in order to capture the communication between two other Bluetooth components, which enables the attacker to perform the PIN cracking attack described in Subsection V-D.

In this scenario, the attacker is located in Bluetooth Zone with Attacker Device that is able to capture Bluetooth communication. The attack graph generated for this scenario is presented in Figure 10. The attacker, who managed to place his/her device in Bluetooth Zone (nodes 3-5 and 8), can view the communication between PLC#1 and Generator#3 (nodes 25-30, 33, 36-37). Given that this communication is the Bluetooth pairing process (nodes 19, 22), we can infer that the attacker can perform the PIN cracking attack (nodes 17-18). After executing this attack, the attacker has the encryption key of the Bluetooth communication between PLC#1 and Generator#3 and can read their future communication (nodes 1-2, 11, 14). Since the extracted key is symmetric, the encryption cracking also applies to the inverse communication direction (nodes 16-15, 39-17).

VII-F Bus Denial of Service Attack

To demonstrate attacks on the serial bus, we introduce the Serial Bus component, which connects * PLC#2*, two more generators (Generator#4 and Generator#5), and a third PLC (PLC#3). The serial Modbus is the communication protocol in this bus, and the master is PLC#2.

The attack graph generated for this attack scenario is presented in Figure 11. The attacker is located in HMI (nodes 24-26), which can communicate with other components connected to OT Network, in particular with PLC#2 on port 22 (nodes 11-14, 17, 20, 23). PLC#2 enables remote login via SSH service (nodes 7, 27). The attacker that managed to obtain PLC#2’s admin account (node 30) can now connect to it on port 22, since inbound communication from HMI is allowed (node 10), enabling the attacker to gain local access (nodes 5-6).

PLC#2 and Generator#4 can communicate via the bus using the Modbus protocol (nodes 31-33, 36, 39). Since the attacker has local access to PLC#2 (node 5), we infer that he/she can abuse it to access Generator#4 via the bus (nodes 3-4) and thus deny service to Generator#4 (nodes 1-2).

VII-G Bus Spoofing Attacks

The Modbus protocol used in Serial Bus is a master/slave communication protocol. In this type of communication, only one component (referred to as the master) is responsible for managing the operation of the other components (referred to as slaves) by sending command messages; the slaves only respond to the master’s commands.

The first spoofing attack scenario is focused on impersonating the bus master. We demonstrate how an attacker located in PLC#3 can exploit the lack of authentication in the serial Modbus protocol and impersonate the master of the bus (PLC#2) in order to send fake commands to Generator#4. The attack graph representing this scenario is presented in Figure 13(a).

PLC#3 and Generator#4 can communicate via the bus (nodes 7-9, 12, 15). PLC#2 and Generator#4 can also communicate via the bus using Modbus, which lacks authentication (nodes 12, 16-17, 20, 23). The attacker can exploit his/her access to the bus via PLC#3 (nodes 4-6, 15) and Modbus’s vulnerability and impersonate PLC#2 (the master) against Generator#4 (nodes 1-3).

The second spoofing attack is focused on spoofing as a slave (Generator#5) in order to provide a fake response to the master (PLC#2). The attack graph (see Figure 13(b)) is quite similar to the master spoofing scenario; the only difference is that we require the source of the vulnerable communication (node 16) to be a slave in the bus (node 3).

VIII Conclusion and Future Work

In this paper, we introduce an extended network modeling for the MulVAL framework and evaluated it in an operational testbed simulating a simplified thermal power plant process. The proposed modeling considers the physical network topology, supports short-range communication protocols, and models specific industrial communication architectures. Furthermore, we model various network attacks, including bus spoofing, WEP cracking, Bluetooth PIN cracking, ARP spoofing, and DNS spoofing.

In future work, we plan to (1) extend the capabilities of the prototype system to support the automatic extraction of additional facts (such as obtaining information about wireless devices); (2) model additional network protocols (such as Zigbee and BLE), wireless communication types (e.g., cellular communication) including the modeling of device mobility, and attack techniques; and (3) develop a process which utilizes the attack graph generated according to the extended modeling we presented in this paper to associate attack graph nodes with potential mitigation actions, resulting in a countermeasure plan that reduces the potential risk to the system.

Appendix A Comparison Between MulVAL Extensions

Appendix B Complete Input for the MulVAL Example

Appendix C Fact Generation Methods