Attack-resistant Spanning Tree Construction in Route-Restricted Overlay Networks

TL;DR

This paper introduces a cryptographically enhanced self-stabilizing spanning tree algorithm for route-restricted overlay networks, significantly improving resilience against active denial of service attacks.

Contribution

It presents a novel distributed spanning tree algorithm that incorporates cryptographic signatures to mitigate active attacks, a first in this context.

Findings

Reduces affected nodes by up to 74% in simulations

Proves theoretical robustness against active attacks

Applicable to real-world overlay networks

Abstract

Nodes in route-restricted overlays have an immutable set of neighbors, explicitly specified by their users. Popular examples include payment networks such as the Lightning network as well as social overlays such as the Dark Freenet. Routing algorithms are central to such overlays as they enable communication between nodes that are not directly connected. Recent results show that algorithms based on spanning trees are the most promising provably efficient choice. However, all suggested solutions fail to address how distributed spanning tree algorithms can deal with active denial of service attacks by malicious nodes. In this work, we design a novel self-stabilizing spanning tree construction algorithm that utilizes cryptographic signatures and prove that it reduces the set of nodes affected by active attacks. Our simulations substantiate this theoretical result with concrete values based on real-world data sets. In particular, our results indicate that our algorithm reduces the number of affected nodes by up to 74% compared to state-of-the-art attack-resistant spanning tree constructions.

Figures

Tables

Table 1. TABLE I: Structural properties of graphs used for simulation, with avg. shortest path length (CPL) and clustering coefficient (CC).

Graph	# nodes	# edges	CPL	CC
Facebook	63,392	816,886	4.32	0.253
Ripple	67,149	99,787	3.82	0.154
Randomized Facebook	63,392	816,886	3.58	0.005
Erdös-Renyi		824,096	3.74	< 0.001

Equations

$$S_B^{\prime }=\{u\in H\mid \exists b\in B:d_{min}^B+d_S(b,u)-1\le d_S(r,u)\}$$

$$S_L^{\prime }=\{u\in H\mid \exists b\in B:d_{min}^B+d_S(b,u)-1<d_S^H(r,u)\}$$

