Secure Coded Cooperative Computation at the Heterogeneous Edge against Byzantine Attacks

TL;DR

This paper introduces SC3, a secure and efficient coded cooperative computation mechanism for edge computing that defends against Byzantine attacks and adapts to device heterogeneity and variability.

Contribution

The paper proposes a novel SC3 mechanism combining homomorphic hash functions with coded computation to enhance security and efficiency in heterogeneous edge environments.

Findings

SC3 significantly reduces task completion delay.

SC3 effectively defends against Byzantine attacks.

The mechanism adapts to device heterogeneity and time-varying conditions.

Abstract

Edge computing is emerging as a new paradigm to allow processing data at the edge of the network, where data is typically generated and collected, by exploiting multiple devices at the edge collectively. However, offloading tasks to other devices leaves the edge computing applications at the complete mercy of an attacker. One of the attacks, which is also the focus of this work, is Byzantine attacks, where one or more devices can corrupt the offloaded tasks. Furthermore, exploiting the potential of edge computing is challenging mainly due to the heterogeneous and time-varying nature of the devices at the edge. In this paper, we develop a secure coded cooperative computation mechanism (SC3) that provides both security and computation efficiency guarantees by gracefully combining homomorphic hash functions and coded cooperative computation. Homomorphic hash functions are used against Byzantine attacks and coded cooperative computation is used to improve computation efficiency when edge resources are heterogeneous and time-varying. Simulations results show that SC3 improves task completion delay significantly.

Equations

$$h(a)\triangleq \mathrm{mod}(g^{\mathrm{mod}(a,q)},r),$$

$${\alpha }_n=h(\sum _{i=1}^{Z_n}{c}_i{\tilde{y}}_{n,i}),$$

$$\displaystyle\beta_{n}=\mod\Big{(}\prod_{j=1}^{C}h(x_{j})^{\mod\big{(}(\sum_{i=1}^{Z_{n}}{c_{i}}p_{n,i,j}),q\big{)}},r\Big{)},$$

$$P_{\text{detect}}^{\text{LW}}$$

$$P_{\text{detect}}^{\text{HW}}=1-\frac{1}{q}$$

$$Z_n\ge \frac{M(r)}{M(\psi )}({\log }_{2}q{)}^2,$$

$$E[T_{{\text{SC}}^3}]\le$$

$$\displaystyle\frac{R+\epsilon}{\sum_{n\in\mathcal{N}}1/E[\beta_{n,i}]}+\frac{\sum_{n\in\mathcal{N}_{m}}z_{n}\Big{(}P+\rho_{c}\big{(}1-P\big{)}\Big{)}}{\sum_{n\notin\mathcal{N}_{m}}1/E[\beta_{n,i}]},$$

$$z_n=\frac{R+ϵ}{E[{\beta }_{n,i}]{\sum }_{n\in \mathcal{N}}1/E[{\beta }_{n,i}]},$$

$$P=1-\Big{(}\frac{(z_{n}\rho_{c})!}{2^{(z_{n}\rho_{c})}\big{(}({z_{n}\rho_{c}}/{2})!\big{)}^{2}}\Big{)}.$$

$$T_{\text{HW-only}}-E[T_{{\text{SC}}^3}]\ge$$

$$\displaystyle\frac{(R+\epsilon)(1-\rho_{c})\sum_{n\in\mathcal{N}_{m}}\frac{1-P}{E[\beta_{n,i}]}}{\big{(}\sum_{n\in\mathcal{N}}1/E[\beta_{n,i}]\big{)}\big{(}\sum_{n\notin\mathcal{N}_{m}}1/E[\beta_{n,i}]\big{)}}.$$

$${\alpha }_n$$

$$\displaystyle=\mod\big{(}g^{\mod(\sum_{i=1}^{Z_{n}}c_{i}\tilde{y}_{n,i},q)},r\big{)}$$

$$\displaystyle=\mod\big{(}g^{\mod(\sum_{i=1}^{Z_{n}}c_{i}y_{n,i},q)},r\big{)}$$

$$\displaystyle=\mod\big{(}g^{\mod(\sum_{i=1}^{Z_{n}}c_{i}\sum_{j=1}^{C}p_{n,i,j}x_{j},q)},r\big{)}$$

$$\displaystyle=\mod\big{(}g^{(\sum_{i=1}^{Z_{n}}\sum_{j=1}^{C}c_{i}p_{n,i,j}x_{j})-qq^{\prime}},r\big{)}$$

$$\displaystyle=\mod\big{(}g^{\sum_{i=1}^{Z_{n}}\sum_{j=1}^{C}c_{i}p_{n,i,j}x_{j}},r\big{)}$$

$$\times \mathrm{mod}(g^{-q{q}^{\prime }},r),$$

$$\mathrm{mod}(g^{q\times q^{\prime }},r)$$

$$=\mathrm{mod}(b^{(r-1)\times q^{\prime }},r)$$

$$=1.$$

$$\displaystyle\mod\big{(}g^{\mod(\sum_{i=1}^{Z_{n}}\sum_{j=1}^{C}c_{i}p_{n,i,j}x_{j},q)},r\big{)}$$

$$\displaystyle=\mod\big{(}g^{\sum_{i=1}^{Z_{n}}\sum_{j=1}^{C}c_{i}p_{n,i,j}x_{j}},r\big{)}$$

$$\mathrm{mod}(g^{x_j},r)=\mathrm{mod}(g^{\mathrm{mod}(x_j,q)},r)$$

$$\mathrm{mod}(g^{x_j{\sum }_{i=1}^{Z_n}{c}_i{p}_{n,i,j}},r)=$$

$$\mathrm{mod}(g^{x_j\mathrm{mod}({\sum }_{i=1}^{Z_n}{c}_i{p}_{n,i,j},q)},r)$$

$${\alpha }_n$$

$$=\mathrm{mod}(\prod _{j=1}^C{g}^{{\sum }_{i=1}^{Z_n}{c}_i{p}_{n,i,j}{x}_j},r)$$

$$=\mathrm{mod}(\prod _{j=1}^C{g}^{x_j\mathrm{mod}({\sum }_{i=1}^{Z_n}{c}_i{p}_{n,i,j},q)},r)$$

$$=\mathrm{mod}(\prod _{j=1}^C$$

$$(\mathrm{mod}(g^{\mathrm{mod}(x_j,q)},r){)}^{\mathrm{mod}({\sum }_{i=1}^{Z_n}{c}_i{p}_{n,i,j},q)},r)$$

$$\displaystyle=\mod\big{(}\prod_{j=1}^{C}h(x_{j})^{\mod(\sum_{i=1}^{Z_{n}}c_{i}p_{n,i,j},q)},r\big{)}$$

$$={\beta }_n$$

$$\mathrm{mod}(\sum _{i\in {\tilde{\mathcal{Z}}}_n}{c}_i(y_{n,i}-{\tilde{y}}_{n,i}),q)=0,$$

$$\mathrm{mod}(c_j(y_{n,j}-{\tilde{y}}_{n,j}),q)=$$

