A New Distribution Version of Boneh-Goh-Nissim Cryptosystem: Security and performance analysis

TL;DR

This paper introduces two distributed variants of the Boneh-Goh-Nissim cryptosystem, proving their security and efficiency, with one version outperforming ElGamal on elliptic curves under certain assumptions.

Contribution

It presents two new distributed versions of BGNC, with security proofs and efficiency comparisons to existing cryptosystems, enhancing practical cryptographic applications.

Findings

First version is semantically secure against active non-adaptive adversaries.

Second version is more efficient than EDECC and secure under SDP assumption.

Provides formal security proofs for both variants.

Abstract

The aim of this paper is to provide two distributed versions of the Boneh-Goh-Nissim Cryptosystem (BGNC). We give a proof of the semantic security for the first one. This guaranties that our algorithm is semantically secure in the contest of active non-adaptive adversaries. Furthermore, we prove that the second version of our distributed scheme is computationally more efficient than the ElGamal destributed elliptic curve cryptosystem (EDECC) and secure under the Subgroup Decision problem (SDP) assumption.

Equations

$$C=m\times g+r\times h.$$

$$m=lo{g}_{q_{1}g}{q}_{1}C.$$

$$m{q}_{1}g=q_{1}C$$

$$q_{1}C$$

$$=q_1\times m\times g+q_1\times r\times h$$

$$=q_{1}mg+q_{1}r(u{q}_2)\text{ (recall that h=uq2)}$$

$$=m{q}_{1}g+ru(q_1{q}_2)$$

$$=m{q}_{1}g+run\text{ (since n=q1q2)}$$