$$h(m,i)=\{\begin{array}{l}m-i\text{ if }m\ge i\\ m-i+|N(u)|\text{ if }m<i\end{array}$$

Full text

In this work, we design a novel self-stabilizing spanning tree construction algorithm that utilizes cryptographic signatures and prove that it reduces the set of nodes affected by active attacks. Our simulations substantiate this theoretical result with concrete values based on real-world data sets. In particular, our results indicate that our algorithm reduces the number of affected nodes by up to 74% compared to state-of-the-art attack-resistant spanning tree constructions.

I Introduction

Payment or state channel networks like Lightning [13] are the most promising approach to scaling blockchains, i.e., enabling blockchain-based payment systems to process tens of thousands of transactions per second with nearly instant confirmation. Participants in such payment networks establish channels for trading assets such as digital coins. As establishing channels requires use of the blockchain, which is both time- and cost-intensive, only nodes that frequently trade with each other establish payment channels [6]. All other payments pass from a sender to the receiver via multi-hop paths of channels. It is essential to find these paths in an effective, efficient, and privacy-preserving manner [16].

Similarly, social overlays require finding paths from a peer to another in a network consisting only of connections between trusted pairs of nodes to realize scalable and privacy-preserving distributed services [15, 3].

Both payment channel networks and social overlays hence share the need for a routing algorithm. A number of promising algorithms for both networks rely on Breadth-First-Search (BFS) spanning trees [11, 15, 16], as these permit finding shortest paths and achieve the most efficient communication. The underlying spanning tree construction algorithm determines the effectiveness, efficiency, and attack resilience of the routing. Resistance to attacks by malicious parties who aim to prevent the tree construction from converging towards a correct spanning tree is particularly important. Preventing the construction of a correct spanning tree results in routing failures and hence constitutes a denial-of-service attack that undermines communication. Such attacks are realistic for both payment channel networks and social overlays. For payment channel networks, adversarial parties may undermine the routing of payments to sabotage competing operators. Social overlays such as Freenet aim to protect communication from censorship [3]. They clearly require attack resistance against participants aiming to execute censorship in the form of a denial-of-service attack.

In the context of route-restricted overlays with potentially malicious participants, spanning tree algorithms have to fulfill three requirements: (1) enable efficient communication by providing short paths between honest nodes in the spanning tree, (2) efficiently adapt to changes of the network structure, and (3) maintain high availability in the presence of malicious nodes that deliberately deviate from the construction protocol in order keep the network from converging. Yet, the existing work on spanning tree-based routing only evaluates the first two aspects jointly, leaving protection against malicious behavior out of scope despite the likely existence of malicious parties in both payment channel networks and social overlays.

In this work, we focus on achieving all three requirements jointly, giving rise to two key contributions:

• •

We present a self-stabilizing algorithm for the computation of a BFS spanning tree that uses cryptographic signatures to check the integrity of statements about the distance to the root node. We prove that the fraction of nodes reaching a stable, non-compromised state is higher than in state-of-the-art protocols.

• •

We present results from an extensive simulation study based on real-world data sets. The results demonstrate that the construction of BFS spanning trees without cryptographic measures is highly vulnerable to attacks, even if the adversary establishes just a handful of connections to honest nodes. Furthermore, we show that our algorithm substantially raises the necessary number of such attack connections to mislead a comparable number of nodes.

II Related Work

We review the existing work for routing in route-restricted overlays to show that the design of attack-resistant spanning trees is indeed the key problem to solve. Afterwards, we consider the existing work on attack-resistant spanning tree constructions, which we then improve upon in the following sections.

II-A Routing in route-restricted overlays

We define an overlay network, or just overlay, as a network between multiple logically connected nodes that communicate via a public infrastructure such as the Internet. In route-restricted overlays, the logical connections between nodes are explicitly managed by their respective users and hard or even impossible to adapt to create a topology that benefits routing. Apart from finding existing paths between nodes, routing algorithms have to be efficient and scalable with regard to delays for the delivery of messages, bandwidth and memory consumption to provide adequate service for large-scale peer-to-peer networks such as payment channel networks and social overlays. Recent work [15, 11, 16] underlines that only routing algorithms based on rooted spanning trees provide the necessary efficiency. Other approaches either use expensive flooding for path discovery [10] or setup virtual tunnels [21, 12, 14], which, in face of network dynamics, require costly maintenance [17]. Alternatively, some payment channel networks of smaller size use source routing [13, 18], which requires that each node maintains a snapshot of the entire network. Source routing hence does not scale, as any change to the network has to be broadcast.

In the context of social overlays, Hoefer et al. [8] suggested using greedy embeddings based on rooted spanning trees to enable efficient routing between nodes. The approach has later been extended to preserve the privacy of users and offer higher attack resistance [15]. However, their adversarial model only considers the routing and not the construction of the underlying spanning tree, which is an orthogonal approach to the one taken in this paper.

For payment channel networks, Malavolta et al. [11] adapted Landmark Routing [19], where a path between sender and receiver is determined through an intermediate node via the construction of a breadth-first-search tree rooted at the latter. Roos et al. later on adapted the greedy embeddings to payment channel networks [16]. Both works aim to achieve efficiency and privacy and do not consider security.

It thus remains an open question, if and how such spanning trees can be constructed in route-restricted overlays with malicious participants.

II-B Attack-resistant spanning tree construction

In the context of self-stabilization, Dubois, Masuzawa, and Tixeuil proposed a BFS spanning tree algorithm and proved that this algorithm guarantees that all nodes, except those that are strictly closer to the adversary than to the root node, will eventually converge to a correct state [5]. While the algorithm by Dubois et al. offers provable attack resistance, it considers a computationally unbounded attacker. Protecting against such a strong adversary disregards mechanisms such as digital signatures that can help to further decrease the number of affected nodes.

In the context of distance vector routing, which implicitly relies on BFS trees, Zapata and Asokan [23] proposed a protocol that utilizes hash chains to keep malicious nodes from lying about their distance from the root node. Furthermore, their protocol employs cryptographic signatures to prevent attacks on the mechanism for the detection of routing loops. Subsequently, Hu et al. [9] proposed a protocol that uses hash chains both against attacks on the reported distance as well as against attacks on loop-detection, thus reducing computational overhead compared to digital signatures. In contrast to the work of Dubois et al., both approaches assume a computationally bounded attacker. However, they do not provide a formal proof of their security guarantees.

In summary, there exists no provably secure BFS tree construction algorithm under the assumption of a computationally bounded attacker. We expect that such an algorithm can provide protection to a larger set of nodes than the existing information theoretically secure algorithms.

III Model and Notation

We now formalize route-restricted overlays as well as the problem of computing a breadth-first-search tree in the context of self-stabilization.

III-A System model

We model a route-restricted overlay $S=(V,E)$ as a finite set $V$ of $n$ nodes and a set of bidirectional communication links $E\subset V\times V$. For each node $u$, the set $N(u)=\{v\mid\{u,v\}\in E\}$ denotes the neighbors of $u$.

We build upon the shared memory model where each pair of nodes $\{u,v\}\in E$ can communicate via shared registers $r_{uv}$ and $r_{vu}$, where $u$ is only allowed to write into $r_{uv}$ and read from $r_{vu}$. We thus call $r_{uv}$ $u$’s output register and $r_{vu}$ its input register.

Please note that we use the shared memory model solely to simplify formal analysis, as it omits the modeling of message transmission. We consider this to be reasonable, as we focus on malicious node behavior and neither link failures nor delays.

For the computation of a BFS tree, every node $u$ holds the following elements:

• •

$ID_{u}$, a fixed, globally unique ID from a set $\mathcal{ID}$,

• •

$level_{u}$, a non-negative integer variable denoting $u$’s current, assumed distance to the root,

• •

$pID_{u}$, a variable holding the $ID$ of the node that is currently considered parent, in other words, the neighbor of $u$ on the path to the root in the subgraph corresponding to the tree.

Furthermore, each communication register holds two values $ID$ and $level$ such that each output register of a node $u$ holds $u$’s $ID$ as well as its current $level$-value. Each input register $r_{vu}$ of a node $u$ accordingly holds $u$’s current view of $v$’s $ID$ and $level$-value. In the following, we denote the set $N_{min}(u)=\{v\in N(u)|\forall n\in N(u):level_{v}\leq level_{n}\}$ as minimal neighbors of $u$. Parent nodes are always minimal neighbors in BFS spanning trees.

We refer to the values currently held by the $level$- and $pID$-variable of a node $u$ as well as the register contents, at one point in time, as the state of $u$. The state of $u$ is said to be legitimate if it fulfills Def. 1.

Definition 1**.**

(Legitimate state)* Let $S=(V,E)$ be a route-restricted overlay with a distinguished root node $l\in V$ with $ID$-value $ID_{L}\in\mathcal{ID}$. The state of a node $u$ whose minimal neighbors have level $l_{min}$ is called legitimate if it fulfills the following conditions:*

$level_{u}=0$* iff $ID_{u}=ID_{L}$* 2. 2.

$level_{u}=l_{min}+1$* if $ID_{u}\neq ID_{L}$* 3. 3.

$pID_{u}=ID_{u}$* iff $ID_{u}=ID_{L}$* 4. 4.

$\exists v_{min}\in N_{min}(u):pID_{u}=ID_{v_{min}}$* if $ID_{u}\neq ID_{L}$*

III-B Adversary model

In this work, we consider adversaries who aim to perform large-scale denial of service attacks. For payment networks, they might be competing payment network operators who want to attract more users by rendering other networks unusable. For social overlays, the adversary might aim to weaken the privacy [1] or degrade utility so that users move to communication services with weaker privacy protection.

Allowing multiple adversaries to act in concert strictly increases their power. We hence assume a single, collective adversary who controls a set $B$ of malicious (or adversarial) nodes and is able to set up a bounded number of connections between these malicious and honest nodes $H$. The motivation for these bounds is the difficulty of large-scale social engineering that will only be successful for a subset of participants.

During an attack, each malicious node may report incorrect data to the adjacent honest nodes in order to keep them from reaching or remaining in a legitimate state. Thus, malicious nodes may set their output registers arbitrarily and report different $ID$- and $level$-values to different neighbors.

However, we assume that the adversary does not know all honest nodes and their internal connections a priori. Hence, he cannot choose which nodes will be malicious or which nodes will connect to malicious nodes. Given that social overlay and payment networks are large-scale and dynamic distributed systems with participants from a multitude of countries, we consider this assumption to be realistic.

For all practical purposes, the Dolev-Yao model, which assumes an adversary who is limited to polynomial-time attacks – and hence unable to break secure cryptographic primitives – has been accepted as realistic[4]. Hence, we aim for algorithms that protect against adversaries that are polynomially bounded.

III-C Formalization of resilience and performance

We formalize the attack resistance of a spanning tree construction protocol via the concept of topology-aware (TA) strict stabilization [5]. To do so, we express the state of every node in the overlay at one point in time as a configuration $\gamma$.

Following the idea of self-stabilization, we consider that every node starts in an arbitrary state. Thus, nodes may change their state over time to reach a legitimate state. The sequence of configurations $\gamma_{0},\gamma_{1},\dots$ is called a computation $\Gamma$. The transition from $\gamma_{t}$ to $\gamma_{t+1}$ is called a step and corresponds to at least one node processing the data in its input register and writing corresponding data into its output register.

Note that self-stabilizing algorithms never terminate but repeatedly update their state and communication registers. However, a node executing a step may not actually change the values of its variables or output registers (e.g., because its current state is legitimate).

Network dynamics

Route-restricted overlays are dynamic: nodes may join and leave the system, connections between nodes are established or torn down over time. An overlay $S=(V,E)$ changes into an overlay $S^{\prime}=(V^{\prime},E^{\prime})$ with a potentially different network size as a consequence of such events. According to literature, we call such changes churn events. To account for the fact that computations are defined for a fixed system $S$, a churn event interrupts a computation on $S$ and starts a new computation on $S^{\prime}$.

At the beginning of the new computation, all nodes in $V\cap V^{\prime}$ have the same state as at the end of the computation on $S$, reflecting the fact that they cannot detect the change until they read from their registers. The remaining nodes in $V^{\prime}$ may start in an arbitrary initial state. In route-restricted networks, the initial state includes information about the register of neighbors, which the new node will eventually write to.

Containment of attacks

TA strict stabilization for a set $S_{B}\subset H$ of honest nodes denotes that every honest node $u$ except those in the set $S_{B}$ eventually reaches and remains in a legitimate state. We call the set $S_{B}$ the containment area of $S$, because $S_{B}$ (also called lost nodes) represents the part of the network where the adversary can keep the state of nodes from converging, whereas all nodes outside of $S_{B}$ (called safe nodes) will eventually reach and remain in a legitimate state.

We now formalize the concept of a node having only honest ancestors on its path to the root.

Definition 2**.**

(Root-directed path)* Given a route-restricted overlay $S$ and a configuration $\gamma$, the root-directed path $P_{u}$ of a node $u$ is a finite sequence $v_{1},v_{2},\dots,v_{n+1}$ of nodes in a legitimate state such that $v_{n+1}=u$ and $pID_{v_{i+1}}=ID_{v_{i}}$ for all $1\leq i\leq n$ and either $pID_{v_{1}}=ID_{v_{1}}$ (the legitimate root) or $v_{1}$ is a malicious node. We call $u$ ill-directed if $v_{i}$ is malicious for any $1\leq i\leq n$ and well-directed otherwise.*

As long as a node is ill-directed, it is subject to changes in the $level$-value reported by the adversarial node on its root-directed path. Thus, it is not guaranteed to remain in a legitimate state. However, an ill-directed node is not inherently a lost node, because it might eventually become well-directed as the execution proceeds.

We express the situation that a node’s state has converged and remains unaffected by attacks as follows:

Definition 3**.**

(Stable state)* The state of a node $u$ is said to be stable if it is legitimate and $u$ never changes its $level_{u}$- and $pID_{u}$-variable as long as no churn event occurs. In particular, actions performed by malicious nodes do not affect $u$. A configuration $\gamma$ is called $S_{B}$-stable if the state of every node in $V\setminus S_{B}$ is stable.*

We define a $S_{B}$-topology-aware-strictly-stabilizing ($S_{B}$-TA-strictly-stabilizing) algorithm as follows:

Definition 4**.**

($S_{B}$-TA-strictly-stabilizing algorithm)* A distributed algorithm $\mathcal{A}$ is $S_{B}$-TA-strictly-stabilizing if and only if starting from an arbitrary configuration, every execution contains a $S_{B}$-stable configuration.*

Time complexity

To be able to reason about the time complexity that a distributed algorithm requires to reach a legitimate state, we use the concept of asynchronous rounds. The first asynchronous round of a computation $\Gamma$ is the shortest prefix $\Gamma^{\prime}$ of $\Gamma$ such that each node has read from and wrote to all of its registers at least once. The second asynchronous round then is the first asynchronous round of the computation following $\Gamma^{\prime}$ and so on. In other words, the length of an asynchronous round corresponds to the maximum amount of time needed for the slowest node (regarding computational speed) to process its inputs and write the corresponding outputs.

IV Signature-based computation of BFS trees

The state-of-the-art algorithm for the construction of BFS trees proposed by Dubois et al.[5] ensures that all honest nodes whose distance from the closest malicious node is higher or equal than their distance from the root will eventually reach a stable state. As the set of nodes that do not reach a stable state is often quite large for this algorithm, we investigate algorithms that achieve a higher number of stable nodes. In contract to previous work, we assume our adversary to be computationally bounded.

In our design, each node $u$ holds a public/private key pair $p_{u},s_{u}$ of an asymmetric cryptosystem. The public key $p_{u}$ of each node $u$ is stored in the $ID$-register and the secret $s_{u}$ is stored in a new register called $secret_{u}$. The given leader ID $ID_{L}$ then is the public key of the corresponding root node, implicitly choosing it as leader. Nodes do not require global knowledge of all other nodes’ keys.

Assumptions

Four assumptions underlie our design:

• •

There is an honest root node whose key is known to all nodes (e.g., bank in a payment network [11]).

• •

The clocks of any pair of nodes differ at most by a globally known constant $\varDelta_{C}$.

• •

The time needed for one iteration of each node’s main loop is bounded by a globally known constant $\varDelta_{E}$.

• •

The delay needed until a value written into an output register is available in the corresponding input register is bounded by a globally known constant $\varDelta_{D}$.

The first assumption is in accordance with the existing literature on tree-based routing in route-restricted overlays [11, 16, 15]. The remaining assumptions allow us to compute expiration times for the data contained in the input register of each node, thus keeping malicious nodes from reporting outdated values obtained in previous computations.

Level attestation

To keep malicious nodes from lying about their distance to the root, we add a $levelAtt$-variable to each node $u$, which holds a finite sequence $P=(p_{1},t_{1},sig_{1}),(p_{2},t_{2},sig_{2}),\dots,(p_{n},t_{n},sig_{n})$ of tuples called a level attestation. The elements $p_{i}$, $t_{i}$, and $sig_{i}$ denote a public key, a timestamp, and a cryptographic signature, respectively. We say that such a sequence is valid for node $u$ at time $t$ if the following conditions are satisfied:

$p_{1}=ID_{L}$, 2. 2.

$\forall i\in\{1,..,n\}:$ $t-t_{i}\leq\varDelta_{C}+(\varDelta_{D}+\varDelta_{E})(n-i+1)$, 3. 3.

$\forall i\in\{1,..,n-1\}:$ $sig_{i}$ is a signature over $p_{i+1}||t_{i}$ that is valid for $p_{i}$, 4. 4.

$sig_{n}$ holds a signature over $ID_{u}||t_{n}$ that is valid for $p_{n}$,

where $a||b$ denotes the concatenation of $a$ and $b$.

Condition (1) ensures that the first tuple of the attestation has indeed been generated by the root node. Condition (2) ensures that adversarial nodes cannot use obsolete attestations (e.g., from an earlier computation) forever. Condition (3) and (4) ensure that the signatures are computed correctly.

Link signatures

Additional to the level attestation, each node assigns a randomly chosen neighbor ID $nID_{v}$ to each neighbor $v$ once in the beginning of the algorithm. During the computation, every honest node tells each neighbor its respective neighbor ID. Whenever a neighbor of a node $u$ transmits a new level attestation, it also has to send a corresponding neighbor signature that includes its neighbor ID assigned by $u$. Given a valid level attestation $P$ with the last element $(p,t,sig)$ and a cryptographic hash function $h$, a neighbor signature $s$ is valid for node $u$ and neighbor $v$ if $s$ is a valid signature over $nID_{v}||h(P)$ for $p$. This addendum keeps malicious nodes from sending a shortened version of an attestation received by an honest neighbor.

Adaptive neighbor preference

To ensure stabilization in the case that a node has multiple neighbors that are minimal according to Def. 1, each node $u$ assigns a unique number between [math] and $|N(u)|-1$ to each neighbor and chooses the minimal neighbor with the lowest number as parent. The number of the current parent is kept in a variable $prnt$. As the preferred neighbor may be ill-directed, the algorithm of Dubois et al. [5] adaptively changes which neighbor will be preferred whenever a node changes its parent. We implemented this strategy as follows: We add an offset counter $i_{start}\in\{0,..,|N(u)|-1\}$ such that $u$ traverses its neighbors from $i_{start}$ to $(|N(u)|-1)+i_{start}\mod|N(u)|$. Whenever a node $u$ changes its parent from the neighbor with number $prnt$ to a neighbor with a number $prnt^{\prime}$ that, counting from $i_{start}$ with wraparound, comes after $prnt$, then $u$ will set $i_{start}$ to $prnt^{\prime}$, thus favoring $prnt^{\prime}$ over $prnt$ in the future. To compare nodes’ positions $a$ and $b$ with regard to $i_{start}$, we say that $a\prec_{i_{start}}b$ if either i) $i_{start}\leq a<b$, ii) $b<i_{start}\leq a$ or iii) $a<b<i_{start}$. Informally, $a\prec_{i_{start}}b$ indicates that $b$ be will be reached later than $a$ when counting from $i_{start}$ modulo $|N(u)|$.