$$\mathrm{mod}(\sum _{i\in {\tilde{\mathcal{Z}}}_n,i\ne j}{c}_i(y_{n,i}-{\tilde{y}}_{n,i}),q)$$

$$R+ϵ-V\le \sum _{n\in {\mathcal{N}}_m}{z}_n(P+{\rho }_c(1-P)),$$

$$T_{\text{HW-only}}=$$

$$=$$

Full text

Simulations results show that SC3 improves task completion delay significantly.

I Introduction

Edge computing is emerging as a new paradigm to allow processing data at the edge of the network, where data is typically generated and collected. This paradigm advocates offloading tasks from an edge device to other edge/end devices including mobile devices, and/or servers in close proximity. Edge computing can be used in Internet of Things (IoT) applications which connects an exponentially increasing number of devices, including smartphones, wireless sensors, and health monitoring devices at the edge. Many IoT applications require processing the data collected by these devices through computationally intensive algorithms with stringent reliability, security and latency constraints. In many scenarios, these algorithms cannot be run locally on computationally-limited IoT-devices.

One of the existing solutions to handle computationally-intensive tasks is computation offloading, which advocates offloading tasks to remote servers or to cloud computing platforms. Yet, offloading tasks to remote servers or to the cloud could be a luxury that cannot be afforded by most edge applications, where connectivity to remote servers can be expensive, energy consuming, lost or compromised. In addition, offloading tasks to remote servers may not be efficient in terms of delay, especially when data is generated and collected at the edge. This makes edge computing a promising solution to handle computationally-intensive tasks, where the task is divided into sub-tasks and each sub-task is offloaded to an edge device for computation.

However, offloading tasks to other devices leaves the edge computing applications at the complete mercy of an attacker. One of the attacks, which is the focus of this work, is Byzantine attacks, where one or more devices (workers) can corrupt the offloaded tasks. Furthermore, exploiting the potential of edge computing is challenging mainly due to the heterogeneous and time-varying nature of the devices at the edge. Thus, our goal is to develop a secure, dynamic, and heterogeneity-aware edge computing mechanism that provides both security and computation efficiency guarantees.

Our key tool is the graceful use of coded cooperative computation and homomorphic hash functions. Coded computation advocates mixing data in computationally-intensive tasks by employing erasure codes and offloading these coded tasks to other devices for computation [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]. The following canonical example demonstrates the effectiveness of coded computation.

Example 1

Consider the setup where a master device wishes to offload a task to 3 workers. The master has a large data matrix $A$ and wants to compute matrix vector product $A\mathbf{x}$.

The master device divides the matrix $A$ row-wise equally into two smaller matrices $A_{1}$ and $A_{2}$, which are then encoded using a $(3,2)$ Maximum Distance Separable (MDS) code111An $(n,k)$ MDS code divides the master’s data into $k$ chunks and encodes it into $n$ chunks ($n>k$) such that any $k$ chunks out of $n$ are sufficient to recover the original data. to give $B_{1}=A_{1}$, $B_{2}=A_{2}$ and $B_{3}=A_{1}+A_{2}$, and sends each to a different worker. Also, the master device sends $\mathbf{x}$ to workers and asks them to compute $B_{i}\mathbf{x}$, $i\in\{1,2,3\}$. When the master receives the computed values (i.e., $B_{i}\mathbf{x}$) from at least two out of three workers, it can decode its desired task, which is the computation of $A\mathbf{x}$. The power of coded computations is that it makes $B_{3}=A_{1}+A_{2}$ act as a “joker” redundant task that can replace any one of the other two tasks if a worker ends up straggling, i.e., being slow or unresponsive. $\Box$

This example demonstrates the benefit of coding for edge computing. However, the very nature of task offloading to workers makes the computation framework vulnerable to attacks. We focus on Byzantine attacks in this work. For example, if workers $1$ and $3$ in Example 1 corrupt $B_{1}\mathbf{x}$ and $B_{3}\mathbf{x}$, the master can only obtain a wrong value of $A\mathbf{x}$. Thus, it is crucial to develop a secure coded computation mechanism for edge devices against this type of attacks.

In this paper, we develop a secure coded cooperative computation (SC3) mechanism which uses homomorphic hash functions. Example 2 illustrates the main idea of homomorphic hash functions in coded computation.

Example 2

Consider the same setup in Example 1, and assume that worker $i$ returns the computed value $\tilde{\mathbf{y}}_{i}$ to the master device. If worker $i$ is an honest worker, $\tilde{\mathbf{y}}_{i}=B_{i}\mathbf{x}$ holds. The master device checks the integrity of $\tilde{\mathbf{y}}_{i}$ by calculating its hash function $h(\tilde{\mathbf{y}}_{i})$, where $h$ is a homomorphic hash function. (The details of the homomorphic hash function which we use will be provided in Section II.) The master also calculates $h(B_{i}\mathbf{x})$ using its local information, i.e., using $h(\mathbf{x})$ and $B_{i}$. If the master finds that $h(\tilde{\mathbf{y}}_{i})\neq h(B_{i}\mathbf{x})$, it concludes that the computed value is corrupted. Otherwise, $\tilde{\mathbf{y}}_{i}$ is declared as verified.

$\Box$**

The above example shows how homomorphic hash functions can be used for coded computation. However, existing hash-based solutions [14, 15] introduce high computational overhead, which is not suitable for edge applications, where computation power and energy are typically limited. In this paper, we use homomorphic hash functions and coded computation gracefully and efficiently. In particular, we develop and analyze light-weight and heavy-weight integrity check tools for coded computation using homomorphic hash functions. We design SC3 by exploiting both light- and heavy-weight tools. The following are the key contributions of this work:

• •

We use a homomorphic hash function as in [15] and show that the hash of a linear combination of computed values can be constructed by the hashes of the original tasks.

• •

We develop light- and heavy-weight integrity check tools for coded computation, and analyze these tools in terms of computation complexity and attack detection probability. We also analyze the trade-off between using light- and heavy-weight tools for different number of tasks.

• •

We design SC3 by exploiting light- and heavy-weight tools. If an attack is detected, SC3 can pinpoint which tasks are corrupted.

• •

We analyze the task completion delay of SC3 by providing an upper bound as well as a lower bound on the gap between the task completion delay of SC3 and a baseline.

• •

We evaluate SC3 for different number and strength of malicious (Byzantine) workers. The simulation results show that our algorithm significantly improves task completion delay as compared to the baselines.

The structure of the rest of this paper is as follows. Section II presents our system model. Section III presents light- and heavy-weight integrity check tools. Section IV presents our secure coded cooperative computation (SC3) algorithm. Section V provides the theoretical analysis of the task completion delay of SC3. Section VI provides simulation results of SC3. Section VII presents related work. Section VIII concludes the paper.

II System Model

