Secure Error Correction using Multi-Party Computation

TL;DR

This paper introduces a secure multi-party computation error correction method that leverages Berlekamp-Welch codes and Reed-Solomon codes to detect and correct errors during data sharing and computation, enhancing privacy and reliability.

Contribution

It proposes a novel error correction technique for secure multi-party computation based on established error-correcting codes, improving robustness against communication errors and malicious manipulations.

Findings

Effective error detection and correction in multi-party computation

Enhanced security against data manipulation and communication errors

Integration of Berlekamp-Welch and Reed-Solomon codes for privacy-preserving error correction

Abstract

During recent years with the increase of data and data analysis needs, privacy preserving data analysis methods have become of great importance. Researchers have proposed different methods for this purpose. Secure multi-party computation is one of such techniques that allows a group of parties to evaluate a function on their data without revealing the data. This is done by secret sharing approach, in which parties share a piece of their data using polynomials and after doing function evaluation on shares of data finally they do a Lagrange interpolation to get the result. Two approaches have been proposed in secure multi-party computation for evaluating a function, arithmetic gates and logical gates. In both of them and since communication is an important step in multi-party computation, errors may happen. So, being able to detect and correct errors is important. Moreover, as adversaries may interrupt communication or manipulate the data, either in communication or during computation, this error detection and correction provide participating parties with a technique to detect such errors. Hence, in this paper we present a secure multi-party computation error correcting technique that has the ability to detect and correct errors on players shares. This technique is based on Berlekamp-Welch error correcting codes and we assume that players shares are generated using Reed-Solomon codes.

Equations

$$P(x)=m_0+m_{1}x+m_2{x}^2+...+m_{k-1}{x}^{k-1}$$

$$c=[c_0,c_1,c_2,..{.}_{,}{c}_{n-1}]=[P(1),P(2),P(3),...,P(n)]$$

$$degree(E(x))\le e$$

$$degree(Q(x))\le m+e-1$$

$$Q(i)=r_{i}E(i)\forall i=1,2,...,n.$$

$$a_0+a_{1}x+a_2{x}^2+...+a_{n-3}{x}^{n-3}+a_{n-2}{x}^{n-2}={\alpha }_i(x+b_0)$$