Spanning Tree Algorithm

Algorithm 1 displays the pseudocode for our spanning tree construction algorithm: Each output register of every node $u$ holds 5 elements, namely the $ID$- and $level$-value of $u$ as well as the $levelAtt$- and $nID$-value together with the neighbor signature $sig_{adj}$ for the corresponding neighbor. The algorithm leverages the following cryptographic functions: The $sign$-function uses the key stored in the $secret$-register to compute a signature $sig$. The function $h$ is a cryptographic hash function.

Every node periodically reads the content of each input register, processes the content, and writes corresponding outputs to output registers. The leader node first ensures that its $pID$- and $level$-value are set correctly (Line 1–1). Subsequently, it generates a level attestation for each neighbor and writes its own $ID$ and $level$-value together with the respective $nID$-value, level attestation, and neighbor signature into the corresponding output register (Line 1–1). Because the $levelAtt$-variable is set to $nil$, the $\mathit{append}$-operation in Line 1 just returns its second argument.

During the processing stage (Line 1–1), an honest non-leader node recomputes its current $pID$-, $prnt$-, $level$- and $levelAtt$-value. It first checks the validity of the received level attestations and neighbor signatures and computes the set of valid neighbors in Line 1. The $isValidAtt$-function checks whether a given level attestation is valid, as defined above. If the given level attestation is valid, $isValidAtt$ further checks whether the length of the attestation equals the given level value and returns false in case of a mismatch. Given this check succeeds, the $isValidLink$-function checks if a given $sig_{adj}$-value is valid for the corresponding neighbor. If a parent node with a valid level attestation has been chosen, the node first checks if its previous parent became either non-minimal or its attestation became invalid and if so, sets $i_{start}$ to $j$. It is possible that $prnt$ might hold a value larger than $|N(u)|-1$ (e.g. because its former parent had this number and left the overlay). $prnt$ will then be set to $j$ that holds a value from the range $\{0,..,|N(u)|-1\}$ (Line 1). Afterwards, it sets its $prnt$-, $pID$- and $levelAtt$-value accordingly. Finally, the node computes the corresponding level attestation for each neighbor and writes it into the respective output register (Line 1–1).

V Analysis