Setup. We consider a master/worker setup at the edge of the network, where the master device offloads its computationally intensive tasks to workers $w_{n}$, $n\in\mathcal{N}$ (where $|\mathcal{N}|=N$) via device-to-device (D2D) links such as Wi-Fi Direct and/or Bluetooth. The master device divides a task into smaller sub-tasks, and offloads them to parallel processing workers. Task Model. Our focus is on computation of linear functions; *i.e., *the master device would like to compute the multiplication of matrix $A$ with vector $\mathbf{x}$; $y=A\mathbf{x}$, where $A=(a_{i,j})\in\mathbb{F}_{\psi}^{R\times C}$, $\mathbf{x}=(x_{i})\in\mathbb{F}_{\psi}^{C\times 1}$, and $\mathbb{F}_{\psi}$ is a finite field. The motivation of focusing on linear functions stems from matrix multiplication applications where computing linear functions is a building block of several iterative algorithms such as gradient descent.

Coding. We divide matrix $A$ into $R$ rows denoted by $A_{i}$, $i=1,\ldots,R$. The master device applies Fountain coding [16, 17, 18] across rows to create coded information packets $\mathbf{q}_{j}\triangleq\sum_{i=1}^{R}\gamma_{i,j}A_{i}$, $j=1,2,\ldots,R+\epsilon$, where $\epsilon$ is the overhead required by Fountain coding222The overhead required by Fountain coding is typically as low as 5% [18]., and $\gamma_{i,j}\in\{0,1\}$ are coding coefficients of Fountain coding and the information packet $\mathbf{q}_{j}$ is a row vector with size $C$. Rateless coding enabled by Fountain codes is compatible with our goal to deal with heterogeneity and time-varying nature of resources. In other words, coded packets are generated on the fly and transmitted to workers depending on the amount of their resources (as described in Section IV-A) and Fountain codes are flexible to achieve this goal.

Worker & Attack Model. The workers incur random delays while executing the task assigned to them by the master device. The workers have different computation and communication specifications resulting in a heterogeneous environment which includes workers that are significantly slower than others, known as stragglers. Moreover, the workers cannot be trusted by the master. In particular, we consider Byzantine attacks, where one or more workers can corrupt the tasks that are assigned to them.

Homomorphic Hash Function. We consider the following hash function that maps a large number $a$ to an output with much smaller size

[TABLE]

where $q$ is a prime number selected randomly from the field $\mathbb{F}_{\phi}$, $r$ is a prime number that satisfies $q|(r-1)$ (i.e., $r-1$ is divisible by $q$) and $g$ is a number in $\mathbb{F}_{r}$ which is calculated as $g=b^{(r-1)/q}$ for a random selection of $b\in\mathbb{F}_{r},b\neq 1$ [14, 15]. The defined hash function is a collision-resistant hash function with the property that when $\phi$ increases, $a$ is compressed less; i.e., $h(a)$ becomes a better approximation of $a$ for larger $\phi$. However, the computational cost of calculating $h(a)$ increases for larger $\phi$. Thus, there is a trade-off between computational complexity and better approximation of $a$ in calculating $h(a)$. Our goal is to exploit this trade-off in the context of coded computation as described in the next sections. Another property of the defined hash function is homomorphism, i.e., $h(\sum_{i}c_{i}a_{i})=\prod_{i}h(a_{i})^{c_{i}}$, which we will exploit in matrix-vector multiplication (in Section III).

Delay Model. Each packet transmitted from the master to a worker $w_{n},\ n=1,2,...,N$ experiences the following delays: (i) transmission delay for sending the packet from the master to the worker, (ii) computation delay for computing the multiplication of the packet by the vector $\mathbf{x}$, and (iii) transmission delay for sending the computed packet from the worker $w_{n}$ back to the master. We denote by $\beta_{n,i}$ the computation time of the $i^{\text{th}}$ packet at worker $n$.

III Light- and Heavy-Weight Integrity Check Tools for Coded Computation

In this section we present how homomorphic hash functions considered in [14, 15] and defined in (1) are used gracefully with coded computation. We first show that (1) can be applied to coded computation. Then, we develop light- and heavy-weight integrity check tools. The tools we develop in this section will be building blocks of our secure coded cooperative computation mechanism (SC3).

III-A Homomorphic Hash Function for Coded Computation

Let us consider that $Z_{n}$ coded information packets are offloaded to worker $w_{n}$. The $i^{\text{th}}$ packet offloaded to $w_{n}$ is $\mathbf{p}_{n,i}\in\{\mathbf{q}_{1},\ldots,\mathbf{q}_{R+\epsilon}\}$, which can be represented as $\mathbf{p}_{n,i}=\left(p_{n,i,1},\dots,p_{n,i,C}\right)$, where $p_{n,i,j}$ is the $j^{\text{th}}$ element of vector $\mathbf{p}_{n,i}$. Worker $w_{n}$ calculates $y_{n,i}=\mathbf{p}_{n,i}\mathbf{x}$ and sends it back to the master device.

Assume that the master receives $\tilde{y}_{n,i}$ from $w_{n}$, where $\tilde{y}_{n,i}=y_{n,i}$ if packet is not corrupted. The master device checks the integrity of packets calculated at $w_{n}$ according to the following rule. First, it calculates

[TABLE]

using the hash function defined in (1), where $c_{i}$’s are coefficients (We will discuss how $c_{i}$ is selected later in this section.). Next, it calculates

[TABLE]

where $x_{j}$ is the $j^{\text{th}}$ element of vector $\mathbf{x}$, and $q$ and $r$ are the parameters of the hash function defined in (1). $\beta_{n}$ in (3) is calculated by the master device using its local data $\mathbf{p}_{n,i}$ and $\mathbf{x}$. $\beta_{n}$ is used to check $\alpha_{n}$ as described in the next theorem.

Theorem 1

If $w_{n}$ does not corrupt packets, i.e., $\tilde{y}_{n,i}=y_{n,i}$, $\forall i$, and $c_{i}$ is a nonzero integer, then $\alpha_{n}=\beta_{n}$ holds.

Proof: The proof is provided in Appendix A. $\blacksquare$

We note that Theorem 1 is necessary, but not sufficient condition to determine if $w_{n}$ is malicious or not. The sufficiency condition depends on how $c_{i}$ is selected as explained next.

III-B Light-Weight Integrity Check (LW Function)

The light-weight integrity check (LW function) uses Theorem 1 to determine if workers corrupt packets or not. In particular, LW function calculates $\alpha_{n}$ in (2) and $\beta_{n}$ in (3) by selecting $c_{i}$ randomly and uniformly from $\{-1,1\}$. LW function concludes that packets processed by $w_{n}$ are not corrupted if $\alpha_{n}=\beta_{n}$. However, as we discussed earlier, this condition is not always a sufficient condition, so LW function detects attacks with some probability, which is provided next.

III-B1 Probability of Attack Detection