$$=m{q}_{1}g.\text{ (since n is the order of the group G and u}$$

$$d_i=q_1{\alpha }_i+{\beta }_i,{\beta }_i<q_1,$$

$${\gamma }_i=q_1{\alpha }_i,$$

$$c_i=lo{g}_{q_{1}g}{\gamma }_{i}C,$$

$$m=lo{g}_{B}A,$$

$${\mu }_{i,j}^S=D\times \frac{{\prod }_{j^{\prime }\in S\backslash j}(i-j^{\prime })}{{\prod }_{j^{\prime }\in S\backslash j}(j-j^{\prime })}\in \mathbb{Z},$$

$$Df(i)=\sum _{j\in S}{\mu }_{i,j}^{S}f(j)\mathrm{mod}n,$$

$$Df(0)=\sum _{j\in S}{\mu }_{0,j}^{S}f(j)\mathrm{mod}n.$$

$$D{d}_0=\sum _{j\in S}{\mu }_{0,j}^S{d}_j.$$

$$c_i=lo{g}_{q_{1}g}{\gamma }_{i}C$$

$$\iff c_i{g}_0={\gamma }_{i}C\text{ since g0=q1g}$$

$$\iff c_i{g}_0=(d_i-{\beta }_i)C\text{ since γi=di−βi}$$

$$\iff c_i{g}_0=d_{i}C-{\beta }_{i}C.$$

$$c_i=lo{g}_{q_{1}g}{\gamma }_{i}C\iff c_i{g}_0+{\beta }_{i}C=d_{i}C,$$

$$m=lo{g}_{d_{0}g}{d}_{0}C\iff m{d}_{0}g=d_{0}C.$$

$$mD{d}_{0}g=d_{0}DC,$$

$$m{\Sigma }_{j\in S}{\mu }_{0,j}^S{d}_{j}g={\Sigma }_{j\in S}{\mu }_{0,j}^S{d}_{j}C$$

$$\iff m{\Sigma }_{j\in S}{\mu }_{0,j}^S{g}_j={\Sigma }_{j\in S}{\mu }_{0,j}^S(c_i{g}_0+{\beta }_{i}C),$$

$$mB=A.$$

$$H=(901696848398424513792042624183449898:919534227604146025519668445930592752:1)$$

$$D=(515582362393135083339332053520498553:934365455532976888281795609449803454:1)$$

$$G=(744114534472669657966133843400531746:77435475791434420844416408483805765:1)$$

$$c_i=lo{g}_{a}b,$$

$$(c,c_1,\dots ,c_l,proo{f}_1,\dots ,proo{f}_l).$$

$$C_i=M_i\times g+r\times h.$$

$$M_i=lo{g}_{q_{1}g}{q}_1{C}_i.$$

Full text

††journal: Journal of LaTeX Templates

1 Introduction

Public key cryptosystems are widely used nowadays in electronic banking, online browsing, voting systems and so on. While symmetric systems are more efficient than the asymmetric ones, those later are suitable for key handling in an intrusted setup. A well known drawback in public key cryptography, is that the knowledge of the secret keys (like a server) provide full control, and may be viewed as a weakness. Hence a new direction in research named distributed systems. Instead of relying on a single trusted party, the key is distributed among $n$ parties and at least $m$ parties must collaborate in order to recover the secrete key. $m$ is chosen as a parameter of the system, at the setup level.

The definition of semantic security of threshold cryptosystem used in this paper follows the one stated in [1].

The decryption operation of the BGNC used in this paper is done by computing the discrete logarithm on elliptic curve. We use Pollard Lambda algorithm (reference) which has complexity $O(\sqrt{T})$ in time of computation, where $T$ is the length of the interval to which the message $m$ belongs.

Our second distributed scheme is more efficient than the El Gamal distributed (EECC) in terms of computation efficiency. We evaluate the computational time of our algorithm and compare it to EECC [2]. In our paper, we focus on encryption and decryption times.

The security of the Paillier, ElGamal ECC (EECC) and BGNC cryptosystems rely on the Decisional Composite Residuosity assumption (DCRA) [3], the Elliptic Curve Discrete Logarithm Problem (ECDLP) [4] and the Subgroub Decision Problem (SDP) assumptions [5], respectively. So, by building on the ECDLP and the SDP assumptions, we prove that our distributed scheme is semantically secure, in the meaning introduced in [1]. For the best of our knowledge, this has never been done.

1.1 Related work

Several elliptic curve distributed systems have been proposed in the literature [1], [6], [7], [8], [9]. Our paper aims to introduce two novel distributed schemes for the BGNC introduced in [5] following the paradigm of [1]. Fouque et al. [1] proposed a first distribution of the Paillier system together with a proof of semantic security. In [6], Fournaris proposed a distributed version of ECC. However, no proof of security was given.

1.2 Organization

This paper is organized as follows. In Section 2, we recall the basic definitions and the scenario when dealing with threshold cryptography. We present our novel threshold scheme together with a proof of security of this later in Section 3. A numerical example with Sage software is given in Section 4. The other distribution version together with its complexity analysis are given in Section 5. We conclude our work in Section 6.

2 Preliminaries

2.1 Zero Knowledge (ZK) Proof of Equality

In this section we will recall the ZK proof of equality algorithm given in [9] to produce proofs of validity in step 3 of our threshold ECC, see Section 3.

Suppose that party B needs to prove that it has a valid secret share key $s$ to party A without divulging any information about $s$.

A selects two random integers $a$ and $b$ smaller than the order of the cyclic group generated by a point of an elliptic curve. 2. 2.

It computes $(a_{1},a_{2})=asg\mod p$ and $(b_{1},b_{2})=bg\mod p$, where $p$ is a prime number related to the finite field $GF(p)$ on which the elliptic curve $E$ is constructed and $g$ is a generator of the group $G$ of the points on $E$. 3. 3.

It also computes $t_{1}=a_{1}b_{1}\mod p$ and $t_{2}=a_{2}b_{2}\mod p$ and sends $(ag,t_{1},t_{2})$ to party B. 4. 4.

B computes $sag=(r_{1},r_{2})\mod p$. 5. 5.

B computes $z_{1}=t_{1}r_{1}^{-1}\mod p$ and $z_{2}=t_{2}r_{2}^{-1}\mod p$ and sends $(z_{1},z_{2})$ to A.

At the end, A verifies that $(b_{1},b_{2})=(z_{1},z_{2})$. If this is true, B has the secret $s$. Otherwise, the proof $proof=(z_{1},z_{2})$ is not valid.

The correctness of this scheme can be verified from the Menezes–Vanstone elliptic curve cryptosystem [9].

2.2 Threshold Cryptosystems

We rewrite in this section the definition of a threshold cryptosystem (TC) introduced in [1]. The system is defined by the following four algorithms:

A key generation algorithm

Inputs:

1. (a)

$k$: a security parameter which controls the level of security, 2. (b)

$l$: the number of parties participating in threshold cryptosystem, 3. (c)

$t$: is a parameter defining the number of participants required in order to recover the cleartext.

Outputs:

1. (a)

$PK$: is a public key for encryption, 2. (b)

$PK_{1},\ldots,PK_{l}$ are the private keys of the participants in the scheme, 3. (c)

$VK,VK_{1},\ldots,VK_{l}$ are verification keys.

• 2.

An encryption algorithm

Inputs:

1. (a)

$PK$, 2. (b)

$M$: the message,

Outputs:

1. (a)

$c$: the ciphertext,

• 3.

A share decryption algorithm

Inputs:

1. (a)

$PK$, 2. (b)

$1\leq i\leq l$: an index, 3. (c)

$SK_{i}$, 4. (d)

$c$.

Outputs:

1. (a)

$c_{i}$: the decryption share, 2. (b)

$proof_{i}$: a proof of validity.

• 4.

A combining algorithm

Inputs:

1. (a)

$PK$, 2. (b)

$c$, 3. (c)

$c_{1},\ldots,c_{l}$, 4. (d)

$VK,VK_{1},\ldots,VK_{l}$, 5. (e)

$proof_{1},\ldots,proof_{l}$.

Outputs:

1. (a)

$M$.

2.3 Description of the TC

The authors in [1] introduced the following parties: a dealer, a combiner, a set of $l$ servers $P_{i}$, an adversary and users. Each of the parties uses the algorithms described in the previous section in the following manner:

The dealer runs the key generation algorithm,

• 2.

Each server has its share $SK_{i}$,

• 3.

The user runs the encryption algorithm,

• 4.

The servers use the decryption algorithm,

• 5.

The combiner recovers the message using the combining algorithm.

2.4 Security Definitions

We recall, in this section, the definition of security [1] used in the proof of our main theorem.

An active non-adaptive adversary corrupts the servers of his choice before the key generation step.

A t-robust cryptosystem recovers the plaintext even if an adversary controls up to $t$ servers.

**Perfect secrecy **is related to the inability of an adversary to learn nothing from the ciphertext. Formally $Pr[M=m|C=c]=Pr[M=m]$, wherein $M$ and $C$ are random variables over the plaintext and the ciphertext, respectively. The above definition is shown to be equivalent to the notion of adversarial indistinguishability [12], wherein an adversary is asked to guess which plaintext, among the two ones, has been encrypted from a ciphertext. We write $Exp=1$ if the adversary succeed in the experiment. The definition of perfect secrecy is equivalent to $Pr[Exp=1]=\dfrac{1}{2}$ for any adversary.

Semantic security. The authors in [1] generalize the above definition to the setup of a distributed system. The adversary is supposed to control $t$ servers. We run the same experiment as in the above definition, asking the adversary to guess which message, $m_{1}$ or $m_{2}$, has been encrypted from a ciphertext $c$. If he succeed then we write $Exp=1$ and the system is semantically secure if $Pr[Exp=1]=\dfrac{1}{2}$, for any adversary $\mathcal{A}$.

3 The Boneh-Goh-Nissim Cryptosystem

We recall that, the BGNC presented in this section, is semantically secure under the SDP assumption [5].

3.1 Description

Key Generation: The public key is $(n,G,g,h)$, where $G$ is a group of order $n$, $n=q_{1}q_{2}$, $g$ and $u$ are generators of $G$ and $h=u.q_{2}$. The private key is $q_{1}$.

Encryption: Pick a random $r\in[0,n-1]$. Let $m\in[0,\ldots,T]$ be a message to encrypt. So, the ciphertext is computed as

[TABLE]

Decryption: Compute

[TABLE]

3.2 Correctness

The equation 2 can be written in the following form:

[TABLE]

We have to prove that the above equation is equivalent to equation 1. Multiply the two sides of equation 1 by $q_{1}$, we get:

[TABLE]

3.3 Distributed Version of BGNC

Key Generation: The dealer chooses an elliptic curve E such that the order of the group of the point of this curve is $p+1=n\times s$ and such that $n=q_{1}q_{2}$, $q_{1}$ and $q_{2}$ are two sufficiently large prime numbers. So, there exist a subgroup $G$ of order $n$. Let $g$ and $u$ be two generators of $G$, set $h=q_{2}u$ and $g_{0}=q_{1}g$. The public key $PK$ will be $PK=(n,G,g,h,g_{0})$ and the secret key $SK=q_{1}$. It is shared using Shamir’s secret sharing scheme: let $f_{0}=SK$ and, for $i=1,\ldots,t$, $f_{i}$ is randomly chosen in $\mathbb{Z}_{n}$.

Let $f(X)=\sum_{i=0}^{t}f_{i}X^{i}$; the secret key $SK_{i}$ is $d_{i}=f(i)\mod n$.

The $d_{i}$’s must be different from $q_{1}$ and $q_{2}$ so that the decryption shares $c_{i}$ may exist. We have to ensure that $c_{i}\in[0,T]$ for a suitable chosen $T$.

Encryption: Compute $C=m\times g+r\times h$ as in the BGNC.

Share Decryption Algorithm :

Let

[TABLE]

$\beta_{i}$ here is the remaining of the division of $d_{i}$ by $q_{1}$. $\alpha_{i}$ is the quotient. Define

[TABLE]

Compute

[TABLE]

for $i=1,\ldots,l$. The share of each server will be the couple $(c_{i},g_{i})$. To convince anyone that the server $i$ has a valid share $d_{i}$, it uses zero knowledge proof presented in section 2.1, resulting in a proof of validity.

Combining Algorithm: Let $S$ be a set of valid decryption shares

$c_{i},i=1,\dots,t+1$. Compute

[TABLE]

where $B=\Sigma_{j\in S}\mu_{0,j}^{S}g_{j}$ and $A=\Sigma_{j\in S}\mu_{0,j}^{S}(c_{i}g_{0}+\beta_{i}C).$ The coefficients $\mu_{i,j}^{S}$ are the Lagrange coefficients defined by

[TABLE]

for any $i\in\{0,\ldots,l\}$ and any $j\in S$.

We will use this Lagrange interpolation formula:

[TABLE]

for any $i\in\{0,\ldots,l\}$ and any $j\in S$.

So, for $i=0$:

[TABLE]

Thus

[TABLE]

We have that

[TABLE]

Finally

[TABLE]

and

[TABLE]

Multiplying the above formula by $D$, we obtain:

[TABLE]

so by formula 11

[TABLE]

and by formula 12

[TABLE]

or

[TABLE]

So, the proposed scheme is correct.

4 Numerical Example

We have used Sage software to make a numerical example.

Let $p=100000000000000003$ and $q=100000000000000013$. With those parameters we obtain an elliptic curve of order: $96000000000000001536000000000\\ 00003744.$ We choose for illustration purpose, $l=20$ and $t=8$. We have computed two points of order $n=pq$ :

[TABLE]

and

[TABLE]

A generator of the curve is :

[TABLE]

We chose to encrypt a message $m=10$. We obtain the shares: [320, 15530, 213640, 1457210, 6593360, 22845370, 65658680, 164354090]. We apply the formula stated in the algorithm, we recover the clear message $m=10$.

4.1 Details on Sage Commands Used for the Above Example

To obtain the two prime numbers and the suitable order for the field we use the following code :

p = next_prime(100000000000000000);

this will generate

a prime greater then 100000000000000000. q = next_prime(p);# a prime number greater than p. n = p * q; l = 1; pp = ln-1; while (not(is_prime(pp)) or mod(pp,3)==1): l = l+1; pp = ln-1;

After running this code, we obtain a prime number $pp$ with $pp+1=l*n$ and this will ensure that the following command:

E = EllipticCurve(GF(pp),[0,1]);

will generate an elliptic curve of order $pp$ as required in our key generation step. When looking for a generator of the curve, we use

E.gens();

To obtain a point of order $n$, we generate a random point and test if its order is as desired:

o = 1; while (o <> n): H = E.random_point(); o = H.order();

The discrete logarithm, in sage when the range of the logarithm, is known and achieved in Sage with the command:

discrete_log_lambda(P,Q,[0,T],operation=’+’);

here $Q$ is the base, $T$ is the range and the operation is relative to the group on which we are working on.

Theorem 1**.**

Under the SDP and the ECDLP assumptions, the distributed version of BGNC (DBGNC) is semantically secure against active non-adaptive adversaries.

Proof.

We prove using the reduction process. We show that if an adversary can break the semantic security of the DBGNC, then we can construct an attacker who can break the semantic security of BGNC. Following this procedure, we have to simulate data received by the adversary in steps A2, A3 and A5 of the game A. So, the proof consists of proving that the data simulated during the steps of the game A are indistinguishable from real ones.

Let us assume the existence of an adversary $\mathcal{A}$ able to break the semantic security of the threshold scheme. We now describe an attacker which uses $\mathcal{A}$ in order to break the semantic security of BGNC. In a first phase, the attacker obtains the public key $(n,G,g,h)$ and chooses two messages $M_{0}$ and $M_{1}$ which are sent to an encryption oracle who randomly chooses a bit $b$ and returns an encryption $c$ of $M_{b}$. In a second phase, the attacker tries to guess which message has been encrypted.

We now describe how to feed an adversary $\mathcal{A}$ of the threshold scheme in order to make a semantic attacker. In step $A1$ of game A, the adversary chooses to corrupt $t$ servers $P_{1},\ldots,P_{t}$. In the find phase, the attacker first obtains the public key $PK=(n,G,g,h)$ of the BGNC. He randomly chooses $t$ values $d_{1},\ldots,d_{t}$ in the range $\{0,\ldots,n\}$. $T$ is suitably chosen to efficiently compute the discrete logarithm on the elliptic curve. As $q_{2}$ is unknown and $T<q_{2}$. We have to simulate the value of $T$. However, as the computation efficiency of the function $log$ is well known, a suitable choice of $T$ may be obtained.

In step 2 of game A, the attacker sends $(n,G,g,h,d_{1},\ldots,d_{t})$ to $\mathcal{A}$.

During step A3, $\mathcal{A}$ chooses a message $M$ and sends it to the attacker. He computes a valid encryption of $M$ given by $c=r\times h+M\times g$, where $r$ is a random number. The decryption shares of the corrupted players are correctly computed using the $d_{i}$’s:$c_{i}=log_{d_{1}g}\gamma_{i}c$, and $g_{i}=d_{i}g$ for $i=1,\ldots,t$. The other shares are computed from the following formula

[TABLE]

where $a=Dg_{0}$ and $b=[\sum_{j\in S}\mu_{ij}(\beta_{j}c+g_{0}c_{j})]-D\beta_{i}c$. We have that $c_{i}=log_{g_{0}}\gamma_{i}c$. So $c_{i}g_{0}=\gamma_{i}c$, and by multiplying by $D$: $Dc_{i}g_{0}=D\gamma_{i}c=D(d_{i}-\beta_{i})c=Dd_{i}c-D\beta_{i}c$. We have also $Dd_{i}=\sum_{j\in S}\mu_{ij}d_{j}$, this is why we chose the values of $c_{i}$ as in the above formula.

Finally, the adversary returns

[TABLE]

In step A4, $\mathcal{A}$ chooses and outputs two messages $M_{0}$ and $M_{1}$. The attacker outputs those two messages as the results of the find phase.

The encryption oracle for the non-threshold ECC scheme chooses a random bit and sends an encryption $c$ of $M_{b}$ to the attacker. He forwards $c$ to the adversary $\mathcal{A}$.

Step A5 is similar to step A3. Finally, in step A6, $\mathcal{A}$ answers a bit $b^{\prime}$ which is returned by the attacker in the guess phase.

We have that $d_{1},\ldots,d_{t}$ and the verification keys are randomly chosen on the interval $[0,T]$. So, the distribution received by $\mathcal{A}$ during the key generation step is indistinguishable from a real one.

Also, the value received in step A3 and A5 are computed from the secret keys and the values of the non-corrupted servers are randomly chosen on the interval $[0,n]$.

Finally, all the data simulated by the attacker cannot be distinguished from real ones by $\mathcal{A}$. Consequently, if there exists a polynomial time adversary $\mathcal{A}$ able to break the semantic security of the threshold scheme, we have made an attacker able to break the semantic security of the original ECC scheme. ∎

5 A Second Distribution of BGNC

5.1 The ElGamal Distributed Version

First, we recall the distributed version of the ElGamal elliptic curve cryptosystem (DEGECC) taken from [7]. Let the parameters of the cryptosystem be a finite field $GF(p)$, where $p$ is a prime number, an elliptic curve $E_{p}(a,b)$ and a point $G$ of order $q$ on the group of point of $E$. Then we run the cryptosystem as follow :

Bob’s private key is $n_{B}$ with $0<n_{B}<q$ and the public key is $K_{B}=n_{B}G$.

First we choose a prime number $p>max(M,n)$, and define $a_{0}=M$ to be the message. Then we randomly select $k-1$ independent coefficients $a_{1},\ldots,a_{k-1}$, with $0\leq a_{j}\leq p-1$; which define the random polynomial $f(x)$ over a Galois prime field $GF(p)$. 2. 2.

We compute $n$ shares, $M_{i}=f(x_{i})\mod p,1\leq i\leq n$, where $x_{i}$ can be just the public index $i$ for simplicity. Convert each index $i$ to a point $P_{i}$ on the elliptic curve $E$. 3. 3.

Alice picks a random number $r$ and send $rG$ and $P_{i}+rK_{B}$ to Bob with index $t$. 4. 4.

Bob recovers each elliptic curve point by calculating $P_{i}+rK_{B}-n_{B}rG=P_{i}$. 5. 5.

Bob converts $P_{i}$ to $M_{i}$ and deduces $M$ by using Lagrange interpolation formula.

Our novel distributed crytosystem runs as follows: The public and private data are as in section 3.

First, define $a_{0}=M$ the message. Then, we select $k-1$ random independent coefficients $a_{1},\ldots,a_{k-1},0\leq a_{j}\leq p-1$, defining the random polynomial $f(x)$ over $GF(p)$. 2. 2.

We compute $n$ shares, $M_{i}=f(x_{i})\mod p,1\leq i\leq n$, where $x_{i}$ can be just the public index $i$ for simplicity. 3. 3.

Alice picks a random number $r\in[0,n-1]$. So the ciphertext is computed as

[TABLE] 4. 4.

Bob recovers each elliptic curve point by calculating

[TABLE] 5. 5.

Bob deduces $M$ by using Lagrange interpolation formula.

If an adversary wishes to cryptanalyse our scheme, he will have to break the SDP assumption, which has not been broken to the best of our knowledge.

5.2 Implementation Details and Computation Efficiency

In this section, we compare our second version of the distributed BGNC to DEGECC. We focus on the ciphering and the deciphering times of the two cryptosytems. We have used Sage software [10] to compare the computational efficiency of the two algorithms. Rather than implementing the whole algorithm, we restricted to the encryption plus the decryption functions, as the other parts of the two algorithms are the same. As we deal with the computation time, we take the average value of all the random values $r$. Also, we have chosen $q/2$ as the private key $n_{B}$.

For the BGNC, we have used $T=100$. So, for a given share $M_{i}<p$, write $M_{i}$ in base 100. Thus, we obtain $(M^{\prime}_{1},\ldots,M^{\prime}_{s})$, $s$ depending on the value of $p$. Hence, for all $0<i<s+1$, $0<M^{\prime}_{i}<100$.

We compute the number of points addition during the ciphering plus the deciphering processes of the two cryptosystems. This is because this operation is the more expensive in time computation. So, for the DEGECC, we will need $r+r+1+n_{B}+1=2r+2+n_{B}$ points addition for encryption and decryption of one single point $P_{i}$. For the BGNC, we will need $r+M_{i}$ points addition plus $s/2$ computation of the logarithm with the Pollard Lambda algorithm. As the value of $s$ will have logarithm behavior, DEGECC will be more costly than BGNC for large keys.

We have taken 3 curves of different key lengths from [11] and computed the average time consumption of 100 runs of the two algorithms. We plotted that and obtained Fig. 1 which shows the good performance of our algorithm over the ElGamal one.

6 Conclusion

We have designed two distributions of the BGNC. The first one is proved semantically secure and the second one is more efficient than the DEGECC. While efficiency is considered a poor comparison parameter, it can be an essential one in the setting of a sensor network, wherein energy consumption is of concern, rather than the security level of the scheme.