We prove that, given an honest root node $r$, Algorithm 1 is $S^{\prime}_{B}$-TA-strictly-stabilizing with

[TABLE]

where $d^{B}_{min}=\min_{b\in B}d_{S}(r,b)$. The “-1” stems from the fact that a malicious node can copy the outputs of an honest neighbor into its output registers (hence pretending to be its own predecessor), thus avoiding the need to append an attestation tuple and hence increase its maximum level.

Furthermore, let $d^{H}_{S}(u,v)$ denote the length of the shortest path between $u$ and $v$ in $S$ that does not contain a malicious node. If no such path exists, we set $d^{H}_{S}(u,v)=\infty$. If malicious nodes repeatedly change their outputs in order to de-stabilize honest nodes, we show that our algorithm guarantees that all nodes in the set

[TABLE]

eventually reach a stable state. Informally, we show that $S^{\prime}_{L}\subset S^{\prime}_{B}$ is the containment area for an adversary that focuses on disrupting convergence by changing its behavior. However, for an arbitrary adversary aiming to maximize the fraction of ill-directed nodes, we achieve only a smaller containment area of $S^{\prime}_{B}$.

Since the system starts in an arbitrary state, a malicious node may initially hold a level attestation that is valid but for which no corresponding path in the overlay exists. We hence say that a level attestation $(p_{1},t_{1},sig_{1}),\ldots,(p_{n},t_{n},sig_{n})$ is consistent for node $u$ if it is invalid or if there exists a path $v_{1},\ldots,v_{n}$ in the system such that (1) $p_{i}$ is the public key of $v_{i}$ for all $1\leq i\leq n$ and (2) $u$ either is a neighbor of $v_{n}$ or both $u$ and $v_{n}$ are neighbors of a malicious node $b$. Otherwise, we say that the attestation is inconsistent. A configuration is called consistent if the $levelAtt$-values as well as the in- and output-registers of all nodes only contain consistent level attestations.

In the following, we assume that at the beginning of a computation at time $t$, all timestamps of every inconsistent attestation are at most $t+\varDelta_{C}$. We consider this to be reasonable since $t+\varDelta_{C}$ is the highest value that a honest node (including the root) may use as timestamp and thus a malicious node cannot have a valid attestation with a higher timestamp from a previous computation. As a consequence, every inconsistent attestation of length $n$ becomes invalid after at most $\varDelta_{C}+(\varDelta_{D}+\varDelta_{E})n$ time units. So, every route-restricted overlay $S$ with diameter $diam(S)$ reaches a consistent configuration after at most $\varDelta_{C}+(\varDelta_{D}+\varDelta_{E})diam(S)$ time units.

V-A Proof of $S^{\prime}_{B}$-TA-strict stabilization

We start the actual proof by establishing key properties of level attestation to later leverage in the proof. In a nutshell, malicious nodes can only influence keys that are used after the $d_{min}^{B}$-th element of a valid and consistent level attestation $P$ but before the $|P|-d^{B}_{u,min}$-th element with $d^{B}_{u,min}=\min_{b\in B}\{d_{S}(u,b)\}$. Based on this result, we can then show that a node is well-directed if their $levelAtt$-value is of length less than $d^{B}_{min}+d^{B}_{u,min}-1$. Convergence to a stable state for all nodes in $S^{\prime}_{B}$ follows from the fact that the system at some point reaches a state when these nodes have a valid and consistent $levelAtt$-value with minimal levels and hence will not change parents anymore.

Lemma 1**.**

Let $P=(p_{1},t_{1},sig_{1}),\ldots,(p_{n},t_{n},sig_{n})$ be a level attestation. Consider a node $u$ such that $sig_{n}$ is a signature over $ID_{u}||t_{n}$. At time $t$, we have $t-t_{i}\leq\Delta_{C}+(\Delta_{D}+\Delta_{E})\cdot(n-i+1)$ for all $1\leq i\leq n$ and the computation has started at least $\Delta_{C}+(\Delta_{D}+\Delta_{E})\cdot n$ time units before, so that $P$ is consistent for $u$. If P is valid, then the following two statements hold:

For $j\leq d^{B}_{min}$, $p_{j}$ is the public key of an honest node $v$ and $d_{S}(v,r)<j$. 2. 2.

For $j>n-d^{B}_{min,u}+1$, $p_{j}$ is the public key of an honest node $v$ and $d_{S}(v,u)\leq n-j+1$.

{conference}

Lemma 1 follows by induction on $j$ and the full proof can be found in the extended version of the paper [byrenheid2019attack].

{arxiv}

Proof.

We show the first claim by induction on $j$. As $p_{1}$ always needs to be the public key of the leader and the leader is honest by assumption, the claim holds for $j=1$. Let $1<j\leq d^{B}_{min}$ and assume the claim holds for $j-1$. Then $sig_{j-1}$ is a signature over $p_{j}||t_{j-1}$ using the secret key $s_{j-1}$ associated with $p_{j-1}$. By induction hypothesis, $p_{j-1}$ is the public key of an honest node $w$ with distance $d_{S}(w,r)<j-1\leq d^{B}_{min}-1$. $d_{S}(w,r)<d^{B}_{min}-1$ implies that $w$ has only honest neighbors, which only write their own keys to its output register for $w$ to sign.

Furthermore, because $w$ itself is honest, $w$ only signs keys and timestamps that it reads from its input registers. Thus, for $p_{j}||t_{j-1}$ to be signed by $w$, $p_{j}$ needs to be the key of an honest neighbor $v$ of $w$. Given that $w$’s distance to the root is less than $j-1$ by induction hypothesis, we also have $d_{S}(v,r)\leq d_{S}(w,r)+1<j$. This proves the first claim. Similarly, we show the second claim by induction on $j^{\prime}=n-j+1$. Note that if $d^{B}_{min,u}=1$, i.e., $u$ is the neighbor of a malicious node, then there is nothing to show as there is no $p_{j}$ such that $j>n-d^{B}_{min,u}+1$. So, we assume $d^{B}_{min,u}>1$. For $j^{\prime}=1$, we only have to consider the key $p_{n}$. As $u$ is honest, it only writes its own key into output registers to be signed by neighbors. If $d^{B}_{min,u}>1$, all of $u$’s neighbors are honest. They would hence only sign $u$’s key concatenated with a timestamp with their own, meaning that any node $v$ with public key $p_{n}$ is indeed an honest node and $d_{S}(v,u)=1$. Consider $1<j^{\prime}<d^{B}_{min,u}$ and assume the claim holds for $j^{\prime}-1$. Hence, $p_{n-(j^{\prime}-1)+1}$ is the public key of an honest node $w$ with $d_{S}(w,u)\leq j^{\prime}-1$. $w$ writes its public key and a timestamp to the registers that will be read by its neighbors. As $j^{\prime}-1<d^{B}_{min,u}-1$, these neighbors are honest and will sign the key and timestamp with their own keys. Hence, any public key $p_{n-j^{\prime}+1}$ whose corresponding secret key has been used to sign $p_{n-(j^{\prime}-1)+1}||t_{n-(j^{\prime}-1)}$ belongs to an honest neighbor $v$ of $w$ with $d_{S}(v,u)\leq d_{S}(w,u)+1=j^{\prime}$. So, the second claim follows by induction as well. ∎

Lemma 2**.**

Let the computation have started a least $\Delta_{C}+(\Delta_{D}+\Delta_{E})\cdot n$ time units before and $u\in V\setminus S^{\prime}_{B}$ be a node with a valid $levelAtt$-value of length $n<d^{B}_{min}+d^{B}_{u,min}-1$. Then $u$ is well-directed.

Proof.

Because $\Delta_{C}+(\Delta_{D}+\Delta_{E})\cdot n$ time units have passed, the $levelAtt$-value of $u$ is also consistent. By Lemma 1, the first $d^{B}_{min}$ public keys have to belong to honest nodes and the last $d^{B}_{u,min}-1$ keys have to belong to honest nodes as well. Hence, if $n<d^{B}_{min}+d^{B}_{u,min}-1$, all keys $p_{j}$ have to belong to an honest node $v_{j}$ for $1\leq j\leq n$. Set $v_{n+1}=u$.