We first consider a pairwise Byzantine attack, where malicious worker $w_{n}$ corrupts two packets out of $Z_{n}$ packets by adding and subtracting terms. For example, $\tilde{y}_{n,i}=y_{n,i}+\delta_{i}$ and $\tilde{y}_{n,j}=y_{n,j}-\delta_{j}$, for any arbitrary $i$,$j\leq Z_{n}$ satisfying $i\neq j$. In this attack pattern, if $|\delta_{i}|\neq|\delta_{j}|$, and considering that the coefficients are selected from $\{-1,1\}$ in LW function, the attack is detected with 100% probability. On the other hand, if the attack is symmetric, i.e., $|\delta_{i}|=|\delta_{j}|$, the probability of detecting the attack is 50%. As symmetrical attacks are the most difficult ones to detect, we focus on this scenario in the next lemma.

Lemma 2

Consider an attack where the malicious worker $w_{n}$ selects an even number $\tilde{Z}_{n}$ randomly out of $Z_{n}$ packets and corrupt them by adding $\delta$ to half of them, and subtracting $\delta$ from the other half. The probability of attack detection by LW function is

[TABLE]

Proof: The proof is provided in Appendix B. $\blacksquare$

As seen from Lemma 2, the probability of attack detection increases with increasing number of corrupted packets. This result intuitively holds for any attack pattern as the coefficients ($c_{i}$) are selected randomly for each packet and estimating these values by an attacker becomes difficult for larger set of corrupted packets. Another attack pattern and its detection probability are provided in the following.

Consider an attack pattern where the malicious worker $w_{n}$ corrupts three packets out of $Z_{n}$ packets by adding $\delta$ to two of randomly selected computed packets and subtracting $2\delta$ from another randomly selected computed packet. This attack pattern can be detected unless the coefficients for the three corrupted packets are all $1$’s or all $-1$’s. Therefore, the probability of attack detection for this attack pattern is $(1-2/2^{3})\times 100=75\%$. For a general attack pattern, the following lemma, provides a lower bound on the probability of attack detection.

Proposition 3

The probability of attack detection when LW function is used and for any attack pattern is lower bounded by $P_{\text{detect}}^{\text{LW}}\geq 0.5$.

Proof: The proof is provided in Appendix C. $\blacksquare$

III-B2 Computational Complexity

Theorem 4

The computational complexity of LW function for checking $Z_{n}$ packets calculated by $w_{n}$ is $O(CM(r)\log_{2}q)$, where $C$ is the size of each information packet, $M(r)$ is the complexity of multiplication in $\mathbb{F}_{r}$, and $r$ and $q$ are the parameters of the hash function defined in (1).

Proof: The complexity of LW function consists of two parts; calculation of $\alpha_{n}$ in (2) and $\beta_{n}$ in (3). We first analyze computational complexity of calculating $\alpha_{n}$. The sum $\sum_{i=1}^{Z_{n}}c_{i}\tilde{y}_{n,i}$ only has addition and subtraction as $c_{i}\in\{-1,1\}$, and can be ignored. The complexity of the modular exponentiation while calculating the hash function is $O(M(r)\log_{2}q)$ by using the method of exponentiation by squaring.

Similarly, we can calculate the computational complexity of calculating $\beta_{n}$. The complexity for computing $\sum_{i=1}^{Z_{n}}c_{i}p_{n,i,j}$ corresponds to the complexity of addition and subtraction, which is negligible. The complexity of computing $\mod(\prod_{j=1}^{C}h(x_{j})^{\mod(\sum_{i=1}^{Z_{n}}{c_{i}}p_{n,i,j},q)},r)$ has two components: (i) Calculating the modular exponentiations $h(x_{j})^{\mod(\sum_{i=1}^{Z_{n}}{c_{i}}p_{n,i,j},q)},\forall j=1,2,...,C$: The complexity for this calculation is $O(M(r)\log_{2}q)$ for one modular exponentiation and $O(CM(r)\log_{2}q)$ for all $C$ modular exponentiations. (ii) Multiplying all the calculated modular exponentiations, i.e., $\prod_{j=1}^{C}h(x_{j})^{\mod(\sum_{i=1}^{Z_{n}}{c_{i}}p_{n,i,j},q)}$ in $\mathbb{F}_{r}$: The complexity for this calculation is $O((C-1)M(r))$. Thus, the total complexity of LW function becomes $O(CM(r)\log_{2}q)$. This concludes the proof. $\blacksquare$

Noting that the computational complexity of calculating the original matrix multiplication is $O(RCM(\psi))$, where $M(\psi)$ is the complexity of multiplication in $\mathbb{F}_{\psi}$. As seen, the complexity of the LW function is significantly low, compared to the original task. This means LW function provides security check with low complexity. However, the probability of attack detection using LW function could be as low as 50%, which may not be acceptable in some applications. Thus, we provide a heavy-weight integrity check tool (HW function) in the next section. Our ultimate goal is to use LW and HW functions together for higher attack detection probability while still having low computational complexity.

III-C Heavy-Weight Integrity Check (HW Function)

The heavy-weight integrity check (HW function) uses Theorem 1 similar to the LW function, but chooses the coefficients $c_{i}$ from a larger field $\mathbb{F}_{q}$ rather than $\{-1,1\}$. This selection, *i.e., *choosing coefficients from a larger field, comes with larger attack detection probability and computational complexity as described next.

III-C1 Probability of Attack Detection

Lemma 5

The probability that HW function detects a Byzantine attack with any attack pattern is expressed as

[TABLE]

where $q$ is the parameter of the hash function in (1).

Proof: The proof is provided in Appendix D. $\blacksquare$

As seen from Lemma 5, the attack detection probability increases with increasing $q$. Next, we present the computational complexity of HW function.

III-C2 Computational Complexity

Theorem 6

The computational complexity of HW function for checking $Z_{n}$ packets calculated by $w_{n}$ is $O(CZ_{n}M(\phi))$.

Proof: The proof follows the same logic of the proof of Theorem 4, *i.e., *the complexity of HW function depends on calculating $\alpha_{n}$ in (2) and $\beta_{n}$ in (3). The difference as compared to the proof of Theorem 4 is that $c_{i}$’s are selected from a larger field, so reducing multiplication to addition in $\sum_{i=1}^{Z_{n}}c_{i}\tilde{y}_{n,i}$ of (2) and $\sum_{i=1}^{Z_{n}}{c_{i}}p_{n,i,j}$ of (3) cannot be made. In particular, the complexity of calculating these terms is $O(Z_{n}M(\phi))$. Following similar steps as in the proof of Theorem 4, we can conclude that the computational complexity of HW function becomes $O(CM(r)\log_{2}q)+O(CZ_{n}M(\phi))$. Since the second term dominates the computational complexity for large $R$ (hence $Z_{n}$), we calculate the computational complexity as $O(CZ_{n}M(\phi))$. This concludes the proof. $\blacksquare$

We can approximate $Z_{n}$ to $(R+\epsilon)/N$ on average assuming that coded information packets are distributed homogeneously across workers, where $R$ is the number of information packets, $\epsilon$ is the Fountain coding overhead, and $N$ is the number of workers. Thus, the computational complexity of HW function across all workers becomes $NO(\frac{C(R+\epsilon)}{N}M(\phi))$. As we discussed earlier, the computational complexity of the original matrix multiplication is $O(RCM(\psi))$. We also note that $M(\psi)>>M(\phi)$. This means that even though HW function is computationally-complex as compared to LW function, it is still computationally-efficient with respect to the original matrix multiplication (considering that $\epsilon$ is small and approaches to 0 with increasing number of packets).