$$\left\{\begin{array}[]{c}a_{0}+a_{1}x+a_{2}x^{2}+...+a_{n-3}x^{n-3}+a_{n-2}x^{n-2}=\alpha_{1}(x+b_{0})\\ a_{0}+a_{1}x+a_{2}x^{2}+...+a_{n-3}x^{n-3}+a_{n-2}x^{n-2}=\alpha_{2}(x+b_{0})\\ ...\\ a_{0}+a_{1}x+a_{2}x^{2}+...+a_{n-3}x^{n-3}+a_{n-2}x^{n-2}=\alpha_{n}(x+b_{0})\\ \end{array}\right.$$

$$\left\{\begin{array}[]{c}a_{0}+a_{1}+a_{2}+...+a_{n-3}+a_{n-2}=\alpha_{1}(1+b_{0})\\ a_{0}+2a_{1}+4a_{2}+...+2^{n-3}a_{n-3}+2^{n-2}a_{n-2}=\alpha_{2}(2+b_{0})\\ ...\\ a_{0}+na_{1}+n^{2}a_{2}+...+n^{n-3}a_{n-3}+n^{n-2}a_{n-2}=\alpha_{n}(n+b_{0})\\ \end{array}\right.$$

$$\left[\begin{array}{cccccc}1& 1& 1& \dots & 1^{n-2}& -{\alpha }_1\\ 1& 2& 4& \dots & 2^{n-2}& -{\alpha }_2\\ 1& 3& 9& \dots & 3^{n-2}& -{\alpha }_3\\ ⋮& ⋮& ⋮& \ddots & ⋮& ⋮\\ 1& n-1& {(n-1)}^2& \dots & (n-1{)}^{n-2}& -{\alpha }_{n-1}\\ 1& n& n^2& \dots & n^{n-2}& -{\alpha }_n\end{array}\right]\left[\begin{array}{c}{a}_0\\ a_1\\ a_2\\ ⋮\\ a_{n-2}\\ b_0\end{array}\right]=\left[\begin{array}{c}{\alpha }_1\\ 2{\alpha }_2\\ 3{\alpha }_3\\ ⋮\\ (n-1){\alpha }_{n-1}\\ n{\alpha }_n\end{array}\right]$$

$$b_0=\frac{det(A_1)}{det(A_2)}$$

$$A_1=\left[\begin{array}{cccccc}1& 1& 1& \dots & 1^{n-2}& {\alpha }_1\\ 1& 2& 4& \dots & 2^{n-2}& 2{\alpha }_2\\ 1& 3& 9& \dots & 3^{n-2}& 3{\alpha }_3\\ ⋮& ⋮& ⋮& \ddots & ⋮& ⋮\\ 1& n-1& {(n-1)}^2& \dots & (n-1{)}^{n-2}& (n-1){\alpha }_{n-1}\\ 1& n& n^2& \dots & n^{n-2}& n{\alpha }_n\end{array}\right]$$

$$A_2=\left[\begin{array}{cccccc}1& 1& 1& \dots & 1^{n-2}& -{\alpha }_1\\ 1& 2& 4& \dots & 2^{n-2}& -{\alpha }_2\\ 1& 3& 9& \dots & 3^{n-2}& -{\alpha }_3\\ ⋮& ⋮& ⋮& \ddots & ⋮& ⋮\\ 1& n-1& {(n-1)}^2& \dots & (n-1{)}^{n-2}& -{\alpha }_{n-1}\\ 1& n& n^2& \dots & n^{n-2}& -{\alpha }_n\end{array}\right]$$

$$d_1=det(A_1)=\sum _{i=1}^n(-1{)}^{i+n}(-{\alpha }_i)det(A_1^{i,n})$$

$$d_2=det(A_2)=\sum _{i=1}^n(-1{)}^{i+n}({\alpha }_i)det(A_2^{i,n})$$

$$Q(i)={\alpha }_{i}E(i)$$

$$A=\left[\begin{array}{cccccc}1& 1& 1& \dots & 1^{n-2}& \ast \\ 1& 2& 4& \dots & 2^{n-2}& \ast \\ 1& 3& 9& \dots & 3^{n-2}& \ast \\ ⋮& ⋮& ⋮& \ddots & ⋮& ⋮\\ 1& n-1& {(n-1)}^2& \dots & (n-1{)}^{n-2}& \ast \\ 1& n& n^2& \dots & n^{n-2}& \ast \end{array}\right]$$

$${\gamma }_i=\prod _{1\le j\le t,i\ne j}(\frac{k-j}{i-j})$$

$${\alpha }_i\times {\gamma }_i={\delta }_{1i}+{\delta }_{2i}+\dots {\delta }_{ti}.$$

$${\sigma }_j=\sum _{i=1}^t{\delta }_{ji}.$$

$${\alpha }_k^{corrected}=\sum _{j=1}^t{\sigma }_j.$$

$$a_{0}+a_{1}x+a_{2}x^{2}={\color[rgb]{1,0,0}\alpha_{i}}(x+b_{0})$$

$$\left\{\begin{array}[]{c}a_{0}+a_{1}+a_{2}={\color[rgb]{1,0,0}2}(1+b_{0})\\ a_{0}+2a_{1}+4a_{2}={\color[rgb]{1,0,0}0}(2+b_{0})\\ a_{0}+3a_{1}+2a_{2}={\color[rgb]{1,0,0}4}(3+b_{0})\\ a_{0}+4a_{1}+2a_{2}={\color[rgb]{1,0,0}3}(4+b_{0})\\ \end{array}\right.$$

$$\left\{\begin{array}[]{c}a_{0}+a_{1}+a_{2}+{\color[rgb]{1,0,0}5}e_{0}=2\\ a_{0}+2a_{1}+4a_{2}+{\color[rgb]{1,0,0}0}e_{0}=0\\ a_{0}+3a_{1}+2a_{2}+{\color[rgb]{1,0,0}3}e_{0}=5\\ a_{0}+4a_{1}+2a_{2}+{\color[rgb]{1,0,0}4}e_{0}=5\\ \end{array}\right.$$

$$b_0=\frac{det(A_1)}{det(A_2)}$$

$$A_{1}=\begin{bmatrix}1&1&1&{\color[rgb]{1,0,0}2}\\ 1&2&4&{\color[rgb]{1,0,0}0}\\ 1&3&2&{\color[rgb]{1,0,0}5}\\ 1&4&2&{\color[rgb]{1,0,0}5}\\ \end{bmatrix}$$

$$A_{2}=\begin{bmatrix}1&1&1&{\color[rgb]{1,0,0}5}\\ 1&2&4&{\color[rgb]{1,0,0}0}\\ 1&3&2&{\color[rgb]{1,0,0}3}\\ 1&4&2&{\color[rgb]{1,0,0}4}\\ \end{bmatrix}$$

Full text

1 Introduction

During recent years, the increase of data on one hand and the importance of privacy of them on the other hand, encouraged researchers to work on techniques that allow data holders to do data analysis techniques without revealing private data. One of such techniques is secure multi-party computation. Secure multi-party computation is a kind of distributed computation that allow a set of parties to compute a function on their private data, without revealing them. The idea was first introduced by Yao, in his Millionarie’s problem [1]. The problem says two millionaries want to know who is richer, but they do not want to reveal their wealth. After Yao’s seminal paper, many researches have been done in this direction and his idea was generalized to a general purpose form. Specifically, researchers focused on how they can evaluate a function on n piece of data, holding by n parties, without revealing the data. It has been shown that any function can be computed in on such data without revealing them. Two general approaches have been proposed, using binary circuits or using arithmetic circuits. In the first case, n parties share their data among themselves, using for example Shamir’s secret sharing [2] and then the parties do function calculation using binary circuits on the shared data. In this approach, parties do bit-wise calculation using for example Oblivious Transfer. As communication is an inseparable part of multi-party computation, because parties are constantly send and receive data, this approach is not efficient from communication complexity point of view. In the arithmetic circuit scenario, the parties use secret sharing to share their data and do function evaluation on them. As this idea is based on polynomials and finite field calculation, it is more efficient.

In both scenarios all parties need to communicate and share their data. On the other hand adversaries may interrupt data communication, or create noise while players are doing local calculation on their data. As such, if they have the ability to use an error detection and correction technique, they can increase the reliability of the protocol they use for multi-party computation. In this paper we propose a secure error correction technique that can be added to a secure multi-party computation for detecting errors created by adversaries or communication channels. The idea is based on Berlekamp-Welch algorithm and we assume parties have created their shares based on Reed-Solomon codes. The reason that we use these two specific techniques is that, as secret sharing, they are based on polynomials over finite fields which are efficient for implementation.

The paper organization is as follows. First we presents the preliminaries of our work, including multi-party computation, Reed-Solomon codes and their decoding using Berlekamp-Welch algorithm. Then the previous works will be reviewed. After that the main part of this paper will be presented.

2 Preliminaries

In this section we present the preliminaries our our work. These include multi-party comutation, Reed-Solomon codes (we call them RS codes for simplicity), Berlekamp-Welch decoding algorithm (we call it BW algorithm for simplicity) for RS codes.

2.1 Secure Multi Party Computation

Secure multi-party computation which its first idea was introduced by Yao [1] is defined as follows. $n$ parties each have a private value, want to evaluate a public function on their private data in such a way that they don’t reveal any information about their data but they all can get the output of the public function. One simple example is that $n$ parties have $n$ integer values and they want to find the maximum of them without revealing them.

Many researches have been done in this area [4], [5], [8], [7], [6]. In secure multi-party computation two approaches can be used. One approach is doing computation based on bits of shared values and the other approach is doing computation based on shared values of secrets in a finite field $Z_{p}$, for a prime integer p, [4]. In both cases the shares of secret values are being distributed using a secret sharing scheme, such as Shamir secret sharing [2]. However, both approaches have their own pros and cons, for example, doing addition and multiplication is efficient in finite field arithmetic, but using boolean circuits it is not efficient. Unfortunately, doing calculations such as secret comparisons is not efficient and trivial in arithmetic circuits, whereas it is trivial in boolean circuit calculations [4]. However, for large integers this task is not efficient using boolean circuits.

To overcome the inefficiency of these two scenarios and having an efficient in [5] authors presented a protocol, called bit-decomposition, that allows parties to convert sharing of finite field elements to sharing of bits. In [4] authors improved the bit-decomposition protocol by reducing its communication complexity. Another work in this area has been presented in [9] which is based on threshold homomorphic systems.

2.2 Reed-Solomon Codes

Reed-Solomon codes was introduced in 1960 in [10]. These linear error-correcting codes are based on polynomials over finite fields and have many applications. In the following we assume all calculation are done in the finite field $Z_{p}$ for a given prime number $p$. RS codes encode a message of length $k$ into a codeword of length $n$, $k\leq n\leq p$. Mathematically, given a message $m=[m_{0},m_{1},m_{2},..._{,}m_{k-1}]$, the polynomial $P$ is defined as following:

[TABLE]

In which coefficients are in $Z_{p}$. To encode the message $m$, the polynomial will be evaluated on $n$ different points, say $1,2,...,n$, so the encoded message, denoted by $c$ would be:

[TABLE]

For the Reed-Solomon codes we have the following theorems:

Theorem 2.1

The weight of Reed-Solomon codes of length $n$ with a message of length $k$, $RS(n,k)$, is $n-k+1$.

Theorem 2.2

An $RS(n,k)$ with $n=k+2e$ can correct $e$ errors.

A decoding algorithm was developed by Berlekamp and Welch in [11], which we will discuss it in the next section.

2.3 Berlekamp-Welch Decoding Algorithm

Berlekamp-Welch algorithm is a decoding algorithm for RS codes [11]. As we discussed in the previous section, an $RS(n,k)$ code encodes a message with length $k$ to a codeword of length $n$. Now, assume that $e$ errors has happened in the codeword $c=[c_{0},c_{1},c_{2},..._{,}c_{n-1}]=[P(1),P(2),P(3),...,P(n)]$ and the codeword with error is $r=[r_{0},r_{1},r_{2},..._{,}r_{n-1}]$. That is, $r_{i}\neq P(i)$ for at most $e$ cases.

Theorem 2.3

Given a received codeword, generated by RS(n, k) codes, with $e$ errors, then there exists non-zero polynomials $E(x)$ and $Q(x)$ for which we have [12]:

[TABLE]

[TABLE]

[TABLE]

Moreover, $\frac{Q(x)}{E(x)}$ will give the polynomial that has generated the codeword, $P(x)$.

Equation 5 is called key equation and solving it gives us the location of the errors in the received codeword, which is guaranteed by theorem 2.3.

For $i=1,2,...,n$, key equation, equation 5, will produce a linear system of equations, which we can solve it by different methods in linear algebra, such as Gaussian elimination or Cramer’s rule. By finding the solution of key equation, we can find errors location and the polynomial $P$ which gives the corrected message.

3 Secure Error Detection and Correction using MPC

We assume that $n$ parties have $n$ shares and they want to be able to check if any errors has happened in their data, because in multy-party computation parties constantly exchange their data. We also assume that all the following calculations are done in finite field $Z_{p}$ where $p$ is a prime number.

In order to be able to detect and correct $e$ errors, we need to have at least $3e+1$ shares, in other words $3e+1$ parties need to participate, because according to theorem 2.2, $n\geq k+2e$, which $k$ is the message length. Also, we assume that the number of errors at most can be one less than the message length. In other words, all the message has not been altered. In the following we will address the problem of error detection and then provide a technique that allows the parties to recover the incorrect share.

Locating one error at the time: Each player creates an equation using his secret value (which is denoted by $\alpha_{i}$ for player $i$).

[TABLE]

So we have $n$ equations, each at hand of one party, by which we can define the following system linear equation (consisting of $n$ equations and $n$ unknowns including $a_{0},a_{1},a_{2},...,a_{n-2},b_{0}$).

[TABLE]

$a_{0},a_{1},a_{2},...,a_{n-2}$ will be used for the error correction polynomial $Q$ in BW algorithm and $b_{0}$ is error locator as the $E$ polynomial in BW algorithm. Also we assume that all of calculations are done in $Z_{p}$ for a public pre-defined prime number $p$. Now, players evaluate equations with $x=1,2,3,...,n$, like BW algorithm. So, they have:

[TABLE]

To make it simple, we use matrix notation to show this linear system of equations:

[TABLE]

The first $n-2$ columns of the first matrix are public values, which are the same as the columns of the Vandermone matrix. If we use Cramer’s rule for solving this system of equations (just for $b_{0}$, which determines the location of the error), we would have:

[TABLE]

where

[TABLE]

and

[TABLE]

if we expand the determinant based on the last column, we will have:

[TABLE]

and

[TABLE]

where $A^{i,n}$ is the $(n-1)\times(n-1)$ matrix that is created by eliminating the $i$-th row and $n$-th column of A. As we see in the above equation just $\alpha_{i}$’s are secret and the second term in the summation is a public value. So, to calculate $d_{1}$ and $d_{2}$, players just need to locally multiply their secret value by a public term and send a shares of the result to other players and finally do a Lagrange interpolation to find the location of the error. The error detection algorithm is as following, see algorithm 1.

Correcting one error at a time: For the error correction we will use the idea in [13]. In this paper authors proposed a new approach, based on Lagrange interpolation, for recovering incorrect shares. After the location of error has been determined, solving the system of equations for $b_{0}$, the other parties who have correct shares, help the party with incorrect share to correct his share. The whole idea is that each player calculates his Lagrange interpolation constant and multiplies it by his share and send the shares of the result value to all players. After all players do so, they will have portions of a share of the original data, by which the player with incorrect share can correct his share. The error correction protocol 2 shows the step by step process for helping a player to correct his share.

4 Technical Discussion

In this section we will discuss the security analysis as well as computational and communication complexity of the error detection and correction protocols.

4.1 Security Analysis of Error Dectection Protocol

Similar to $(t,n)$-threshold secret sharing, in which a group of $t$ players need to cooperate in order to get the secret value, here in this secure error correction protocol $t$ players need to come together to detect and correct an error. To do so, they create a asystem of linear equations and when they represent it in the matrix format, $Ax=b$, one column of the $A$ matrix and the $b$ vector consist of secret values of players. As they calculate the determinant of the matrix using Gaussian expansion based on the column containing the secret values, the new sub-matrices are all containing public values, which their determinant will be calculated and distributed among all players by a volunteer player. Then each player needs to caclulate a multiplication by a public value localy which can be calculated easily by each player without revealing any information, , see equations 13 and 14 and the toy example in appendix A.

4.2 Round Complexity Discussion

Communication or round complexity, which can very large in some MPC protocol, for our secure error correction protocol is very small. For error detection players calculate two determinants ($d_{1}$ according to the equation 13 and $d_{2}$ according to the equation 14) in which they only do multiplication by some public values, which can be easily done and does not need any multiplication in MPC which requrires sharing and resharing. After that they do a Lagrange interpolation collaboratively.

For error correction, one round of communication is needed in step 2 and one round in step 3, in totall two round of communication.

4.3 Computational Complexity Discussion

The computational complexity of error correction algorithm is $O(n^{3})$ where $n$ is the number of players. Because a volunteer player calculates the determinant of $(n-1)$ by $(n-1)$ matrices which can be done in $O(n^{3})$, or by using more efficient algorithms in a lower time complexity. The Lagrange interpolation can be done in $O(n^{2})$.

5 Conclusion

In this paper we introduced the idea of secure error correction that allows a group of parties to detect and correct their shares in a privacy-preserving manner. The idea is based on Reed-Solomon codes and Berlekamp-Welch decoding algorithm. In fact we used Berlekamp-Welch algorithm for finding the location of the errors and for error correction we used the assumption of Shamir’s $(t,n)$-threshold Secret Sharing, that a group of $t$ parties have enough data to recover the secret or equivalently create the share of a specific party. The protocol works as follows.

At any point in an MPC protocol, players can collaboratively form the system of equations in BW algorithm and then solve it. Note that each equation is at the hand of one player. Then they expand the determinant of the matrix of their system of equations using the Laplace expansion and they calculate and announce the determinant of the sub-matrices if there is no secret value in any column. After doing calculation and finding the location of the error, which is the ID of a player, any subset of $t$ of players with correct share can help the player with incorrect share to recover his correct share ($t$ is threshold in the Shamir’s (t, n)-threshold secret sharing).

Appendix: A Toy Example

A toy example: Assume that the prime $p=7$ and players ID are 1, 2, 3, 4. Also the private values of four parties are 2, 0, 5, 3 and the third value has changed to 4 because of an error. So, the codeword is $[c_{0},c_{1},c_{2},c_{3}]=[2,0,5,3]$ and the received vector, as described in BW algorithm, is $[r_{0},r_{1},r_{2},r_{3}]=[\alpha_{0},\alpha_{1},\alpha_{2},\alpha_{3}]=[2,0,4,3]$. The key equation of BW algorithm would be

[TABLE]

Evaluating it for $x=1,2,3,4$ (here each $x$ is the ID of a player and each equation is at the hand of one player):

[TABLE]

In fact each player create his equation using his ID which is a public value. This system of equations can be written as, after doing all calculation in $Z_{7}$:

[TABLE]

To find the erroneous private value (or its location) we need to find $e_{0}$ as following, which was explained in section 3.

[TABLE]

where

[TABLE]

and

[TABLE]

After doing the calculation we will have $b_{0}=4$, which means the location of the error is 3. Because error locator polynomial would be $x+b_{0}=x+4$ and its root shows the location of the error, and its root in $Z_{7}$ is $3$. Notice that the last column of $A_{1}$ and $A_{2}$ are consisted of a multiplicative factor of parties private value, so the determinant calculation should be expanded based on that column and after the expansion players can use any method to calculate the determinant of the resulting $3\times 3$ matrix.