$u$ can only be ill-directed if at least one $v_{j}$ has their $pID$-value set to a key provided by a malicious node. First, consider the case that $j<d^{B}_{min}$. By Lemma 1, $d_{S}(v_{j},r)<d^{B}_{min}-1$, meaning that $v_{j}$ only has honest neighbors. Honest nodes only write their own keys in the register of their neighbors, so that $v_{j}$ can hence only set its $pID$-value to one of their keys. Now, consider $j>d^{B}_{min}$, i.e., $n-j+1<n-d^{B}_{min}+1\leq d^{B}_{u,min}-1$. According to Lemma 1, $d_{S}(v_{j},u)\leq n-j+1<d^{B}_{u,min}-1$. Again, $v_{j}$ has only honest neighbors and can hence only set its $pID$-value to one of their keys.

It remains to consider the case $j=d^{B}_{min}$. By the first part of the proof, $v_{j}$ is the only node that can have malicious neighbors. Assume that $v_{j}$ has set its $pID$ to a malicious neighbor $b$. For $u$’s $levelAtt$ to correspond to a valid attestation, $v_{j-1}$ has to sign $p_{j}||t_{j-1}$ resulting in $sig_{j-1}$, append $(p_{j-1},t_{j-1},sig_{j-1})$ to the attestation, and write the attestation to the register corresponding to the neighbor that wrote $p_{j}$ to the register. Because $v_{j-1}$ has only honest neighbors, the respective neighbor has to be $v_{j}$, the only honest node that would claim $p_{j}$ as its key. So, for $u$’s $levelAtt$-value to include $(p_{j-1},t_{j-1},sig_{j-1})$, $v_{j}$ must have read the register and disseminated $(p_{j-1},t_{j-1},sig_{j-1})$ as part of a level attestation. Consequently, $v_{j}$ is aware that $v_{j-1}$ offers a root-directed path of supposed length $j-2\leq d^{B}_{min}-2$. For $v_{j}$ to choose a different parent, $b$ has to produce a valid attestation $\widetilde{P}=(\widetilde{p}_{1},\widetilde{t}_{1},\widetilde{sig}_{1}),\ldots,(\widetilde{p}_{l},\widetilde{t}_{l},\widetilde{sig}_{l})$ with $l\leq j-1$ and $\widetilde{sig}_{l}$ being a signature over $ID_{v_{j}}||\widetilde{t}_{l}$. Furthermore, $b$ has to ensure that the $isValidLink$-function returns $true$. The neighbor-related signature has to be signed by the secret key $\widetilde{s}_{l}$ corresponding to $\widetilde{p}_{l}$. As $b$ can not forge signatures, $\widetilde{P}$ has to be a (potentially shortened) attestation that $b$ has read from one of its input registers. For such an attestation, $\widetilde{p}_{l}$ belongs to an honest node $w$ at distance at most $l-1$ from the root by Lemma 1. Due to $d_{S}^{H}(w,r)\leq l-1<d^{B}_{min}-1$, $w$ has no malicious neighbors. By Algorithm 1, $w$ only writes signatures over $nID_{w}||h(L)$ for some $L$ to registers of neighbors. Being honest, these neighbors do not disseminate the respective signatures. As a consequence, $b$ can not obtain the required neighbor signature and hence $v_{j}$ does not accept any attestation from $b$ as its $levelAtt$-value.

In summary, none of the nodes $v_{j}$ has its $pID$-value set to a key provided by a malicious node and hence $u$ is indeed well-directed. ∎

Theorem 1**.**

Given any route-restricted overlay $S$ with diameter $diam(S)$, a computation of Algorithm 1 starting from an arbitrary configuration reaches a consistent configuration after at most $\Delta_{C}+(\Delta_{D}+\Delta_{E})\cdot diam(S)$ time units. Furthermore the computation will reach a $S^{\prime}_{B}$-stable configuration $\gamma^{*}$ within at most $diam(S)+1$ additional asynchronous rounds. Thus, Algorithm 1 is $S^{\prime}_{B}$-TA-strictly-stabilizing.

Proof.

Arrival at a consistent configuration follows from the assumption that the timestamps of every inconsistent level attestation do not exceed the starting time of the computation by more than $\varDelta_{C}$ time units, as explained at the beginning of this section. To prove the subsequent convergence to a $S^{\prime}_{B}$-stable configuration, we first show that after $l+1$ rounds, all nodes $u\in V\setminus S^{\prime}_{B}$ within distance $l$ of the root are well-directed and have valid $levelAtt$-values of length $l$. The properties from Definition 1 follow. Last, we show that these nodes remain well-directed.

After the first round, the root has written its information to all registers. After the second round, the neighbors of the root have processed these registers. Hence, each such neighbor $u$ will set its $levelAtt$-value to a valid attestation of length 1. If $u\in V\setminus S^{\prime}_{B}$, the distance $d_{S}(u,b)\geq 2$ for any malicious node $b$ and hence by Lemma 2, $u$ is well-directed. So, the claim holds for $l=1$.

Assume the claim holds for $l$, i.e., after $l+1$ rounds, all nodes $v\in V\setminus S^{\prime}_{B}$ within distance $l$ of the root are well-directed and have valid $levelAtt$-values of $l$. They know the IDs their neighbors have assigned to them as $l>1$ indicates that they have read it from the register at least once. As a consequence, they can construct a valid attestation of length $l+1$ for each neighbor $w$ as well as the necessary signature over the neighbor ID $nID_{w}$. They write this information to the register $r_{vw}$. After $l+1$ rounds, any node $u\in V\setminus S^{\prime}_{B}$ at distance $l+1$ from the root has read the register corresponding to its neighbors at distance $l$ to the root. As a consequence, $u$’s $levelAtt$-value is of length $l+1$. As $u\in V\setminus S^{\prime}_{B}$, Lemma 2 shows that $u$ is well-directed. It follows by induction that within $diam(S)$ rounds, all nodes $u\in V\setminus S^{\prime}_{B}$ are well-directed.

It remains to prove that the nodes in $V\setminus S^{\prime}_{B}$ remain well-directed. To become ill-directed, a node has to change its $pID$-value. Let $u$ be the first node to change its $pID$-value. According to Algorithm 1, $u$ selects the parent from those neighbors that provide the shortest valid attestation and a valid neighbor signature. By assumption, $u$ breaks ties consistently, meaning $u$ only changes its parent if either i) $u$’s previous parent does not provide any valid attestation of the shortest length or provides an invalid neighbor signature, or ii) a neighbor that is not the current parent writes an attestation of a shorter length than $u$’s $levelAtt$-value to its register and the content of the register passes the two validity checks.

In order to conclude that neither i) or ii) are possible, consider the following: Let $v$ be $u$’s parent and note that $v\in V\setminus S^{\prime}_{B}$ by the definition of $S^{\prime}_{B}$ as $d_{S}(v,r)=d_{S}(u,r)-1$ and $d_{S}(v,b)\geq d_{S}(u,b)-1$ for all malicious nodes $b$. It follows recursively that all nodes on a root-directed path of $u$ are in $V\setminus S^{\prime}_{B}$. Case i) would imply that a node on the root-directed path changed its parent, as honest nodes do not write invalid attestations or neighbor signatures to registers. However, such a parent change contradicts the definition of $u$ as the first node in $V\setminus S^{\prime}_{B}$ to change its parent. If case ii) holds, by Lemma 1, $u$ has to be well-directed after its parent change. Hence, its new parent $w$ is an honest node. By the above, $w$ and all nodes on the new root-directed path are in $V\setminus S^{\prime}_{B}$ and at least one of them has to have changed its parent for $w$ to write an attestation of a different length. Again, such a change in parent is a contradiction to the definition of $u$. Consequently, nodes $u\in V\setminus S^{\prime}_{B}$ do not change their $pID$-value for the rest of the computation and remain well-directed. ∎

V-B Proof of stabilization for $S^{\prime}_{L}$ under attacks

Building upon Theorem 1, we now show that under an attacker that frequently changes the output values of its nodes, all nodes $u$ with $d^{B}_{min}-d^{H}_{S}(b,u)-1=d^{H}_{S}(r,u)$ eventually reach a stable state as well. Our result requires the concept of a $S_{B}$-disturbance, a concept similar to Dubois et al. [5]’s $S_{B}$-disruption.

Definition 5**.**