III-D Light- versus Heavy-Weight Integrity Check

In this section, we investigate employing LW function multiple rounds/times to achieve higher attack detection probability with low computational complexity. LW function is used to check $Z_{n}$ packets computed by $w_{n}$ by selecting $c_{i}$ uniformly randomly from $\{-1,1\}$. Let us call this the first round. In the second round, we can use LW function again, but selected values of $c_{i}$ will be different from the first round. Thus, if an attack is not detected in the first round, it may still be detected in the next round. Thus, using LW function over multiple rounds will increase the attack detection probability. The next theorem characterizes the performance of LW function when used in multiple rounds as compared to HW function.

Theorem 7

The attack detection probability of multiple-round LW function is equal to the attack detection probability of HW function in (5) when LW function is used for $\log_{2}(q)$ rounds. Furthermore, the computational complexity of $\log_{2}(q)$-round LW function is lower than HW function if the following condition is satisfied.

[TABLE]

Proof: The proof is provided in Appendix E. $\blacksquare$

IV SC3: Secure Coded Cooperative Computation

In this section, we present our secure coded cooperative computation (SC3) mechanism. SC3 consists of packet offloading, attack detection, and attack recovery modules.

IV-A * Dynamic Packet Offloading*

The dynamic packet offloading module of SC3 is based on [1]. In particular, the master offloads coded packets gradually to workers and receives two ACKs for each transmitted packet; one confirming the receipt of the packet by the worker, and the second one (piggybacked to the computed packet) showing that the packet is computed by the worker. Then, based on the frequency of the received ACKs, the master decides to transmit more/less coded packets to that worker. In particular, each packet $\mathbf{p}_{n,i}$ is transmitted to each worker $w_{n}$ before or right after the computed packet $\mathbf{p}_{n,i-1}\mathbf{x}$ is received at the master. For this purpose, the average per packet computing time $E[\beta_{n,i}]$ is calculated for each worker $w_{n}$ dynamically based on the previously received ACKs. Each packet $\mathbf{p}_{n,i}$ is transmitted after waiting $E[\beta_{n,i}]$ from the time $\mathbf{p}_{n,i-1}$ is sent or right after packet $\mathbf{p}_{n,i-1}\mathbf{x}$ is received at the master, thus reducing the idle time at the workers. This policy is shown to approach the optimal task completion delay and maximizes the workers’ efficiency and is shown to improve task completion delay significantly compared with the literature [1].

IV-B Attack Detection

Assume that while the dynamic packet offloading process continues, the set of received packets from worker $w_{n}$ at the master device during time interval $T$ is $\mathcal{Z}_{n}$ ($|\mathcal{Z}_{n}|=Z_{n}$). The attack detection module of SC3 is applied on $\mathcal{Z}_{n}$ periodically and consists of two phases.

The first phase applies LW function on the packets in $\mathcal{Z}_{n}$ for any worker $w_{n},n\in\mathcal{N}$. Let us assume that attack is detected in the packets coming from worker $w_{n^{*}}$. Then, all the packets in $\mathcal{Z}_{n^{*}}$ are discarded and the malicious worker $w_{n^{*}}$ is removed from the set of workers, i.e., $\mathcal{N}=\mathcal{N}-n^{*}$. As we discussed earlier, the attack detection probability of LW function increases with increasing corrupted packets. Thus, if an attack is detected in this phase, we can consider that most of the packets are corrupted, so we can discard all the received packets.

The goal of the second phase is to detect any attacks, which are not detected in the first phase. Both HW and multiple-round LW functions are used in this phase. In particular, if the inequality in Theorem 7 is satisfied, LW function is used for $\log_{2}(q)$ times. Otherwise, HW function is used. If an attack is not detected, all the packets in $\mathcal{Z}_{n}$ are labeled as verified packets. Otherwise, *i.e., *if an attack is detected, the attack recovery module, which is described later in this section, starts.

IV-C Attack Recovery

If an attack is detected in the second phase of the attack detection module of SC3, we consider that a small number of packets are corrupted. Otherwise, the first phase of the attack detection module could have detected the attack and discarded all the packets. Thus, the goal of the attack recovery module is to detect a small number of corrupted packets and recover the non-corrupted packets, *i.e., *avoid discarding all the packets.

Let us assume that an attack is detected among the packets received from $w_{n^{*}}$, *i.e., *in $\mathcal{Z}_{n^{*}}$. In order to pinpoint the packets that are corrupted, we use a binary search algorithm. In particular, $\mathcal{Z}_{n^{*}}$ is divided into two disjoint sets; $\mathcal{Z}_{n^{*}}^{1}$ and $\mathcal{Z}_{n^{*}}^{2}$. The second phase of the attack detection module is run over these two sets. If an attack is not detected on any of these sets, all the packets in that set are verified. Otherwise, the binary search (this set splitting) continues over the sets where an attack is detected. When the size of a splitted set is one, *i.e., *it has one packet in it, and an attack is detected, the packet in that set is declared a corrupted packet and discarded. As seen, the attack recovery module can still verify some of the packets coming from a malicious worker. This is important to efficiently utilize available resources while still providing security guarantees.

IV-D SC3 in a nutshell

SC3 algorithm is provided in Algorithm 1. As detailed in this algorithm, in SC3, the attack detection module, which if required will be followed by the attack recovery module, is applied until the number of verified packets from all workers reaches $R+\epsilon$ (Note that $R+\epsilon$ is the number of packets required for a successful decoding of Fountain codes). In particular, first, the attack detection module is applied on each $\mathcal{Z}_{n}$ set of packets received from worker $w_{n},n\in\mathcal{N}$ during the time period $T$, where $T$ is defined as the time period that $R+\epsilon$ packets are received collectively from all workers, i.e., $\sum_{n=1}^{N}Z_{n}=R+\epsilon$. If all $R+\epsilon$ packets in the set $\cup_{n=1}^{N}\mathcal{Z}_{n}$ are labeled as verified, then all workers have been honest and sent back correct results to the master device. Otherwise, *i.e., *if an attack is detected, then the number of correct packets delivered by honest workers and labeled as verified, is less than $R+\epsilon$. In this case, the master device waits until it receives additional $R+\epsilon-V$ packets collectively from all workers, where $V$ is the number of packets labeled as verified. Then, for each worker $w_{n},n\in\mathcal{N}$, the attack detection module is applied on the set of newly received packets. This process is repeated until $R+\epsilon$ packets are labeled as verified. Finally, Fountain decoding is applied on $R+\epsilon$ packets labeled as verified and the result of the multiplication task is obtained by the master device.

V Performance Analysis of SC3