($S_{B}$-disturbance)* Two consecutive configurations $\gamma_{0}$ and $\gamma_{1}$ are a $S_{B}$-disturbance if at least one node $u\in V\setminus S_{B}$ changes its $level_{u}$- or $pID$-variable.*

In contrast to a $S_{B}$-disruption, a $S_{B}$-disturbance does not assume that all nodes in $V\setminus S_{B}$ have a legitimate state.

Theorem 2**.**

Given any route-restricted overlay $S$ with diameter $diam(S)$ and $deg_{sum}=\sum_{u\in S^{\prime}_{B}\setminus S^{\prime}_{L}}|N(u)|$, a computation of Algorithm 1 starting from an arbitrary configuration reaches a $S^{\prime}_{B}$-stable configuration $\gamma^{+}$ within at most $\Delta_{C}+(\Delta_{D}+\Delta_{E})\cdot diam(S)$ time units plus at most $diam(S)+1$ asynchronous rounds. After reaching the configuration $\gamma^{+}$, $S$ will reach a $S^{\prime}_{L}$-stable configuration within at most ($2deg_{sum}-|S^{\prime}_{B}\setminus S^{\prime}_{L}|$) $S^{\prime}_{L}$-disturbances.

{conference}

We only present a sketch of the proof here and refer the reader to the full version of the paper [byrenheid2019attack]. The $S^{\prime}_{B}$-stability after at most $\varDelta_{C}+(\varDelta_{D}+\varDelta_{E})diam(S)$ time units and $diam(S)+1$ asynchronous rounds follows from Theorem1. Any subsequent $S^{\prime}_{L}$-disturbance after reaching $\gamma^{+}$ can only affect nodes in $S^{\prime}_{B}\setminus S^{\prime}_{L}$. Let $u$ be a node affected by a $S^{\prime}_{L}$-disturbance. Algorithm 1 ensures that $u$ changes its parent and the fact that $u\in S^{\prime}_{B}\setminus S^{\prime}_{L}$ means that $u$ has a minimal neighbor $v$ that offers a path consisting of all honest nodes to the root. After at most $|N(u)|-1$ $S^{\prime}_{L}$-disturbances affecting $u$, $u$ starts increasing the variable $i_{start}$ in Algorithm 1. From then on, $u$ iterates over potential parents sequentially and increases $i_{start}$ with each $S^{\prime}_{L}$-disturbance, hence it will choose $v$ as a parent after at most another $|N(u)|$ $S^{\prime}_{L}$-disturbances that affect $u$. In total, at most $2|N(u)|-1$ $S^{\prime}_{L}$-disturbances affect $u$ before it chooses $v$ or another honest neighbor with a path of minimal length to the root. Afterwards, $u$ does not change its parent as $v$ does not change its level. The claim follows by summing over all nodes $u\in S^{\prime}_{B}\setminus S^{\prime}_{L}$.

{arxiv}

Proof.

The $S^{\prime}_{B}$-stability after $\Delta_{C}+(\Delta_{D}+\Delta_{E})\cdot diam(S)$ time units plus $diam(S)+1$ asynchronous rounds follows from Theorem1. In order to have $S^{\prime}_{L}$-stability, all nodes in $S^{\prime}_{B}\setminus S^{\prime}_{L}$ have to reach a stable and legitimate state.

Let $u\in S^{\prime}_{B}\setminus S^{\prime}_{L}$. The proof consists of showing the following four claims:

$u$’s $level$-value is $level_{u}=d^{H}_{S}(u,r)$ for any configuration after $\gamma^{+}$. 2. 2.

If $u$ has a parent $v$ such that $v$ is a node on a path from $u$ to the root of length $d^{H}_{S}(u,r)$ consisting of only honest nodes, then $v\in V\setminus S^{\prime}_{L}$ and $u$ will not change its $pID$-value in any subsequent configuration if $prnt=i_{start}$. 3. 3.

$u$ will choose such a node $v$ as a parent after at most $(2|N(u)|-1)$ $S^{\prime}_{L}$-disturbances that affect $u$, i.e., in which $u$ changes its level or parent. 4. 4.

The maximal number of $S^{\prime}_{L}$-disturbances until $u$ is in a stable and legitimate state is $2deg_{sum}-|S^{\prime}_{B}\setminus S^{\prime}_{L}|$.

By definition of $S^{\prime}_{B}$ and $S^{\prime}_{L}$, $u$ has at least one path consisting of only honest nodes to the root $r$. Furthermore, as $d^{B}_{u,min}+d^{B}_{min}-1=d^{H}_{S}(u,r)$, $u$ never receives a valid level attestation of length less than $d^{H}_{S}(u,r)$. So, we claim that after $diam(S)+1$ asynchronous rounds, $u$ has to have level $d^{H}_{S}(u,r)$. The previous claim obviously holds for $d^{H}_{S}(u,r)=1$ and by induction holds for all $d^{H}_{S}(u,r)$ as any honest neighbor $v$ of $u$ with $d^{H}_{S}(v,r)=d^{H}_{S}(u,r)-1$ sends a valid level attestation to $u$. Hence, $u$’s $level$-value does not change and the first claim holds.

For the second claim, consider Algorithm 1. $u$ always selects the minimal neighbor whose unique index is reached first. If $prnt=i_{start}$, $u$ first considers its current parent, which is $v$ (Line 1). $u$ only replaces $v$ if it does not receive a valid attestation of length $d^{H}_{S}(v,r)$ and link signature from $v$. As $v$ is honest, it does not send invalid attestations or link signatures. So, a change would only happen if $v$ changes its $level$-value. We now show that $v$ does not change its $level$-value and hence $u$ does not change its $pID$-value. If $v\in V\setminus S^{\prime}_{B}$, $v$ is in a stable state and hence does not change its $level$-value. By the first part of the proof, $v\in S^{\prime}_{B}\setminus S^{\prime}_{L}$ also does not change its $level$-value. So, it remains to show that $v\notin S^{\prime}_{L}$. By definition, $v$ has a path to $r$ consisting of only honest nodes and being of length $d^{H}_{S}(v,r)=d^{H}_{S}(u,r)-1$. Similarly, as $v$ is a neighbor of $u$, we have $d^{B}_{v,min}\geq d^{B}_{u,min}-1$, i.e., $v$ is at most 1 hop closer to any malicious node than $u$. So, $d^{B}_{v,min}+d^{B}_{min}-1\geq d^{B}_{u,min}+d^{B}_{min}-1-1\geq d^{H}_{S}(u,r)-1=d^{H}_{S}(v,r)$. The third step follows from Eq. 2 because $u\in V\setminus S^{\prime}_{L}$. So, $d^{B}_{v,min}+d^{B}_{min}-1\geq d^{H}_{S}(v,r)$ and hence again by Eq. 2, $v\notin S^{\prime}_{L}$. So, indeed, $u$ does not change its $pID$-value.

The third claim ascertains that $u$ chooses such a $v$ as parent after at most $(2|N(u)|-1)$ $S^{\prime}_{L}$-disturbances affecting $u$. By the above, a $S^{\prime}_{L}$-disturbance can only affect $u$’s $pID$-value. We determine an upper bound on the number of times the $pID$-value can change until $i_{start}=prnt$ and $v$ is the parent node. Let $l$ be the local index of $v$ assigned by $u$ and

[TABLE]

As the result of a $S^{\prime}_{L}$-disturbance, $u$’s parent changes to either $v$ or a node with pointer $prnt^{\prime}\neq prnt$ with $h(prnt^{\prime},i_{start})<h(l,i_{start})$. If it changes to $prnt^{\prime}$, we either have $h(prnt^{\prime},i_{start})<h(prnt,i_{start})$ or $h(prnt^{\prime},i_{start})>h(prnt,i_{start})$. In this first case, $i_{start}$ remains the same (Line 1). However, the maximal number of consecutive decreases of the function $h(prnt,i_{start})$ is $h(l,i_{start})-1\leq|N(u)|-1$. Once $i_{start}=prnt$, $h(prnt,i_{start})=0$. Any further change corresponds to the second case, as the condition in Line 1 will hold for any new parent and so $h(p,i_{start})$ continues to be [math]. In the second case, i.e., $h(prnt^{\prime},i_{start})>h(prnt,i_{start})$, $i_{start}$ is now set to $p^{\prime}$, i.e., $h(l,i_{start})$ decreases. $h(l,i_{start})$ can decrease at most $|N(u)|$ times. So, the total number of $S^{\prime}_{L}$-disturbances until $u$ chooses $v$ as a parent are the sum of possible instance of the first and the second case, namely $|N(u)|-1+|N(u)|=2|N(u)|-1$. Furthermore, $i_{start}=prnt$ holds after these disturbances.