In this section, we first characterize the task completion delay of SC3 and then we provide a lower bound on the gap between the task completion delay of SC3 and the task completion delay of a baseline. The task completion delay is the time spent to receive $R+\epsilon$ computed and verified packets at the master device collectively from all workers.

Theorem 8

The average task completion delay of SC3 for a set of workers $\{w_{n},n\in\mathcal{N}\}$, out of which $\{w_{n},n\in\mathcal{N}_{m}\}$ is the set of malicious workers, is upper bounded by:

[TABLE]

where $z_{n}$ is equal to

[TABLE]

$\rho_{c}$* is the probability that a packet is corrupted by a malicious worker, and $P$ is given by*

[TABLE]

Proof: The proof is provided in Appendix F. $\blacksquare$

In the following we characterize the task completion delay of SC3 as compared with a baseline, where the master detects the malicious workers and takes advantage of only honest workers to accomplish its task. One method to detect the malicious workers is using HW function with a high value for the parameter $q$, so that the probability of attack detection given in (5) is close to $1$. We call this baseline as HW-only and denote its task completion delay by $T_{\text{HW-only}}$. Note that in HW-only, if a worker is detected as malicious, all the packets coming from that worker are discarded, while SC3 uses both LW and HW functions gracefully to discard only corrupted packets coming from malicious workers.

Lemma 9

The gap between the task completion delay of HW-only and the task completion delay of SC3 is lower bounded by:

[TABLE]

Proof: The proof is provided in Appendix G. $\blacksquare$

From Lemma 9, we can conclude that the faster the honest helpers are, the closer are the performances of HW-only and our SC3. This is expected as the performance of SC3 is dominated by the fastest workers and the performance of HW-only is dominated by the speed of honest workers and thus SC3 performs close to HW-only when the fastest workers are honest. In addition, smaller $\rho_{c}$ (which results in smaller $P$) results in larger gap between HW-only and SC3. This is expected as smaller $\rho_{c}$ results in less number of corrupted packets delivered by malicious workers and thus using SC3 that takes advantage of non-corrupted packets delivered by malicious workers results in more performance improvement compared with HW-only that throws away non-corrupted packets delivered by malicious workers. Finally, lower bound on the gap $T_{\text{HW-only}}-E[T_{\text{SC}^{3}}]$ is linearly proportional to $R+\epsilon$. This implies that more improvement is obtained by using SC3 compared with HW-only for larger input matrix $A$.

VI Performance Evaluation

In this section, we evaluate the performance of our algorithm; Secure Coded Cooperative Computation (SC3) via simulations. We consider master/worker setup, where some of the workers are malicious. Each computed packet $y_{n,i}$ is corrupted by the malicious worker $w_{n}$ with probability $\rho_{c}$. The computing resources are heterogeneous and vary across workers, where per packet computing delay $\beta_{n,i}$ is an i.i.d. random variable following a shifted exponential distribution. We compare SC3 with the baselines (i) HW-only, which uses HW function to detect corrupted packets, while SC3 uses both LW and HW functions gracefully. In HW-only, if a worker is detected as malicious, all the packets coming from that worker are discarded, (ii) Lower Bound, which is obtained by using C3P proposed in [1], the best known dynamic but unsecured coded cooperative computation. Note that C3P is not practical in the presence of an attacker, however it can provide a lower bound on SC3 and the gap between Lower Bound and SC3 shows the cost that we should pay to make our system secure against Byzantine attack, and (iii) Upper Bound provided in (7).

Task Completion Delay vs. Number of Malicious Workers. Fig. 1 compares the task completion delay of SC3 with the baselines for increasing number of malicious workers.

In this setup, the total number of workers is $N=150$, the number of rows in matrix $A$ is $R=1K$, the number of columns is $C=1K$, the overhead of Fountain codes is $5\%$, the probability of packet corruption is $\rho_{c}=0.3$, and per-packet computing delay is a shifted exponential random variable with the mean selected uniformly between $1$ and $6$ for each worker.

The task completion delay of SC3 and HW-only increases with increasing number of malicious workers. When the number of malicious workers increases, there will be more corrupted packets in the system. These corrupted packets are detected and discarded by SC3 and HW-only. As more packets are discarded when the number of malicious workers is higher, the task completion delay increases. The increase in the task completion delay of SC3 is less than HW-only thanks to (i) using both LW and HW functions to reduce completion time and thus computational complexity, and (ii) attack recovery module of SC3. SC3 performs better than its Upper Bound as the Upper Bound is based on the theoretical analysis in the worst case scenario. Finally, the completion time of Lower Bound does not change by increasing the number of malicious workers as it uses C3P in [1], which is not designed for an environment with malicious workers and uses all received packets including the corrupted packets to obtain the computation task result. By increasing the number of malicious workers, the gap between the performance of SC3 and the Lower Bound increases, as the cost for providing a secure system increases when the adversary attacks more workers.

Task Completion Delay versus Packet Corruption Probability. Fig. 2 compares the task completion delay of SC3 with (i) HW-only, (ii) Lower Bound, and (iii) Upper Bound for different values of $\rho_{c}$, the probability that a delivered packet by a malicious worker is corrupted. The number of workers, the number of rows in $A$, Fountain coding overhead, and per-packet computing delay are the same as the previous setup above. The number of malicious workers is $N_{m}=50$.

The task completion delay of HW-only does not change with increasing packet corruption probability. The reason is that HW-only does not have attack recovery feature and discards all the packets coming from a malicious worker. On the other hand, task completion delay of SC3 is significantly lower than HW-only especially when the packet corruption probability is low thanks to using both LW and HW functions and employing the attack recovery module. Again, the completion time of Lower Bound does not change by increasing $\rho_{c}$ and by increasing $\rho_{c}$, the gap between the performance of SC3 and the Lower Bound increases, as the cost for providing a secure system increases when number of corrupted packets increases.

Task Completion Delay Gap between SC3 and HW-only. Fig. 3 shows the gap between the HW-only and SC3 and compares the simulated gap with the lower bound of the gap provided in (9) for the total number of $N=80$ workers out of which $N_{m}=40$ are malicious. The number of rows in $A$ is $R=1K$ for Figs. 3(a) and (b), the number of columns is $C=1K$, Fountain coding overhead is $5\%$, the probability of packet corruption is $\rho_{c}=0.3$ for Figs. 3(a) and (c), and per-packet computing delay is a shifted exponential random variable with the mean selected uniformly between $3$ and $4$ for each worker for Figs. 3(b) and (c).

Fig. 3(a) shows the gap versus the speed of computation at honest helpers. The per-packet computing delay is a shifted exponential random variable with the mean selected uniformly between $3$ and $4$ for each malicious worker. For each honest worker, the mean is selected uniformly between $1$ and $2$ for the first simulated points, between $3$ and $4$ for the second simulated points, and between $5$ and $6$ for the third simulated points. As seen, the faster the honest workers are, the closer are the performances of the HW-only and our SC3. This observation confirms our analysis in section V.

Fig. 3(b) shows the gap versus $\rho_{c}$, the probability of packet corruption by a malicious worker. As seen, larger $\rho_{c}$ (which results in more corrupted packets delivered by malicious workers) results in smaller gap between HW-only and SC3. This observation confirms our analysis in section V.