The fourth and last claim establishes that all nodes in $V\setminus S^{\prime}_{L}$ are in a legitimate and stable state after at most $2deg_{sum}-|S^{\prime}_{B}\setminus S^{\prime}_{L}|$ disturbances. First note that each $S^{\prime}_{L}$-disturbance has to affect a node in $S^{\prime}_{B}\setminus S^{\prime}_{L}$. This is a direct consequence of the definition of $S^{\prime}_{L}$-disturbance and the fact that $S$ is $S^{\prime}_{B}$-stable. A $S^{\prime}_{L}$-disturbance requires a node in $V\setminus S^{\prime}_{L}$ to change its level or parent but nodes in $V\setminus S^{\prime}_{B}$ are in a stable state already, so the affected node has to be in $(V\setminus S^{\prime}_{L})\cap S^{\prime}_{B}=S^{\prime}_{B}\setminus S^{\prime}_{L}$. Combining the second and third claim, nodes $u\in S^{\prime}_{B}\setminus S^{\prime}_{L}$ are affected at most $2|N(u)|-1$ times by a $S^{\prime}_{L}$-disturbance. So, the total number of $S^{\prime}_{L}$-disturbances until no node in $V\setminus S^{\prime}_{L}$ can be affected anymore is $\sum_{u\in S^{\prime}_{B}\setminus S^{\prime}_{L}}(2|N(u)|-1)=2deg_{sum}-|S^{\prime}_{B}\setminus S^{\prime}_{L}|$. It remains to show that all these nodes are indeed in legitimate states. By the second and third claim, all nodes in $S^{\prime}_{B}\setminus S^{\prime}_{L}$ have an honest parent in $V\setminus S^{\prime}_{L}$. In addition, all nodes in $V\setminus S^{\prime}_{B}$ have an honest parent in $V\setminus S^{\prime}_{L}$ because of the $S^{\prime}_{B}$-stability. Hence, a node $u\in S^{\prime}_{B}\setminus S^{\prime}_{L}$ cannot have an ancestor in $B\cup S^{\prime}_{L}$ and is hence well-directed and in a legitimate state. Furthermore, $u$ is in a stable state by the second claim. ∎

VI Evaluation

Using OMNeT++ [20], we implemented a simulation to evaluate the impact of our attestation-based algorithm on the number of lost nodes compared to the non-cryptographic state-of-the-art. Furthermore, we investigated the impact of the network structure, the position of the root node, and the placement of edges between honest and malicious nodes.

VI-A Metrics, Data Sets, and System Parameters

Given a distributed system $S=(V,E)$ with a subset $H$ of honest nodes and a $S_{B}$-TA stabilizing spanning tree construction algorithm, we measured the ratio of lost nodes (RLN) $\nicefrac{{|S_{B}|}}{{|H|}}$. A low ratio of lost nodes indicates high attack resistance.

{arxiv}

Route-restricted overlays include both social overlays and payment networks. We hence utilized a real-world graph for each of them and compare the results with synthetic graphs for the purpose of characterizing the impact of various topological features. Facebook denotes a real-world graph of Facebook [22], as used in several prior studies [12, 15]. Ripple denotes a real-world graph from the Ripple payment network [16]. Ripple has a low number of edges and a heavily skewed degree distribution: $95\%$ of all nodes have a degree less or equal than the average degree of approximately 3. Our synthetic data sets are i) a random synthetic network (denoted randomized Facebook) with the same degree distribution as the Facebook graph and ii) an Erdös and Renyi graph (ER) with approximately the same number of nodes and edges as Facebook but normal distributed degrees [7]. We compare Facebook with randomized Facebook to characterize the impact of clustering while the comparison of randomized Facebook and ER reveals the impact of the degree distribution.

We considered the number of malicious nodes and the time of their presence to be unbounded but limit the total number $g$ of connections between honest nodes and malicious nodes. To model that all nodes are colluding, we represented them as a single node with $g$ edges.

VI-B Set-up

We investigated the resistance of spanning tree algorithms to adversarial behavior given structural differences of the networks and a varying number $g$ of attack edges. For all scenarios, we performed 100 runs to obtain statistically significant results.

We assumed the adversary knows all nodes but can only establish a connection to a subset with limited size. Following [2] we also assumed that users with many contacts are more likely to accept new requests and thus connect with a malicious node. We hence added a single adversary $m$ to the graph and choose the $g$ honest neighbors at random, with a probability proportional to their degree. Afterwards, a root node $r$ was chosen uniformly at random from all honest nodes and the leader ID of each honest node was set accordingly.

We executed different spanning tree constructions for various adversarial behaviors. The two spanning tree algorithms are Algorithm 1, i.e., spanning tree construction with level attestation, and the state-of-the-art protocol by Dubois et al. [5]. The two adversarial behaviors are:

The attacker aims to prevent convergence by causing disturbances. By Theorem 2, the set of lost nodes corresponds to $S^{\prime}_{L}$ as defined in Eq. 2. Similarly, the set of lost nodes for the state-of-the-art protocol is $S_{L}=\{u\in H:d_{S}(u,m)<d_{S}(u,r)\}$ [5]. 2. 2.

The attacker aims to maximize the number of ill-directed nodes. In this case, the adversary always pretends to be as close to the root as possible and does not perform any disturbances. In this case, the set of lost nodes is $S^{\prime}_{B}$ as defined in Eq. 1 according to Theorem 1. For the state-of-the-art protocol, the set of lost nodes is $S_{B}=\{u\in H:d_{S}(u,m)<d_{S}(u,r)\}$.

To investigate how strongly the cheating by one level (described in Sec. V) affects the number of lost nodes when Algorithm 1 is used, we furthermore simulated a modified adversary which does not cheat, effectively following Algorithm 1 correctly. {conference} As the results for the second adversarial behavior are very similar in terms of the advantage gained by Algorithm 1, we only present the results for the first adversarial behavior here. The remaining results are included in the extended version [byrenheid2019attack].

VI-C Impact of Level Attestation

{conference}

Figure 1 show the obtained mean RLN with $99\%$ confidence intervals for the four graphs and both algorithms under the first adversarial behavior. Especially for the Facebook graph, its randomized version, and the ER graph, Algorithm 1 considerably reduced the ratio of lost nodes compared to the state-of-the-art protocol. For the latter, an attack with 25 edges resulted in a mean RLN of $0.57$, $0.31$, $0.19$, and $0.75$ for the Facebook graph, the randomized Facebook graph, the ER graph and the Ripple graph, respectively. When applying Algorithm 1, the mean RLN at 25 attack edges dropped down to $0.0005$, $0.00006$, $0.00005$, and $0.34$ for the Facebook graph, the randomized Facebook graph, the ER graph, and the Ripple graph, respectively. Even for 1000 attack edges, the mean RLN for the Facebook graph, its randomized variant, and the ER graph significantly decreased from $0.93$, $0.84$, and $0.84$ to $0.18$, $0.06$, and $0.12$, respectively.

In the scenario with an adversary that does not cheat by a level, the mean RLN was considerably lower than in the scenario with Algorithm 1 alone, especially with 1000 and 5000 attack edges. Referring to Table I we realize that all graphs used in our experiment have a very low average path length, and all nodes are in short distance from the root node. Increasing the adversary’s reported $level$ value by 1 then represents a significant disadvantage for the attack. We conjecture that this causes many nodes to remain well-directed and investigate this relationship in more detail in the following.

For the Ripple graph, the improvement regarding mean RLN was considerably lower than for the other graphs. In the following, we describe the impact of distances between honest nodes, malicious nodes, and the root node on the RLN to explain this stark difference.

{arxiv}