Fig. 3(c) shows the gap versus the number of rows of matrix $A$. As seen, the gap between HW-only and SC3P increases with an increase in the number of rows of matrix $A$. This observation confirms our analysis in section V stating that more improvement will be obtained by using SC3 compared with HW-only for larger input matrix $A$.

VII Related Work

Coded computation, advocating mixing data in computationally intensive tasks by employing erasure codes and offloading these tasks to other devices for computation, has recently received a lot of attention, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]. For example, coded cooperative computation is shown to provide higher reliability, smaller delay, and reduced communication cost in MapReduce framework [19], where computationally intensive tasks are offloaded to distributed server clusters [20]. The effectiveness of coded computation in terms of task completion delay has been investigated in [11, 7, 1]. In [21], the same problem is considered, but with the assumption that workers are heterogeneous in terms of their resources. In [1], a dynamic and adaptive algorithm with reduced task completion time is introduced for heterogeneous workers. As compared to this line of work, we consider secure coded computation by focusing on Byzantine attacks.

There is existing work at the intersection of coded computation and security by specifically focusing on privacy [2, 22, 23, 24]. As compared to this line of work, we focus on Byzantine attacks and use homomorphic hash functions. Homomorphic hash functions have been widely used for transmission of network coded data. Corrupted network coded packets are detected by applying homomorphic hash functions that we consider in this work [14]. The hash function is applied to random linear combinations of network coded packets in [15]. SC3, although similar to these work, is more efficient in terms of computational efficiency, which was not the main concern of [14, 15] as their focus was on transmitting network coded packets, not computation.

VIII Conclusion

In this paper, we focused on secure edge computing against Byzantine attacks. We considered a master/worker scenario where honest and malicious workers with heterogeneous resources are connected to a master device. We designed a secure coded cooperative computation mechanism (SC3) that provides both security and computation efficiency guarantees by gracefully combining homomorphic hash functions, and coded cooperative computation. Homomorphic hash functions are used against Byzantine attacks and coded cooperative computation is used to improve computation efficiency when edge resources are heterogeneous and time-varying. Simulations results show that SC3 improves task completion delay significantly.

Appendix A: Proof of Theorem 1

[TABLE]

where $q^{\prime}$ is the quotient of dividing $(\sum_{i=1}^{Z_{n}}\sum_{j=1}^{C}c_{i}p_{n,i,j}x_{j})$ by $q$. On the other hand, as mentioned before, $g$ can be written as $b^{(r-1)/q}$ and thus by using the condition of $q|(r-1)$ and using Fermat’s little theorem, we have:

[TABLE]

From (19) and (16), we have:

[TABLE]

From the above equation, we can conclude that:

[TABLE]

and

[TABLE]

On the other hand, from (19) and (16), we have:

[TABLE]

where, (26) comes from (23) and (27) comes from (22). This concludes the proof.

Appendix B: Proof of Lemma 2

This kind of attack is not detected by the master device if the coefficients $c_{i}$ for corrupted packets are selected such that the added $\delta$’s are canceled out with the subtracted $\delta$’s. For example, let us assume there are $\tilde{Z}_{n}=4$ corrupted packets of $y_{n,1}+\delta,y_{n,2}+\delta,y_{n,3}-\delta,$ and $y_{n,4}-\delta$ among $Z_{n}=10$ packets received from worker $w_{n}$. For this attack not to be detected, there are six possibilities for values of coefficients $\{c_{1},c_{2},c_{3},c_{4}\}$: $\{1,1,1,1\}$, $\{1,-1,1,-1\}$, $\{1,-1,-1,1\}$, $\{-1,1,1,-1\}$, $\{-1,1,-1,1\}$, and $\{-1,-1,-1,-1\}$. Note that the other six coefficients $\{c_{5},\ldots,c_{10}\}$ can have any value as those packets are not corrupted. All possible cases for the first four coefficients are $2^{4}=16$ cases. Therefore, the probability of attack detection for this example is $1-6/16$. In general, for $\tilde{Z}_{n}$ corrupted packets, the number of cases the attack cannot be detected is equal to the combination of ${\tilde{Z}_{n}}\choose{\tilde{Z}_{n}/2}$. The reason is that half of the $\tilde{Z}_{n}$ coefficients for which the corrupted packets are added by $\delta$ can have any value but the other half for which the corrupted packets are subtracted by $\delta$ should be chosen such that when they are multiplied by their correspondent coefficients, the added $\delta$’s can be canceled out with the subtracted $\delta$’s. Note that any permutation of coefficients for which the corrupted packets are added by $\delta$ (or subtracted by $\delta$) do not have any effect on the attack detection. As the total number of cases for coefficient selections of the corrupted packets is equal to $2^{\tilde{Z}_{n}}$, the probability that the attack is not detected is equal to $\frac{\binom{\tilde{Z}_{n}}{\tilde{Z}_{n}/2}}{2^{\tilde{Z}_{n}}}=(\frac{\tilde{Z}_{n}!}{2^{\tilde{Z}_{n}}\times((\frac{\tilde{Z}_{n}}{2})!)^{2}})$. This concludes the proof.

Appendix C: Proof of Proposition 3

If the malicious worker corrupts only one packet out of $Z_{n}$ packets, it is obvious that this attack can be detected by applying $F_{LW}$. Among the remaining attack patterns, *i.e., *all attack patterns, where the malicious worker corrupts more than one packet, the most difficult one to detect is a symmetric pairwise Byzantine attack, where the malicious worker corrupts two packets out of $Z_{n}$ packets. The reason is that the attack is detected by applying function $F_{LW}$ unless the coefficients corresponding to the corrupted packets have a systematic structure, while the coefficients corresponding to the remaining packets can have any value. Therefore, for $F_{LW}$ to fail the attack detection, among all attacks with more than two corrupted packets, the function has the least freedom on selecting the coefficients when the number of corrupted packets is two. This results in the least probability of attack detection when the number of corrupted packets is two. This fact can also be confirmed in Lemma 2, as the detection probability presented in (4) is an increasing function of the number of corrupted packets. On the other hand, among all attack patterns that changes two of the packets, the symmetrical attacks, where one of the packets is corrupted by adding $\delta$ to the result and the other packet is corrupted by subtracting the same amount of $\delta$ from the result is the most difficult one to be detected (In fact, the probability of attack detection for the asymmetrical pairwise attack is $100\%$). Therefore, the most difficult attack pattern for function $F_{LW}$ is symmetrical pairwise Byzantine attack, for which the probability of attack detection is $50\%$. This concludes the proof.

Appendix D: Proof of Lemma 5

In order for an attack not to be detected by applying HW function, the value of the corrupted packets should be changed by the attacker such that $\alpha_{n}$ in (2) is equal to $\beta_{n}$ in (3). For this condition to be satisfied, $\mod(\sum_{i=1}^{Z_{n}}c_{i}\tilde{y}_{n,i},q)$ should be equal to $\mod(\sum_{i=1}^{Z_{n}}c_{i}y_{n,i},q)$. In other words, if the following condition is satisfied, then the attack will not be detected:

[TABLE]

where $\tilde{\mathcal{Z}}_{n}$ with size $|\tilde{\mathcal{Z}}_{n}|=\tilde{Z}_{n}$ is the set of corrupted packets among all $Z_{n}$ received packets, i.e., $(y_{n,i}-\tilde{y}_{n,i})\neq 0,i\in\tilde{\mathcal{Z}}_{n}$. For this condition to be satisfied, one of the coefficients $\{c_{j}|j\in\tilde{\mathcal{Z}}_{n}\}$ out of all $\tilde{Z}_{n}$ coefficients, should be selected depending on the values of the other coefficients, i.e., $c_{j}$ should be selected such that the following condition is satisfied:

[TABLE]

Since $q$ is a prime number, from the modular arithmetic principles, $c_{j}$ has a unique solution. Considering that $c_{j}$ is selected randomly in $\mathbb{F}_{q}$ by the master device, the probability that the selected coefficient $c_{j}$ satisfies the above equation is $1/q$. Therefore, the probability that the attack is not detected by HW function is $1/q$. This concludes the proof.

Appendix E: Proof of Theorem 7

According to Lemma 3, the probability of attack detection when LW function is used for one round is at least $\frac{1}{2}$. When LW function is used for two rounds, *i.e., *no attack is detected by selecting the coefficients $c_{i},1\leq i\leq Z_{n}$ uniformly randomly from $\{-1,1\}$ and thus a different set of coefficients $c_{i}\in\{-1,1\},1\leq i\leq Z_{n}$ are selected uniformly at random, the probability of attack detection is at least $1-\frac{1}{2}\times\frac{2^{Z_{n}-1}-1}{2^{Z_{n}}-1}$. Similarly, the probability of attack detection when LW function is used for $K$ rounds is at least $1-\prod_{k=0}^{K}\frac{2^{Z_{n}-1}-k}{2^{Z_{n}}-k}$, which can be approximated as $\frac{1}{2^{K}}$ when $Z_{n}\gg\log_{2}K$. Therefore, for $K=\log_{2}q$, the probability of attack detection when LW function is used for $\log_{2}q$ rounds is $1-1/q$, which is equal to the attack detection probability of HW function.

According to Theorem 4, the computational complexity for one round of LW function is $O(CM(r)\log_{2}q)$ and thus the computational complexity of $\log_{2}q$ rounds of LW function is $O(CM(r)(\log_{2}q)^{2})$. On the other hand, according to Theorem 6, the computational complexity of HW function is $O(CZ_{n}M(\phi))$. Therefore, if $Z_{n}\geq\frac{M(r)}{M(\psi)}(\log_{2}(q))^{2}$, the computational complexity of $\log_{2}(q)$-round LW function is lower than HW function.

This concludes the proof.

Appendix F: Proof of Theorem 8

In order to characterize the completion time of SC3, we calculate the required time for receiving the required number of packets collectively from all workers at the master device during each time period $T$, defined in Algorithm 1.

According to Algorithm 1, the first time period $T$ is defined as the time interval during which $R+\epsilon$ packets are received collectively from all workers. Using the dynamic packet offloading module of SC3, this time period is equal to $\frac{R+K}{\sum_{n\in\mathcal{N}}1/E[\beta_{n,i}]}$, according to (17) in [1], where $E[\beta_{n,i}]$ is the average of per packet computing time at worker $w_{n},n\in\mathcal{N}$.

According to Algorithm 1, the second time period $T$ is defined as the time interval during which $R+\epsilon-V$ packets are received collectively from all workers, where $V$ is the number of packets labeled as verified after applying the attack detection module on the packets received during the first time interval. In the worst case scenario, $R+\epsilon-V$ additional packets that should be received at the master device and labeled as verified, are delivered only by honest workers. This worst case scenario results in the maximum time for receiving $R+\epsilon-V$ additional packets, which is equal to $\frac{R+\epsilon-V}{\sum_{n\notin\mathcal{N}_{m}}1/E[\beta_{n,i}]}$ [1]. By taking into account this worst case scenario and the upper bound on the average value of $R+\epsilon-V$ (provided in Lemma 10), and adding the time during the first time period, the completion time is upper bounded by $\frac{R+K}{\sum_{n\in\mathcal{N}}1/E[\beta_{n,i}]}+\frac{\sum_{n\in\mathcal{N}_{m}}z_{n}(P+\rho_{c}(1-P))}{\sum_{n\notin\mathcal{N}_{m}}1/E[\beta_{n,i}]}$.

Lemma 10

The average number of packets among all $R+\epsilon$ packets received during the first time period $T$, that are not labeled as verified by SC3, is upper bounded by:

[TABLE]

where $P$ is given by P=1-\Big{(}\frac{(z_{n}\rho_{c})!}{2^{(z_{n}\rho_{c})}\big{(}({z_{n}\rho_{c}}/{2})!\big{)}^{2}}\Big{)}.

Proof: The packets received during the first time period $T$, that are not labeled as verified by SC3, consist of two kinds:

(i) Packets received from malicious workers, where attack is detected by applying the LW function: The average number of these packets is equal to $\sum_{n\in\\ Nset_{m}}z_{n}P$, where $P$ is equal to the probability of attack detection by LW function when applied on $z_{n}$ packets received from worker $w_{n},n\in\mathcal{N}$. From (4), $P$ is given by P=1-\Big{(}\frac{(z_{n}\rho_{c})!}{2^{(z_{n}\rho_{c})}\big{(}({z_{n}\rho_{c}}/{2})!\big{)}^{2}}\Big{)}.

(ii) Corrupted packets received from malicious workers, where attack is not detected by applying the LW function but attack is detected in the attack recovery module. The average number of such packets is upper bounded by $\sum_{n\in\mathcal{N}_{m}}z_{n}\rho_{c}(1-P)$, where $z_{n}\rho_{c}$ is the average number of corrupted packets received from the malicious worker $w_{n}$ and $1-P$ is the probability that the attack is not detected by applying function LW. Note that for larger values of $q$, the probability of attack detection by applying HW function or multiple-round LW function is closer to 1 and the exact value gets closer to its upper bound.

This concludes the proof. $\blacksquare$

Appendix G: Proof of Lemma 9

HW-only uses only the honest workers for computing $R+\epsilon$ packets, *i.e., *all workers that are not in the set $\mathcal{N}_{m}$, and thus its task completion delay is equal to $T_{\text{HW-only}}=\frac{R+\epsilon}{\sum_{n\notin\mathcal{N}_{m}}1/E[\beta_{n,i}]}$ [1], which can be equivalently written as:

[TABLE]

Using the upper bound on $E[T_{\text{SC}^{3}}]$ provided in Theorem 8, $T_{\text{HW-only}}-E[T_{\text{SC}^{3}}]$ can be written as:

[TABLE]

This concludes the proof.