Figure 1 show the obtained mean RLN with $99\%$ confidence intervals for the four graphs and both algorithms under the first adversarial behavior. Figure 2 shows the corresponding data under the second adversarial behavior. Especially for the Facebook graph, its randomized version, and the ER graph, Algorithm 1 considerably reduced the ratio of lost nodes compared to the state-of-the-art protocol. For the latter, an attack with 25 edges resulted in a mean RLN of $0.57$, $0.31$, $0.19$, and $0.75$ for the Facebook graph, the randomized Facebook graph, the ER graph and the Ripple graph, respectively, under the first adversarial behavior. Under the second adversarial behavior, the mean RLN increased to $0.77$, $0.66$, $0.5$ and $0.91$ for the four graphs. When applying Algorithm 1, the mean RLN at 25 attack edges under the first adversarial behavior dropped down to $0.0005$, $0.00006$, $0.00005$, and $0.34$ for the Facebook graph, the randomized Facebook graph, the ER graph, and the Ripple graph, respectively. Similarly, the mean RLN at 25 attack edges under the second adversarial behavior decreased to $0.002$, $0.0006$, $0.004$ and $0.38$ for the four graphs. Even for 1000 attack edges, the mean RLN for the Facebook graph, its randomized variant, and the ER graph significantly decreased from $0.93$, $0.84$, and $0.84$ to $0.18$, $0.06$, and $0.12$, respectively under the first adversarial behavior. Under the second adversarial behavior, the mean RLN at 1000 attack edges was reduced from $0.98$, $0.97$, $0.98$ and $0.95$ to $0.36$, $0.21$ and $0.23$ for the Facebook graphs and the ER graph. In summary, while the exact numbers differ for the two adversarial behaviors, the overall result is the same: Algorithm 1 achieves a considerable higher number of well directed nodes than the state of the art.

In the scenario with an adversary that does not cheat by a level, the mean RLN was considerably lower than in the scenario with Algorithm 1 alone, especially with 1000 and 5000 attack edges for both adversarial behaviors. Referring to Table I we realize that all graphs used in our experiment have a very low average path length, and all nodes are in short distance from the root node. Increasing the adversary’s reported $level$ value by 1 then represents a significant disadvantage for the attack. We conjecture that this causes many nodes to remain well-directed and investigate this relationship in more detail in the following.

For the Ripple graph, the improvement regarding mean RLN was considerably lower than for the other graphs. In the following, we describe the impact of distances between honest nodes, malicious nodes, and the root node on the RLN to explain this stark difference.

VI-D Impact of Network Structure

We start with a discussion of our results for the state-of-the-art algorithm and subsequently present results for Algorithm 1. Because the correlations between the different aspects were similar for both adversarial behaviors, we focus on our results for the first adversarial behavior.

State-of-the-Art Spanning Tree Construction

We considered the average hop distance over all honest nodes to the root node $\overline{d}(r)$ and to the attacker node $\overline{d}(m)$ for each simulation run. The lower $\overline{d}(r)$ is compared to $\overline{d}(m)$, the more honest nodes will have a lower hop distance to $r$ than to $m$ and thus be well-directed. Therefore, we expected a positive correlation between $\overline{d}(r)-\overline{d}(m)$ and the RLN.

Figure 3 shows the obtained RLN values in ascending order together with the corresponding value of $\overline{d}(r)$ and $\overline{d}(m)$ for 25 attack edges and both adversarial behaviors. Indeed, the difference $\overline{d}(r)-\overline{d}(m)$ generally correlated with the RLN. While $\overline{d}(m)$ only varied slightly between the different runs on each graph, there are notable differences in the behavior of $\overline{d}(r)$: It varied highly for the Facebook graphs and to some extent for the Ripple graph but barely for the ER graph.

The reason for the small variance in $\overline{d}(r)$ for ER is due to the uniform probability of two nodes being connected. As a consequence, it was very unlikely that the average distance of any node significantly differs from the other nodes. The degree of $m$, corresponding to the 25 attack edges, was close to the average degree of 26. However, the mean RLN was only $0.19$, because there was a high number of nodes whose distance to the root node equalled that to the malicious node. These nodes chose the path to the root node when the malicious node continuously causes disturbances. {conference} In the setting where the attacker aims to maximize the number of ill-directed nodes, approximately half of all nodes became ill-directed.

For the Facebook graphs and Ripple, there is a higher variance of the root node degree and hence of the average distance to the root. The distances in the randomized graph were generally lower than in the original Facebook graph due to its lower average path length. Furthermore, $\overline{d}(r)$ correlated more strongly with the RLN, possibly due to the absence of outlier nodes with increased shortest path length. Because of the highly skewed degree distribution of the Ripple graph, the random root node’s degree was $1$ in 73 out of a 100 runs. The degree of the adversarial node, i.e., 25, was hence generally higher than the degree of the root, leading to shorter paths to the malicious nodes and hence the observed high RLN.

Algorithm 1

In addition to $\overline{d}(r)$, we computed the effective average hop distance $D(m)=\overline{d}(m)+d(m,r)-1$, as $d(m,r)-1$ is the $level$-value that $m$ propagated during a simulation run. We expected a positive correlation between $\overline{d}(r)-D(m)$ and the RLN, i.e., nodes closer to the root node than $D(m)$ should be well-directed and otherwise not.

In all runs with 25 attack edges, $D(m)$ was considerably higher than $\overline{d}(r)$ such that only a very small number of nodes became ill-directed. Figure 4 thus shows our more distinct results for an adversary with 1000 attack edges, ordered by the RLN. The results indeed validated the expected correlation. Due to the high number of attack edges, the $\overline{d}(m)$ value of each run only differed slightly from its mean value of $2.75$, $2.52$, $2.63$, and $2.02$ for the Facebook graph, the randomized Facebook graph, the ER graph, and the Ripple graph, respectively. Thus, the values of $D(m)$ mainly depended on $d(m,r)$ and hence differed by integer values.

Again, the degree of correlation between $\overline{d}(r)-D(m)$ and the RLN varied between graphs. The Facebook graph generally had a longer average shortest path length and hence varied in $\overline{d}(r)$ considerably. In contrast, the value of $\overline{d}(r)$ was more stable for the randomized Facebook graph and the ER graph, so that $d(m,r)$ is indeed the main impact factor.

Here, we also find the explanation for the strong difference between the mean RLN values for the simulations of Algorithm 1 with a cheating adversary and those of Algorithm 1 with a non-cheating adversary on the Ripple graph. It stems from the fact that the $d(m,r)$ value decreased very slowly as the number of attack edges increases. Concretely, the mean value of $\overline{d}(r)$ was roughly $3.8$, irrespective of the number of attack edges and the construction algorithm. In the case of 25 attack edges, the mean value for $D(m)$ was $3.9$ and in the case of $5000$ edges, it was $2.9$, such that the $level$ value propagated by $m$ was low enough to cause a high number of nodes to become ill-directed. As the value of $D(m)$ was increased by 1 when the adversary does not cheat, it was higher than $\overline{d}(r)$ for any considered number of attack edges, resulting in a negative $\overline{d}(r)-D(m)-1$ and hence a low impact of the attack. In contrast, $\overline{d}(r)-D(m)$ was positive, corresponding to an attack of high impact.

Summary of Results

The first part of our evaluation showed that our protocol based on cryptographic signatures is much more robust to malicious behavior and attacks than state-of-the-art solutions without the usage of cryptography. Indeed, as displayed in Figure 1, to compromise a similar number of nodes, the adversary needs to establish up to 200 times as many attack edges compared to the algorithm by Dubois et al. [5].

VII Conclusion

In this paper, we leveraged cryptographic signatures to design a BFS tree algorithm that greatly reduces the number of nodes affected by attacks. Based on the concept of topology-aware strict stabilization, we proved that this algorithm only allows malicious nodes to report a distance to the root that differs by at most one from the correct value. Our evaluation based on real-world scenarios demonstrates that this novel construction provides crucial security improvements over existing, non-cryptographic algorithms. Yet, our results indicate that the resistance to attacks is highly correlated with the degree of the root node, highlighting the need to develop secure leader election algorithms that prioritize high-degree nodes.

VIII Acknowledgements

We thank Sebastién Tixeuil for shepherding our work and the reviewers for their constructive feedback. This work has been funded by the German Research Foundation (DFG) Grant STR 1131/2-2 and EXC 2050 “CeTI´´.