Loading [MathJax]/extensions/MathMenu.js
Privacy-Preserving Outsourced Inner Product Computation on Encrypted Database | IEEE Journals & Magazine | IEEE Xplore

Privacy-Preserving Outsourced Inner Product Computation on Encrypted Database


Abstract:

We consider an outsourced computation model in the selective data sharing setting. Specifically, one of the data owners outsources the encrypted data to an untrusted clou...Show More

Abstract:

We consider an outsourced computation model in the selective data sharing setting. Specifically, one of the data owners outsources the encrypted data to an untrusted cloud server, and wants to share the specific function of these data with a group of data users. A data user can perform the specific computation on the data that it is authorized to access. We propose a construction under this model for the inner product computation by using the Inner Product Functional Encryption (IPFE) as a building block. A standard IPFE used on this model has two privacy weaknesses regarding the master secret key and the encrypted vector. We propose a strengthened IPFE that revises these weaknesses. We construct a new IPFE scheme and use it to construct an efficient outsourced inner product computation scheme. In our outsourced computation scheme, the storage overhead and the computation cost for a data user are independent of the vector size. The result privacy and the outsourced data privacy are well preserved against the untrusted cloud server. The experimental results show that our schemes are efficient and practical.
Published in: IEEE Transactions on Dependable and Secure Computing ( Volume: 19, Issue: 2, 01 March-April 2022)
Page(s): 1320 - 1337
Date of Publication: 10 June 2020

ISSN Information:

Funding Agency:


CCBY - IEEE is not the copyright holder of this material. Please follow the instructions via https://creativecommons.org/licenses/by/4.0/ to obtain full-text articles and stipulations in the API documentation.
SECTION 1

Introduction

Huge volumes of data are generated everyday. This brings heavy storage burden to the data owner who has limited storage capacity. Fortunately, the emerging cloud service provides almost unlimited storage resources. The data owner can purchase storage service from a cloud server to store the data. However, the cloud server is usually maintained by the external companies that may be curious about the outsourced data. For example, they collect the private information including phone numbers for the merchants who want to sell their products by calling the data owner. This could bring troubles to the data owner. In fact, the outsourced data privacy becomes a main concern in the cloud storage.

For the sensitive nature of outsourced data, it is necessary for data owner to encrypt the data prior to storing these data in the cloud server. Of course, to achieve full privacy, we want the outsourced data to appear as a set of meaningless symbols. But once the outsourced data is encrypted by a conventional encryption scheme such as the AES encryption and ElGamal encryption, it seems infeasible to perform the computations on these outsourced data [1]. The data owner needs to first download the relevant ciphertext, and then use the secret key to recover the underlying data for computation. This will incur a cost of downloading outsourced data and a storage overhead for the data owner. These limitations contradict the intention of storing data in the cloud and motivate the study of how to efficiently compute on the outsourced encrypted data in a privacy-preserving manner.

To avoid downloading the encrypted data, the data user can delegate the computation to the cloud server. This paradigm is called as outsourced computation [2] that enables the computation to be performed in the cloud server's side. In order to prevent the malicious behavior of the cloud server, the data user needs a procedure to verify the correctness of the returned result. So this paradigm is also referred to as verifiable computation. It can theoretically be achieved by combining Zero Knowledge (ZK) [3] with Fully Homomorphic Encryption (FHE) [4] or Multi-Party Computation (MPC) [5]. However, the huge efficiency overhead makes the resulting schemes impractical in the real life.

In addition to reducing the local overhead (including the overhead of storage and computation) for data owner, another benefit of cloud service is that a data owner can easily share the data with other people who is called as data user. It is natural to consider a case where a group of data owners outsource their individual encrypted data under their personal keys to a cloud server, then the authorized data users can perform the computation on these outsourced data. A trivial way to solve this problem is to let the data owner provide the authorized group of data users with the secret keys. It requires that one secret key is just used to encrypt one data to achieve the access control over the data. To delegate the computation, the data user sends the keys and the desired function to the cloud server. However, this solution has two main drawbacks: 1) the data user needs to maintain lots of secret keys when the computation needs lots of data. 2) The data is totally exposed to the cloud server who can manipulate these data without any limitation.

To overcome the above restrictions, we seek to use the Functional Encryption (FE) [6], [7] as a building block to perform the outsourced computation on the outsourced encrypted data, which is usually mentioned as the motivation in many works regarding FE, such as [8], [9]. The solution extracted from these works is stated that a data owner who acts as the encryptor uses the public key $pk$ to generate the ciphertexts $C_{m_1},\ldots, C_{m_t}$ for the data $m_1,\ldots, m_t$, and then stores these ciphertexts in the cloud server. The data user who acts as the decryptor asks the key generation center to generate the secret key $sk_f$ related to a function $f$, and then sends this secret key to the cloud server to compute $f(m_1),\ldots,f(m_t)$. Ideally, the security of FE requires that the legitimate decryptor learns only the specific information of encrypted data, and nothing else. This property can preserve the privacy of outsourced data, and achieve the access control over the revealed information of outsourced data. Obviously, the resulting scheme can be also applied to the case of multiple data owners and multiple data users.

Recently, the works [10], [11], [12], [13], [14], [15] proposed the outsourced computation schemes by using as a building block the Attribute-Based Encryption (ABE) that is a specific form of FE. The resulting schemes can be used to compute the Boolean circuit, but are not as efficient as the constructions for a specific function in realistic case. To the end of high efficiency and practical significance, we would like to propose an outsourced computation scheme for inner product based on Inner Product Functional Encryption (IPFE) [16], [17], [18], [19], [20], [21], [22], [23], [24], [25], [26], [27], [28]. The inner product is a basic primitive in many practical applications. In particular, it is an elegant way to compute the weight mean in descriptive statistics [16]. Moreover, it can be used to compute the polynomials with the coefficient vector and the variable power vector [29]. Following the idea of above solution based on FE, we replace underlying primitive of FE with IPFE to get the initial solution for inner product computation, which is shown in Fig. 1a. However, this initial solution is not so satisfactory that may cause data leakage, wrong result, etc.

Fig. 1. - 
To explicitly show our work about the deployment of inner product functional encryption in cloud, we illustrate the initial solution and our solution. The differences between (a) and (b) reflect our works based on the initial solution that is mentioned in the existing works. For example, our solution achieves the verification and the result privacy against cloud server. Refer to Section 1.1.2 for more details.
Fig. 1.

To explicitly show our work about the deployment of inner product functional encryption in cloud, we illustrate the initial solution and our solution. The differences between (a) and (b) reflect our works based on the initial solution that is mentioned in the existing works. For example, our solution achieves the verification and the result privacy against cloud server. Refer to Section 1.1.2 for more details.

1.1 Our Works

In order to construct a privacy-preserving outsourced inner product computation scheme in the data sharing setting, we need first to propose an IPFE scheme with some privacy guarantees.

1.1.1 The Weakness in IPFE

To clearly specify our works, we present the scheme in [19] as follows. Suppose integers $X$ and $Y$ are both bound parameters, the vectors $x=(x_1,\ldots,x_n)$ and $y=(y_1,\ldots,y_n)$ are respectively bounded by $X$ and $Y$. For integer $N=\tilde{p}\cdot \tilde{q}>X\cdot Y$, where $\tilde{p}$, $\tilde{q}$ are two safe primes, we randomly choose a value $g^{\prime }$ from $\mathbb {Z}^{\ast }_{N^2}$ to compute $g=g^{\prime 2N}\ mod \ N^2$, and the vector $s=(s_1,\ldots,s_n)$ from the discrete Gaussian distribution $\mathcal {D}_{\mathbb {Z}^{n},\delta }$ to compute $\left\lbrace h_i=g^{s_i}\ mod \ N^2 \right\rbrace _{i\in \lbrace 1,\ldots,n\rbrace }$. The master public key and the master secret key are respectively \begin{equation*} mpk=\left(N,g,\left(h_1,\ldots,h_n\right),X\right),\ msk=\left(\left(s_1,\ldots,s_n\right),Y\right). \end{equation*} View SourceRight-click on figure for MathML and additional features. The secret key regarding $y$ is computed as $sk_y=\sum _{i=1}^{n}s_i y_i$. To generate the ciphertext for $x$, we randomly choose the integer $r$ from $\lbrace 0,\ldots,\lfloor \frac{N}{4}\rfloor \rbrace$ to compute \begin{equation*} C_0=g^{r}\ mod \ N^2,\ \left\lbrace ct_i=\left(1+Nx_i\right)h_i^{r}\ mod \ N^{2} \right\rbrace _{i\in \lbrace 1,\ldots,n\rbrace }. \end{equation*} View SourceRight-click on figure for MathML and additional features. The ciphertext is $C_x=\left(C_0,C_1\right)$ where $C_1=\left(ct_1,\ldots,ct_n\right)$. The inner product $\left<x,y\right>$ is obtained by decrypting the ciphertext as follows: \begin{equation*} \frac{1}{N}\cdot \left(\left(\prod _{i=1}^{n}ct_i^{y_i}\cdot C_0^{-sk_y}-1\right)\ mod \ N^2\right). \end{equation*} View SourceRight-click on figure for MathML and additional features. We can observe that $sk_y$ can be used to obtain the relevant inner products when the ciphertexts are encrypted under a public key associated with the master secret key $s$.

The Encrypted Vector Privacy. Thanks to the linearity of inner product, a malicious decryptor can recover the encrypted vector $x$ by querying the secret keys related to $n$ independent vectors, if the encrypted vector is $n$-dimension. For the encrypted vector $x=(x_1, \ldots,x_n)$, a malicious decryptor or an attacker controlling several decryptors queries the secret keys $sk_{y^{(1)}},\ldots,sk_{y^{(n)}}$ regarding the linearly independent vectors $y^{(1)},\ldots,y^{(n)}$. Then it can obtain $x$ by solving below system of linear equations \begin{equation*} \left\lbrace \begin{array}{ll}\displaystyle\mathop \sum \limits _{i=1}^{n}x_{i}y_{i}^{(1)}&=\left\langle x,y^{(1)}\right\rangle \;mod \ N,\\ \cdots \\ \displaystyle\mathop \sum \limits _{i=1}^{n}x_{i}y_{i}^{(n)}&=\left\langle x,y^{(n)}\right\rangle mod\ N.\\ \end{array} \right. \tag{1} \end{equation*} View SourceRight-click on figure for MathML and additional features. The Master Secret Key Privacy. In order to control the revealed information of the encrypted vector in IPFE, the key generation center will generate a master secret key that includes the vector $s=\left(s_1,\ldots,s_n\right)$. The data user can ask the key generation center to generate the secret key $sk_y$ related to vector $y$, where $sk_y$ is the inner product between $s$ and $y=\left(y_1,\ldots,y_n\right)$, namely $\left<s,y\right>=\sum _{i=1}^{n}s_iy_i$. Clearly, $s$ can be maliciously recovered by solving the system of linear equations similar to (1), which results from $sk_{y^{\left(1\right)}},\ldots,sk_{y^{\left(n\right)}}$. Once $s$ is compromised, the secret key can be generated beyond the key generation center's supervision. IPFE would no longer have the advantage over controlling the revealed information regarding underlying encrypted vector. All of the encrypted vectors related to master secret key $s$ will be totally exposed. For this issue, the work [19] and subsequent works such as [17], [18], [22] require the key generation center to keep track of the vectors for which secret keys are issued. However, the key generation center needs to store the issued vectors, and compare the new vectors with them. Moreover, the domain of vector $y$ is restricted to the space generated from some specific linearly independent vectors, where the number of these vectors is no more than $n-1$. So these schemes fail to preserve the master secret key privacy over the total space that is generated based on $n$ linearly independent vectors.

1.1.2 The Issues Regarding the Deployment of IPFE

As is shown in Fig. 1a, in the initial solution that enables cloud server to compute the inner product, the data user needs to send the secret key $sk_y$ to the cloud server. Obviously, the secret key privacy and the result privacy cannot be preserved. What is worse, the malicious cloud server can abuse the secret key without the data user's permission. After accomplishing the computational query for a data user, the cloud server can still use the secret key to decrypt the new stored ciphertexts for its personal purpose. This is undesirable in many realistic scenarios since the result may contain some sensitive information.

In IPFE, the key generation center is responsible for distributing the secret key to the legitimate ones. However, this key can be applied to all the ciphertexts with which it shares the same master secret key. The resulting outsourced computation scheme also has this property. However, this is undesirable in the data sharing setting, where the data owners usually want to selectively share the information about the outsourced data. For example, the data owner would like to share the information regarding medical data with the doctors, while the information regarding work data with the colleagues.

1.1.3 Our Contributions

We first identify the privacy issues regarding master secret key and encrypted vector in IPFE. To achieve stronger privacy guarantees than the original schemes, we introduce the notion of standard consistency constraint in IPFE and put forward the notion of master secret key hiding.

We construct an IPFE scheme that meets these requirements based on the scheme in [19]. In the resulting scheme, a ciphertext can be decrypted by only one specific secret key. The revealed information of the encrypted vector is just an inner product that is generated from the encrypted vector and the vector embedded in the secret key. In addition, the unbounded number of the secret key queries are allowed, and the master secret key is perfectly hidden in our scheme. The experimental results show that our scheme achieves these new properties at a reasonable price of time cost compared with the scheme in [19].

We propose a new outsourced computation model in the selectively data sharing setting. In this model, the data owner is free of the huge storage overhead, while the data user is free of both the huge storage overhead and the large computation cost. The shared item is the function on the outsourced data instead of the data itself in the conventional way, which is a new way to preserve the outsourced data privacy in the data sharing setting.

We propose an outsourced inner product computation scheme for the selectively data sharing setting based on our IPFE scheme. The verification time and the storage cost for data user are both independent of the vector size. The resulting scheme achieves the secret key privacy and the result privacy, which discourages the malicious cloud server from computing the inner product beyond the data user's request. The outsourced data privacy relies on the indistinguishable based (CCA) security of our IPFE scheme. In addition, the resulting scheme achieves the “double access control” over the outsourced data. This implies that only the authorized data user can compute the inner product on the outsourced data, and other functions are unallowed. It is the first attempt to preserve the outsourced data privacy in such a way for the data sharing setting.

As a side result, the proposed outsourced computation scheme can implement retrieval functionality. The data user can use it to locate and obtain the outsourced data stored in cloud server. More specifically, data owner encrypts the vector $x=\left(x_1,\ldots,x_n\right)$ resulting from the outsourced data $x_1$, $\ldots$, $x_n$ by this proposed scheme. Data user who wants to obtain the data $x_i$ can use the vector $y=\left(0,0,\ldots,0,1,0,\ldots,0\right)$ whose $i$th position is 1 to get $x_i$ by computing the inner product $\left<x,y\right>=\sum _{i=1}^{n}x_iy_i=x_i$.

1.2 Related Works

1.2.1 The Inner Product Functional Encryption

In 2015, Abdalla et al. put forward the novel idea of IPFE in [16] in the public-key setting. They proposed two IPFE schemes under the Decision Diffie-Hellman (DDH) assumption and the Learning-With-Errors (LWE) assumption. These schemes are secure against the Chosen Plaintext Attack (CPA) under selective model. In 2016, they also proposed the adaptively CPA-secure generic constructions and corresponding concrete instantiations in [18]. The subsequent works attempted to increase the security level and implement the practical property. Agrawal et al. proposed the adaptively secure schemes based on the LWE assumption, the DDH assumption and the Decision Composite Residuosity (DCR) assumption [19]. In 2017, Benhamouda et al. proposed the schemes secure against Chosen Ciphertext Attack (CCA) [21]. These works all focused on the works qualified for the inner product computation over $\mathbb {Z}$. In 2018, Castagnos et al. proposed a scheme proper for the inner product computation over $\mathbb {Z}_p$ [17].

The existing works regarding IPFE usually consider the decryptor to be honest. Even though the privacy issue regarding the encrypted vector is mentioned in some existing works, such as [16], [17], they did not plan to solve this issue in the honest decryptor case. For the same reason, the privacy issue regarding the master secret key is not considered in the literature.

Another line of works, such as [23], [24], [25], [26] researched IPFE in the secret-key setting, where the encryptor and the decryptor share the same secret key. The standard consistency constraint in our IPFE scheme seems to be similar with the works in the secret-key setting. However, our work is still in the domain of public-key setting, where distinct encryptors can use the public key to generate ciphertexts for the designated decryptor.

1.2.2 The Outsourced Computation for Inner Product

The work [30] proposed the first practical outsourced computation scheme for high degree polynomial functions. In order to reduce the computation cost of verification, this work researched the primitive of Pseudorandom Functions (PRFs) with the closed form efficiency property. After this work, the work [31] proposed an outsourced computation scheme based on the outsourced database for matrix multiplication. In this work, a scheme supporting multi-function verifiable computation is also proposed, which allows a client to delegate the computation of multiple functions on the fixed outsourced data. The recent work [32] focused on the outsourced polynomial computation on the label-encrypted data under multi-server model. To perform the computation in a privacy-preserving manner, the outsourced data is stored in several cloud servers, and these cloud servers collectively accomplish the computation. Obviously, these schemes can be used to compute the inner product. However, these schemes need to compute the PRF value in the verification process, where the secret key is used. This implies that these schemes are not suitable for our setting where the data owner and the data user are distinct entities.

The works [33], [34] were specified on outsourced inner product computation. Similar to work [32], the work [33] used the technique of data splitting to protect the outsourced data privacy instead of the encryption, and store them in several different cloud servers. This scheme is more efficient than the cryptography-based ones. However, this scheme did not consider the verification. The work [34] proposed a scheme that is proper for inner product evaluation over outsourced data streams under multiple keys. This scheme can be used to compute the inner product on the data from different data owners. However, the storage overhead and the computation cost for data user are both dependent on the vector size.

The work [35] adopted the matrix digest technique to construct an outsourced computation scheme for batch matrix multiplication. This scheme achieves the public delegation that allows multiple data users to compute on the outsourced data. The input data privacy and the result privacy can be preserved, but it did not consider the procedures to preserve the outsourced data. In addition, the outsourced data are involved in the verification process, which contradicts the goal of relieving the local storage burden in the cloud storage.

In the research community, the outsourced computation has attracted more attention. For example, the works [36], [37] considered the applications of outsourced computation in the verifiable database. However, the outsourced computation in the selective data sharing setting is not fully considered. Since this model can largely reduce the local storage overhead and the computation cost, and implement the convenient information sharing in a privacy-preserving manner, it is interesting to investigate.

1.3 Organization

In the rest of this paper, the related preliminaries are introduced in Section 2. The system model and the security definitions are introduced in Section 3. Our constructions are proposed in Section 4. The related security analysis and necessary proofs are given in Section 5. The performance analysis is presented in Section 6. The conclusion is given in Section 7.

SECTION 2

Preliminaries

In this section, we introduce the notations and some related cryptographic knowledge used in this paper.

2.1 Notations

Some notations are illustrated in Table 1.

TABLE 1 Notations Used in This Paper
Table 1- 
Notations Used in This Paper

2.2 The Related Cryptographic Knowledge

Definition 1 (DCR Assumption).

Given an integer $N$ which is the multiplication of primes $p$ and $q$, the advantage probability $Adv_{\mathcal {A}}^{\text{DCR}}(\lambda)$ of distinguishing $\mathcal {D}_1=\lbrace z|z \ {\in }_{R}\ \mathbb {Z}_{N^2}^{\ast }\rbrace$ and $\mathcal {D}_2=\lbrace z|z=z_0^N\ mod\ N^2, z_0\ {\in }_{R}\ \mathbb {Z}_{N}^{\ast }\rbrace$ is negligible.

Definition 2 (Access Structure).

If $\lbrace P_1,\ldots,P_n\rbrace$ is a set of parties, $U\subseteqq 2^{\lbrace P_1,\ldots,P_n\rbrace }\setminus \emptyset$ is called an access structure. The set $U^{\prime }$ included in $U$ is called authorized set, and otherwise is called unauthorized set. The monotone access structure implies that, for any set $B_1$ and $B_2$, $B_2\in U$ if $B_1\in U$ and $B_1\subseteqq B_2$.

In our proposed scheme, the role of parties $P_i$ for $i\in \lbrace 1,\ldots,n\rbrace$ is described by their attributes. Thus, the access structure $U$ consists of the attributes of parties in authorized set. For simplicity, we define the attributes as elements in $\mathbb {Z}_p$, i.e., $U=\lbrace 1,\ldots,\left|U\right|\rbrace $.

Definition 3 (Bilinear Map).

Given two cyclic groups $\mathbb {G}$, $\mathbb {G}_{T}$ of prime order $p$ and the generator $g_1$ of $\mathbb {G}$, the bilinear pairing is a map $e$: $\mathbb {G}\times \mathbb {G}\rightarrow \mathbb {G}_T$ with following properties:

Non-degeneracy: $e(g_1,g_1)\ne 1$.

Bilinearity: $e(u_1^{a_1},u_2^{a_2})=e(u_1,u_2)^{a_1a_2}$ for all $u_1$, $u_2 \in \mathbb {G}$ and all $a_1$, $a_2\in \mathbb {Z}_p$.

Computability: we can find an efficient algorithm to compute $e(u_1,u_2)$ for all $u_1$, $u_2 \in \mathbb {G}$.

Definition 4 (Lagrange Coefficient).

We assume that $f(\cdot)$ is a $(d-1)$-degree polynomial and $U=\lbrace 1,\ldots,\left|U\right|\rbrace$. For every $i \in U$, the Lagrange coefficient for computing $f(x)$ is defined as \begin{equation*} \Delta _{i,U}(x)=\prod _{j\in U,j\ne i}\frac{x-j}{i-j}. \end{equation*} View SourceRight-click on figure for MathML and additional features. Then $f(x)$ can be represented as \begin{equation*} f(x)=\sum _{i=1}^{\left|U\right|}f(i)\Delta _{i,U}(x). \end{equation*} View SourceRight-click on figure for MathML and additional features.

Definition 5 (Adapted Inner Product Functional Encryption, Ada-IPFE).

This definition of Ada-IPFE is adapted from the work [38], which is shown in Fig. 2

Fig. 2. - 
This is the adaptation of IPFE. The left subfigure is derived from the definition in [19]. The right subfigure is derived from Definition 5. The processes marked by “$\dashrightarrow$⤏” in these two subfigures collectively reflect the standard consistency constraint of Definition 9.
Fig. 2.

This is the adaptation of IPFE. The left subfigure is derived from the definition in [19]. The right subfigure is derived from Definition 5. The processes marked by “$\dashrightarrow$” in these two subfigures collectively reflect the standard consistency constraint of Definition 9.

.
  • $\mathbf {Setup}(1^{\lambda }, 1^n,X,Y):$ On input security parameter $\lambda$, length parameter $n$ and two bound parameters $X$, $Y$, the setup algorithm outputs the master secret key $msk$ and the master public key $mpk$. This process is conducted by key generation center (KGC).

  • $\mathbf {KeyGen}(y,msk):$ On input a vector $y$ and master secret key $msk$, the key generation algorithm outputs the secret key $sk_y$ and the public key $pk_y$. This process is conducted by KGC.

  • $\mathbf {Encrypt}(x,mpk,pk_y):$ On input vector $x$, master public key $mpk$ and public key $pk_y$, the encryption algorithm outputs the ciphertext $C_x$. This process is conducted by qencryptor.

  • $\mathbf {Decrypt}(sk_y,C_x):$ On input secret key $sk_y$ and ciphertext $C_x$, the decryption algorithm outputs the inner product $\left<x,y\right>$ or the error symbol $\perp$. This process is conducted by decryptor.

Definition 6 (Correctness of Ada-IPFE).

An Ada-IPFE scheme is correct if for all $(msk,mpk)$ $\leftarrow$ $\mathbf {Setup}(1^{\lambda }, 1^n,X,Y)$, $(sk_y,pk_y) \leftarrow \mathbf {KeyGen}(y,msk)$, $C_x\leftarrow \mathbf {Encrypt} (x,mpk,pk_y)$, the algorithm $\mathbf {Decrypt}(sk_y,C_x)$ outputs $\left<x,y\right>$ with probability $1-\epsilon$, where $\epsilon$ is negligible.

Definition 7 (Adaptive Security of Ada-IPFE).

This definition is adapted from [17]. To define the adaptive security of Ada-IPFE, we first give the model defined by the following game $Exp_{\mathcal {A},Ada-IPFE}^{AdpSec}$ played by $\mathcal {A}$ and $\mathcal {C}$.

  • $\mathbf {Setup.}$ $\mathcal {C}$ runs $\mathbf {Setup}(1^{\lambda }, 1^n,X,Y)$ to produce $\left(msk,mpk\right)$. It sends $mpk$ to $\mathcal {A}$.

  • $\mathbf {Query\ phase\ 1.}$ $\mathcal {A}$ adaptively chooses the vectors $y^{(1)},\ldots,y^{(l_1)}$ for $\mathcal {C}$. $\mathcal {C}$ runs $\mathbf { KeyGen}(y^{(i)},msk)$ to generate the secret keys $sk_{y^{(1)}},\ldots,sk_{y^{(l_1)}}$ and the public keys $pk_{y^{(1)}},\ldots,pk_{y^{(l_1)}}$ for $\mathcal {A}$.

  • $\mathbf {Challenge.}$ $\mathcal {A}$ adaptively chooses the vectors $x^{(0)}$ and $x^{(1)}$ with the condition that $\left<x^{(0)},y^{(i)}\right>=\left<x^{(1)},y^{(i)}\right>$ for all $i\in \lbrace 1,\ldots,l_1\rbrace$ for $\mathcal {C}$. Then, $\mathcal {C}$ chooses a bit $\mu \ {\in }_{R}\ \lbrace 0,1\rbrace$, and runs $\mathbf {Encrypt}(x^{(\mu)},mpk,pk_{y^{(i_0)}})$ for one $i_0\in \left\lbrace 1,\ldots,l_1\right\rbrace$ to generate the challenge ciphertext $C_{x^{(\mu)}}$ for $\mathcal {A}$.

  • $\mathbf {Query\ phase\ 2.}$ Upon receiving $C_{x^{(\mu)}}$, $\mathcal {A}$ adaptively chooses the vectors $y^{(l_1+1)},\ldots,y^{(l_1+l_2)}$ with the condition that $\left<x^{(0)},y^{(i)}\right>=\left<x^{(1)},y^{(i)}\right>$ for all $i\in \lbrace l_1+1,\ldots,l_1+l_2\rbrace$ for $\mathcal {C}$. $\mathcal {C}$ runs $\mathbf { KeyGen}(y^{(i)},msk)$ to generate the secret keys $sk_{y^{(l_1+1)}},\ldots,sk_{y^{(l_1+l_2)}}$ for $\mathcal {A}$.

  • $\mathbf {Guess.}$ $\mathcal {A}$ outputs its guess $\mu ^{\prime }$, and wins in this game if $\mu ^{\prime }=\mu$.

An Ada-IPFE scheme is adaptively secure if $\mathcal {A}$ wins in $Exp_{\mathcal {A},Ada-IPFE}^{AapSec}$ with probability $\frac{1}{2}+\epsilon$, where $\epsilon$ is negligible.

In addition to the aforementioned basic requirements, we also consider the following new requirements in our Ada-IPFE scheme.

Definition 8 (Master Secret Key Hiding of Ada-IPFE).

To define the master secret key hiding of Ada-IPFE, we first give the model defined by the following game $Exp_{\mathcal {A},Ada-IPFE}^{MSKH}$ played by $\mathcal {A}$ and $\mathcal {C}$.

  • $\mathbf {Setup.}$ $\mathcal {C}$ runs $\mathbf {Setup}(1^{\lambda }, 1^n,X,Y)$ to produce $\left(msk,mpk\right)$. It sends $mpk$ to $\mathcal {A}$.

  • $\mathbf {Query\ phase.}$ $\mathcal {A}$ adaptively chooses the vectors $y^{(1)},\ldots,y^{(l)}$ for $\mathcal {C}$. $\mathcal {C}$ runs $\mathbf { KeyGen}(y^{(i)}, msk)$ to generate the secret keys $sk_{y^{(1)}},\ldots,sk_{y^{(l)}}$ and the public keys $pk_{y^{(1)}},\ldots,pk_{y^{(l)}}$ for $\mathcal {A}$.

  • $\mathbf {Guess.}$ $\mathcal {A}$ outputs its guess of the master secret key $msk^{\ast }$. $\mathcal {A}$ wins in this game if $msk^{\ast }=msk$.

An Ada-IPFE scheme is master secret key hiding if $\mathcal {A}$ wins in $Exp_{\mathcal {A},Ada-IPFE}^{MSKH}$ with probability $\epsilon$, where $\epsilon$ is negligible.

Definition 9 (Standard Consistency Constraint of Ada-IPFE).

An Ada-IPFE scheme guarantees the standard consistency constraint if the ciphertext $C_x$ generated with the public key $pk_y$ can only be decrypted by the secret key $sk_y$ to reveal the inner product $\left<x,y\right>$. This is shown in the Fig. 2.

Definition 10 (Encrypted Vector Hiding of Ada-IPFE).

An Ada-IPFE scheme is encrypted vector hiding if the underlying encrypted vector cannot be recovered.

SECTION 3

Our System Model and Security Definitions

In this section, we describe the system model and the security definitions of outsourced inner product computation on encrypted database in the selective data sharing setting.

3.1 System Model

3.1.1 The Role of Participants

As is shown in Fig. 1b, the outsourced inner product computation with access control over the encrypted database (OIPFE-ACED) involves four participants, namely key generation center (KGC), data owner (DO), cloud server (CS) and data user (DU). The details are described as follows.

  1. KGC generates the system parameters which include the master public key and the master secret key. In addition, it is also responsible for generating the secret key for DU.

  2. DO uses master public key to encrypt the outsourced data, and then stores it in CS.

  3. KGC generates the secret key for DU based on DU's attributes. Then, DU transforms secret key into the evaluation key for CS.

  4. Upon receiving the evaluation key, CS uses it to compute the intermediate result for DU. Then, DU recovers the desired inner product and verifies it.

3.1.2 System Components

A scheme for outsourced inner product computation with access control over the outsourced encrypted database consists of following five polynomial time algorithms.

  • $\mathbf {Setup}(1^{\lambda }, 1^n, X, Y,U)$: On input the security parameter $\lambda$, the length parameter $n$, the bound parameters $X$ and $Y$, the system attribute universe $U$, the setup algorithm outputs the master secret key $msk$ and the master public key $mpk$. This process is conducted by KGC.

  • $\mathbf {Store}(x,mpk,d)$: On input the vector $x$, the master public key $mpk$ and the threshold value $d$, the storage algorithm outputs the ciphertext $C_x$ and the verification key $VK$. Then, it stores $C_x$ in CS. This process is conducted by DO.

  • $\mathbf {Query}(y,msk,U^{\prime })$: On input the vector $y$, the master secret key $msk$ and DU's attribute set $U^{\prime }$, the computational query algorithm outputs the secret key $sk_y$, the public information $pk_1$ and $pk_2$, the retrieving key $\pi$ and the evaluation key $EK_y$. This algorithm is divided into two stages. The first one is conducted by KGC, the second one is conducted by DU.

  • $\mathbf {Compute} (pk_1,pk_2,EK_y,C_x)$: On input the public information $pk_1$ and $pk_2$, the evaluation key $EK_y$ and the ciphertext $C_x$, the computation algorithm outputs the proof $P$, the intermediate result $I$. This process is conducted by CS.

  • $\mathbf {Recover}(I,sk_y,VK,P)$: On input the intermediate result $I$, the secret key $sk_y$, the verification key $VK$ and the proof $P$, the retrieving algorithm outputs the desired result $\left<x,y\right>$ and verifies this result if $\left|U\cap U^{\prime }\right|\geq d$. This process is conducted by DU.

3.2 Security Definitions

Definition 11 (Correctness of OIPFE-ACED).

An OIPFE-ACED scheme is correct if for all $(msk,mpk)\leftarrow \mathbf {Setup}(1^{\lambda }, 1^n, X, Y,U)$, all $(C_x,VK)\leftarrow \mathbf {Store}(x,mpk,d)$, all $(sk_y,pk_1,pk_2,\pi,EK_y) \leftarrow \mathbf {Query}(y,msk,U^{\prime })$, all $(P,I)$ $\leftarrow \mathbf {Compute} (pk_1,pk_2,EK_y,C_x)$, the algorithm $\mathbf {Recover}(I,sk_y,VK,P)$ outputs the inner product $\left<x,y\right>$ with probability $1-\epsilon$ under the condition of $\left|U\cap U^{\prime }\right|\geq d$, where $\epsilon$ is negligible.

Definition 12 (Outsourced Vector Privacy of OIPFE-ACED).

To define the outsourced vector privacy of OIPFE-ACED, we first give the model defined by following game $Exp_{\mathcal {A},OIPFE}^{OVP}$ played by $\mathcal {A}$ and $\mathcal {C}$.

  • $\mathbf {Setup.}$ $\mathcal {C}$ runs $\mathbf {Setup}(1^{\lambda }, 1^n,X,Y,U)$ to produce $\left(msk,mpk\right)$. It sends $mpk$ to $\mathcal {A}$.

  • $\mathbf {Query\ phase.}$ $\mathcal {C}$ randomly chooses a vector $x$ and runs $\mathbf {Store}(x,mpk,d)$. Then, it sends the $C_x$ and $VK$ to $\mathcal {A}$. Then, $\mathcal {A}$ adaptively chooses the vectors $y^{(1)},\ldots,y^{(l)}$ and the attribute set $U^{\prime }$ for $\mathcal {C}$, $\mathcal {C}$ runs $\mathbf {Query}(y^{(i)},msk,U^{\prime })$ to produce $(pk_1^{(i)},pk_2^{(i)},EK_{y^{(i)}})$ for $\mathcal {A}$.

  • $\mathbf {Challenge.}$ $\mathcal {A}$ adaptively chooses the vectors $y_{0}$ and $y_{1}$ for $\mathcal {C}$. $\mathcal {C}$ chooses $\mu \ {\in }_{R}\ \lbrace 0,1\rbrace$ and runs $\mathbf {Query}(y_\mu,msk,U^{\prime })$ to produce $(pk_1^{(\mu)},pk_2^{(\mu)},EK_{y_{\mu }})$ for $\mathcal {A}$.

  • $\mathcal {A}$ outputs its guess $\mu ^{\prime }$, and wins in this game if $\mu ^{\prime }=\mu$.

An OIPFE-ACED scheme can preserve the outsourced vector privacy if $\mathcal {A}$ wins in $Exp_{\mathcal {A},OIPFE}^{OVP}$ with probability $\epsilon$ regardless of whether $\left|U\cap U^{\prime }\right|\geq d$ or $\left|U\cap U^{\prime }\right|< d$ holds, where $\epsilon$ is negligible.

Definition 13 (Unforgeability of OIPFE-ACED).

To define the unforgeability of OIPFE-ACED, we first give the model defined by the following game $Exp_{\mathcal {A},OIPFE}^{Unforge}$ played by $\mathcal {A}$ and $\mathcal {C}$.

  • $\mathbf {Setup.}$ $\mathcal {C}$ runs $\mathbf {Setup}(1^{\lambda }, 1^n,X,Y,U)$ to produce $\left(msk,mpk\right)$. It sends $mpk$ to $\mathcal {A}$.

  • $\mathbf {Query\ phase.}$ $\mathcal {C}$ chooses a vector $x$ to run $\mathbf {Store}(x,mpk,d)$ to produce the verification key $VK$ and the ciphertext $C_x$ for $\mathcal {A}$. Then, $\mathcal {A}$ adaptively chooses the vectors $y^{(1)},\ldots,y^{(l)}$ and the attribute set $U^{\prime }$ for $\mathcal {C}$. $\mathcal {C}$ runs $\mathbf {Query}(y^{(i)},msk,U^{\prime })$ for $i\in \lbrace 1,\ldots,l\rbrace$ to produce $(pk_1^{(i)},pk_2^{(i)},EK_{y^{(i)}})$ for $\mathcal {A}$.

  • $\mathbf {Forgery.}$ $\mathcal {A}$ adaptively chooses the vectors $y^{\ast }$ for $\mathcal {C}$, $\mathcal {C}$ runs $\mathbf {Query}(y^{\ast },msk,U^{\prime })$ to produce $\left(pk_1^{\ast },pk_2^{\ast },EK_{y^{\ast }}\right)$ for $\mathcal {A}$. $\mathcal {A}$ outputs its forged intermediate result $I^{\ast }$ and the forged proof $P^{\ast }$ for $\mathcal {C}$.

  • $\mathbf {Output.}$ $\mathcal {A}$ wins in this game if the final inner product resulting from the forged intermediate result passes the verification. Then, this game outputs 1, and otherwise outputs 0.

An OIPFE-ACED scheme achieves the unforgeability if $\mathcal {A}$ wins in $Exp_{\mathcal {A},OIPFE}^{Unforge}$ with probability $\epsilon$ regardless of whether $\left|U\cap U^{\prime }\right|\geq d$ or $\left|U\cap U^{\prime }\right|< d$ holds, where $\epsilon$ is negligible.

SECTION 4

Our Constructions

We have already known that the existing IPFE schemes are given under the assumptions of DDH, LWE, DCR, etc. The DDH-based schemes require that the inner product should be contained in a sufficiently small interval for decryption to be efficient. The LWE-based schemes suffer from poor efficiency due to the impractical parameters. And the DCR-based schemes need to use a large modulus. Clearly, these schemes have various practical restrictions. Considering the popularity of Paillier cryptographic system thanks to its better efficiency and practical deployment, we choose to present our constructions based on DCR-based IPFE scheme in [19].

We first propose our Ada-IPFE scheme. Then, we propose the privacy-preserving outsourced inner product computation scheme with the access control over the outsourced encrypted database based on this Ada-IPFE scheme. These schemes are proper for computing the inner product over $\mathbb {Z}$. We assume that the message vector $x$ and the key vector $y$ respectively satisfy $\left\Vert x\right\Vert \leq X$, $\left\Vert y\right\Vert \leq Y$ and $X\cdot Y < N$ where $N$ is the modulus in the Paillier's cryptography. Even though the decryption reveals $\left<x,y\right>$ over $\mathbb {Z}_N$, this inner product is exactly $\left<x,y\right>$ over $\mathbb {Z}$ for the norm bounds of $x$ and $y$. To prove the security, we also assume $X, Y <\sqrt{\frac{N}{n}}$.

4.1 The Ada-IPFE With Mater Secret Kay Hiding and Encrypted Vector Hiding

Our Ada-IPFE scheme based on the Paillier cryptographic system is described as follows.

  • $\mathbf {Setup}(1^{\lambda }, 1^n, X, Y)$: On input the security parameter $\lambda$, the length parameter $n$, the bound parameters $X$ and $Y$, KGC chooses the prime numbers $\tilde{p}=2p^{\prime }+1$ and $\tilde{q}=2q^{\prime }+1$ to compute $N=\tilde{p}\tilde{q}$, where $p^{\prime }$, $q^{\prime }$ $>$ $2^{l(\lambda)}$ for some polynomial $l$. Furthermore, it chooses an element $g^{\prime }\ {\in }_{R}\ \mathbb {Z}_{N^2}^{\ast }$ and a vector $s=\left(s_1,\ldots, s_n\right)\ {\in }_{R} \mathcal {D}_{\mathbb {Z}^{n},\delta }$ which is the discrete Gaussian distribution with the standard deviation $\delta >\lambda ^{\frac{1}{2}}\cdot N^{\frac{5}{2}}$.

    Then, it computes \begin{equation*} g=g^{\prime 2N}\ mod \ N^2,\ \left\lbrace h_i=g^{s_i}\ mod \ N^2\right\rbrace _{i\in \left[1,n\right]}. \end{equation*} View SourceRight-click on figure for MathML and additional features. Finally, it sets $mpk=(g,\left\lbrace h_i\right\rbrace _{i\in \left[1,n\right]}, N, X), msk=\left(s,Y\right),$ stores the master secret key $msk$ and makes the master public key $mpk$ public.

  • $\mathbf {KeyGen}(y,msk)$: On input the vector $y=\left(y_1,\ldots,y_n\right)$ from a decryptor and the master secret key $msk$, KGC chooses the values $\alpha, \beta \ {\in }_{R}\ \mathbb {Z}_{N}$. Then, it computes \begin{align*} sk&=\left<s,y\right>+\;\alpha +\beta,\\ pk_1&=g^{\alpha }\ mod\ N^2, \ pk_2=g^{\beta }\ mod\ N^2. \end{align*} View SourceRight-click on figure for MathML and additional features. Finally, it sets $sk_{y}=\left(\beta, sk\right)$ and $pk_{y}=\left(pk_1,pk_2\right)$, sends the secret key $sk_y$ to the decryptor and makes the public key $pk_y$ public.

  • $\mathbf {Encrypt}(x,mpk,pk_y)$: On input the encrypted vector $x=(x_1,\ldots,x_n)$, the master public key $mpk$ and the public key $pk_y$, the encryptor chooses the values $r\ {\in }_{R}\ \lbrace 0,\ldots,\lfloor \frac{N}{4}\rfloor \rbrace$, $a\ {\in }_{R}\ \mathbb {Z}_{N}^{\ast }$, $b\ {\in }_{R}\ \mathbb {Z}_{N}$ and $c\ {\in }_{R}\ \mathbb {Z}_{N}$.

    Then, it computes \begin{align*} \sigma &=\left(pk_2^{c}\ mod\ N^2\right)\ mod\ N,\ C_1=g^{r}\ mod \ N^2, \\ C_2&=g^{b}\ mod \ N^2,\ C_3=(c\cdot a-b)\ mod \ N,\\ C_4 &=pk_1^{r}\ mod \ N^2,\\ C_5&=\left\lbrace ct_i=h_i^{r} (1+N\sigma x_i) \ mod \ N^2\right\rbrace _{i\in \left[1,n\right]}. \end{align*} View SourceRight-click on figure for MathML and additional features. Finally, it sets $C_0=a$, $C_x=\left(C_0,C_1,C_2,C_3,C_4,C_5\right)$, and sends the ciphertext $C_x$ to the decryptor.

  • $\mathbf {Decrypt}(sk_y, C_x)$: On input the secret key $sk_y$ and the ciphertext $C_x$, the decryptor computes the following values with the aid of KGC who can compute the inverse in $\mathbb {Z}_N^{\ast }$ (i.e., $(C_1^{(\beta -sk)modN} C_4 \prod _{i=1}^{n}ct_i^{y_i})^{\omega _1^{-1}}$, where $(C_2\cdot g^{C_3})^{\beta }$ and $C_1^{(\beta -sk)modN} C_4 \prod _{i=1}^{n}ct_i^{y_i}$ are computed by decryptor) \begin{align*} \omega _1&=\left(\left(C_2\cdot g^{C_3}\right)^{\beta \cdot C_0^{-1}\ mod\ N}mod\ N^2\right)mod\ N,\\ \omega _2&=\frac{\left(\left(C_1^{(\beta -sk)modN} C_4 \prod _{i=1}^{n}ct_i^{y_i}\right)^{\omega _1^{-1}}-1\right)mod \ N^2}{N}. \end{align*} View SourceRight-click on figure for MathML and additional features.

4.2 Privacy-Preserving Outsourced Inner Product Computation on Encrypted Database

4.2.1 An Overview

In the setup phase, the global parameters are generated. The parameters related to Ada-IPFE are used to encrypt the outsourced vector and compute the inner product. Whereas, the rest parameters are used to achieve the access control over the outsourced database. Among the rest algorithms, the data outsourcing is implemented by the $\mathbf {Store}$ algorithm, the computation outsourcing is implemented by the algorithms of $\mathbf {Query}$, $\mathbf {Compute}$ and $\mathbf {Recover}$. In the $\mathbf {Store}$ algorithm, the outsourced vector is encrypted by the encryption procedures of Ada-IPFE scheme. And the components related to access policy and verification are also respectively generated. These items except that related to the verification are stored in CS. The privacy of the outsourced vector relies on the security of underlying Ada-IPFE. In the $\mathbf {Query}$ algorithm, the secret key related to one vector and DU's attribute set is generated. This secret key allows the legitimate DU to learn the desired inner product. For the security and privacy concerns, DU should avoid sending the secret key to CS. So DU needs to transform the secret key into the evaluation key. This is done by blinding the secret key with random factors. Thanks to these random factors, the returned result computed by CS is in the blinded form. This prevents CS from arbitrarily abusing the secret key beyond DU's request. In the $\mathbf {Compute}$ algorithm, CS computes the returned result and the proof. In the $\mathbf {Recover}$ algorithm, DU recovers the desired inner product by using the specific secret information. And it can verify this result in the necessary case.

4.2.2 Description of the Proposed OIPFE-ACED Scheme

Our OIPFE-ACED scheme based on the Paillier cryptographic system is described as follows.

  • Setup($1^{\lambda }, 1^n, X, Y,U$): On input the security parameter $\lambda$, the length parameter $n$, the bound parameters $X$, $Y$ and the system attribute universe $U$, KGC chooses the prime numbers $\tilde{p}=2p^{\prime }+1$ and $\tilde{q}=2q^{\prime }+1$ to compute $N=\tilde{p}\tilde{q}$, where $p^{\prime }$, $q^{\prime }$ $>$ $2^{l(\lambda)}$ for some polynomial $l$. Furthermore, it chooses an element $g^{\prime }\ {\in }_{R}\ \mathbb {Z}_{N^2}^{\ast }$ and a vector $s=\left(s_1,\ldots, s_n\right) \ {\in }_{R}\ \mathcal {D}_{\mathbb {Z}^{n},\delta }$ which is the discrete Gaussian distribution with the standard deviation $\delta >\lambda ^{\frac{1}{2}}\cdot N^{\frac{5}{2}}$. For the system attribute universe $U$, KGC chooses the bilinear map $e$: $\mathbb {G}\times \mathbb {G}\rightarrow \mathbb {G}_T$ as in Definition 3, the hash functions $H_1:\mathbb {G}_T\rightarrow \mathbb {Z}_N^{\ast }$, $H_2:\mathbb {Z}_{N^2}\rightarrow \mathbb {Z}_{N^2}$, the elements $A_1, \ldots, A_{\left|U\right|} \ {\in }_{R}\ \mathbb {G}$ and the values $a, \beta \ {\in }_{R} \ \mathbb {Z}_p$.

    Then, it computes \begin{align*} &g=g^{\prime 2N}\ mod \ N^2,\ \left\lbrace h_i=g^{s_i}\ mod \ N^2\right\rbrace _{i\in \left[1,n\right]},\\ & A=g_1^{a}, \ h=g_1^{\beta }, \ E=e(g_1,g_1)^{\beta }. \end{align*} View SourceRight-click on figure for MathML and additional features. Finally, it sets \begin{align*} &msk=\left(s,h,Y \right),\\ & mpk=(g,\lbrace h_i\rbrace _{i\in \left[1,n\right]}, \lbrace A_i\rbrace _{i\in \left[1,\left|U\right|\right]}, e,\mathbb {G},\mathbb {G}_T,g_1,H_1,\\ &\quad \quad \quad \ \ H_2, A, E, N, X), \end{align*} View SourceRight-click on figure for MathML and additional features. stores the master secret key $msk$ and makes the master public key $mpk$ public.

  • Store($x,mpk,d$): On input $x=(x_1,\ldots,x_n)$, the master public key $mpk$ and the threshold value $d$, DO chooses $c\ {\in }_{R}\ \mathbb {Z}_{p}$, $r\ {\in }_{R}\ \lbrace 0,\ldots,\lfloor \frac{N}{4}\rfloor \rbrace$, the random values $\left\lbrace a_i\right\rbrace _{i\in [1,\left|U\right|]}$ from $\mathbb {Z}_p$ and a $(d-1)$-degree polynomial $f(\chi)\ {\in }_{R}\ \mathbb {Z}_p[\chi ]$ such that $f(0)=c$.

    Then, it computes \begin{align*} \sigma &=H_1(E^{c}),\ C_0=g_1^{c},\ C_1=g^{r}\ mod \ N^2, \\ C_2&=\left\lbrace ct_i=h_i^{r}\cdot (1+N\sigma x_i) \ mod \ N^2\right\rbrace _{i\in \left[1,n\right]}, \\ C_3&=\left\lbrace \left(c_{i,1},c_{i,2}\right)=\left(A^{f(i)}A_{i}^{-a_i},g_1^{a_i}\right)\right\rbrace _{i\in \left[1,\left|U\right|\right]},\\ vk&=H_2(ct_1), \ vk_1=g^{\sigma }\ mod \ N^2. \end{align*} View SourceRight-click on figure for MathML and additional features. Finally, it sets $C_x=\left(C_0,C_1,C_2,C_3\right)$ and $VK=\left(VK_1,VK_2,VK_3\right)=\left(vk,vk_1,C_1\right)$, stores the ciphertext $C_x$ in the cloud server and makes the verification key $VK$ public.

  • Query($y,msk,U^{\prime }$): On input $y=(y_1,\ldots,y_n)$, the master secret key $msk$ and the attribute set $U^{\prime }$, this process consists of the below two phases.

    1) Secret key generation. KGC chooses the values $\alpha \ {\in }_{R}\ \mathbb {Z}_{N}$ and $t\ {\in }_{R}\ \mathbb {Z}_p$ to compute \begin{align*} &pk_1=C_1^{\alpha }\ mod\ N^2,\ sk_{0,0}=h A^{t},\ sk_{0,1}=g_1^{t}, \\ &sk=\left\langle s,y\right\rangle +\alpha,\ \left\lbrace sk_i=A_i^{t}\right\rbrace _{i\in U^{\prime }}. \end{align*} View SourceRight-click on figure for MathML and additional features. It sets $sk_y=\left(sk, sk_{0,0}, sk_{0,1}, \left\lbrace sk_i\right\rbrace _{i\in U^{\prime }}\right),$ sends the secret key $sk_y$ to DU and makes the public information $pk_1$ public.

    2) Evaluation key generation. DU chooses the values $\xi _1 \ {\in }_{R}\ \mathbb {Z}_{N}$ and $\xi _2 \ {\in }_{R}\ \mathbb {Z}_{p}^{\ast }$ to compute \begin{align*} &pk_2=C_1^{\xi _1}\ mod\ N^2, \ sk_{0,0}^{\prime }=sk_{0,0}^{\xi _2},\ sk^{\prime }_{0,1}=sk_{0,1}^{\xi _2}, \\ &sk^{\prime }=sk+\xi _1,\ \left\lbrace sk^{\prime }_i= sk_i^{\xi _2}\right\rbrace _{i\in U^{\prime }}. \end{align*} View SourceRight-click on figure for MathML and additional features. Then, it sets \begin{equation*} \pi =\xi _2,\ EK_y=\left(y, sk^{\prime }, sk^{\prime }_{0,0}, sk^{\prime }_{0,1}, \left\lbrace sk^{\prime }_i\right\rbrace _{i\in U^{\prime }}\right), \end{equation*} View SourceRight-click on figure for MathML and additional features. stores the retrieving key $\pi$, makes the public information $pk_2$ public and sends the evaluation key $EK_y$ to CS.

  • Compute$(pk_1,pk_2,EK_y,C_x)$: On input the public information $pk_1$ and $pk_2$, the evaluation key $EK_y$ and the ciphertext $C_x$, CS computes \begin{align*} &\omega _1=\frac{e\left(C_0,sk^{\prime }_{0,0}\right)}{\prod _{i\in U^{\prime }}\left(e\left(c_{i,1},sk_{0,1}^{\prime }\right)e\left(c_{i,2},sk^{\prime }_i\right)\right)^{\Delta _{i,U^{\prime }}(0)}}, \\ &\omega _2=pk_1\cdot pk_2\cdot \prod _{i=2}^{n}ct_i^{y_i}\ mod\ N^2,\\ &\omega _3=ct_1^{y_1}\omega _2/ C_1^{sk^{\prime }}\ mod\ N^2. \end{align*} View SourceRight-click on figure for MathML and additional features.

    Then, it sets $P=\left(P_1,P_2\right)=\left(ct_1,\omega _2\right)$, and sends the intermediate result $I=\left(\omega _1,\omega _3\right)$, the proof $P$ to DU.

  • Recover($I,sk_y,VK,P$): On input the intermediate result $I$, the secret key $sk_y$, the evaluation key $VK$, the proof $P$, DU computes the following values with the aid of KGC who can compute the inverse in $\mathbb {Z}_N^{\ast }$ (i.e., $\omega _3^{\omega _4^{-1}}$, where $\omega _4$ is computed by DU) \begin{equation*} \omega _4=H_1\left(\omega _1^{\pi ^{-1}}\right),\ \omega _5=\frac{1}{N}\left(\left(\omega _3^{\omega _4^{-1}}-1\right)\ mod \ N^2\right). \end{equation*} View SourceRight-click on figure for MathML and additional features. It can verify the final result by computing \begin{align*} &H_2\left(P_1\right)\overset{?}{=}VK_1, \tag{2} \end{align*} View SourceRight-click on figure for MathML and additional features. \begin{align*} &g^{\omega _4}\ mod\ N^2\overset{?}{=} VK_2,\tag{3} \end{align*} View SourceRight-click on figure for MathML and additional features. \begin{align*} &P_1^{y_1} P_2\ mod\ N^2\overset{?}{=} VK_3^{sk^{\prime }}\left(1+N\right)^{\omega _4 \omega _5}\ mod\ N^2. \tag{4} \end{align*} View SourceRight-click on figure for MathML and additional features. If the Equations (2), (3) and (4) hold at the same time, the result $\omega _5$ is correct, and DU accepts it as $\left<x,y\right>$. Otherwise, DU rejects it.

Remark 1 (The discussion about access control over the computation and the data user).

As is introduced before, the security of inner product functional encryption requires that the decryptor can use the secret key regarding one vector to decrypt the encrypted vector to obtain the inner product of these two vectors, and nothing else. This property is used in this OIPFE-ACED scheme to not only preserve the privacy for outsourced vector, but also restrict the computation on these outsourced vectors to be inner product. In order to implement the access control over data user, we adopt the technique introduced in [39] to hide the random value $c$ that is a crucial component to obtain the actual inner product value $\left<x,y\right>$ from the intermediate result $I$. This technique guarantees that the value $c$ can be recovered for computing $\omega _1$ only in the case when the data user's attribute set $U^{\prime }$ satisfies the threshold condition $\left|U\cap U^{\prime }\right|\geq d$. If the result is correctly computed, it can pass the verification procedures implemented by Equations (2), (3) and (4). Nevertheless, if $\left|U\cap U^{\prime }\right|< d$, the data users will fail to obtain the value $c$ in such a way that they cannot recover the actual inner product value. And this value cannot pass the verification procedures. This is because the polynomial about variate $\chi$ is contained in the result, which makes the result meaningless. In this case, the illegal data users will lose their motivation to ask cloud server to compute inner product on the outsourced data, where they need to pay for the service provided by cloud server.

SECTION 5

Security Analysis

5.1 The Security Analysis for Ada-IPFE Scheme

In this section, we give the security analysis for Ada-IPFE scheme from the correctness, the adaptive security, the master secret key hiding, the standard consistency constraint and the encrypted vector hiding.

5.1.1 Correctness of Ada-IPFE Scheme

The intuitive sense of the correctness is that the final result obtained by the decryptor is $\left<x,y\right>$ for $x$ and $y$ if the procedures are honestly executed. The proposed Ada-IPFE scheme is correct. Formally, we have the following theorem.

Theorem 1.

The proposed Ada-IPFE scheme is correct.

Proof.

If all of the participating parties honestly execute the procedures of Ada-IPFE scheme, we can obtain the following results: \begin{align*} \sigma &=\left(pk_2^{c}\ mod\ N^2\right) mod\ N=\left(g^{\beta c}\ mod \ N^2\right)mod\ N,\tag{5} \end{align*} View SourceRight-click on figure for MathML and additional features. \begin{align*} \omega _1&=\left(\left(C_2\cdot g^{C_3}\right)^{\beta \cdot C_0^{-1}\ mod\ N}mod\ N^2\right)mod\ N \\ &=\left(g^{\beta c}\ mod \ N^2\right)\ mod\ N =\sigma, \\ \omega _2&=\frac{\left(C_1^{(\beta -sk)\ mod\ N} C_4\left(\prod _{i=1}^{n}ct_i^{y_i}\right)^{\omega _1^{-1}}-1\right) mod \ N^2}{N}\\ &=\frac{\left(N\sum _{i=1}^{n} x_iy_i\right)\ mod \ N^2}{N}.\tag{6} \end{align*} View SourceRight-click on figure for MathML and additional features. $N\sum _{i=1}^{n} x_iy_i$ is less than $N^2$ since we assume that $x$ and $y$ respectively satisfies $\left\Vert x\right\Vert \leq X$, $\left\Vert y\right\Vert \leq Y$ and $X\cdot Y < N$ in the beginning of Section 4. We can obtain \begin{equation*} \omega _2=\frac{N\sum _{i=1}^{n} x_iy_i}{N}=\sum _{i=1}^{n} x_iy_i. \tag{7} \end{equation*} View SourceRight-click on figure for MathML and additional features. Therefore, the proposed Ada-IPFE scheme is correct.

5.1.2 The Adaptive Security of Ada-IPFE Scheme

The security of Ada-IPFE scheme states that given a ciphertext of the vector $x$, the only information revealed by the secret key related to the vector $y$ is the inner product $\left<x,y\right>$. Specifically, no $\mathcal {A}$ can distinguish the encryption of $x_0$ from that of $x_1$ even with the information of the adaptively chosen secret keys $sk_{y^{(1)}},\ldots,sk_{y^{(l_1+l_2)}}$ with the condition that $\left<x^{(0)},y^{(i)}\right>=\left<x^{(1)},y^{(i)}\right>$ for all $i\in \lbrace 1,\ldots,l_1+l_2\rbrace$. The adaptive security allows $\mathcal {A}$ to have access to the system public parameters, and query series of secret keys before choosing the challenge vectors $x_0$ and $x_1$. The Ada-IPFE scheme achieves the adaptive security. Formally, we have the following theorem.

Theorem 2.

The proposed Ada-IPFE scheme is adaptively secure under the DCR assumption.

Proof.

The adaptive security of Ada-IPFE scheme is proved by series of games. This proof begins with a game which is same as the game $Exp_{\mathcal {A},Ada-IPFE}^{AdpSec}$ described in Definition 7. Specifically, this game takes as input the vector $x_\mu$ where $\mu \ {\in }_{R}\ \lbrace 0,1\rbrace$. In the last game, $\mu$ is information-theoretically hidden from $\mathcal {A}$'s view.

Game 0. In this game, the master public key $mpk=(g,\left\lbrace h_i\right\rbrace _{i\in \left[1,n\right]}, N, X)$ is sent to $\mathcal {A}$ where $h_i=g^{s_i}\ mod \ N^2$ and $s_i\ {\in }_{R} \mathcal {D}_{\mathbb {Z,\delta }}$. In the challenge phase, $\mathcal {A}$ chooses the vectors $x^{(i)}=(x_{1}^{(i)},\ldots,x_{n}^{(i)})$ for all $i\in \lbrace 0,1\rbrace$ with the condition that $\Vert x^{(i)}\Vert \leq X$, and then receives the encryption $C_{x^{(\mu)}}$ for one bit $\mu \ {\in }_{R}\ \lbrace 0,1\rbrace$. After this, $\mathcal {A}$ outputs its guess $\mu ^{\prime }$ based on its knowledge. We denote as $\mathcal {S}_0$ the case of $\mu ^{\prime }=\mu$. To avoid the trivial case that $\mathcal {A}$ always correctly guesses $\mu$, the condition $\left<x^{(0)},y\right>=\left<x^{(1)},y\right>$ over $\mathbb {Z}$ should be satisfied for the vector $y$ submitted by $\mathcal {A}$ to query the secret key.

Game 1. This game is the same as Game 0 except that the encryption of the challenge vector $x^{(\mu)}$ is modified. Specifically, $\mathcal {C}$ first chooses $\rho _0\ {\in }_{R}\ \mathbb {Z}^{\ast }_N$ and computes \begin{equation*} \rho =\rho _0^N\ mod\ N^2. \tag{8} \end{equation*} View SourceRight-click on figure for MathML and additional features. Then, it uses the master secret key $msk=(s,Y)$ to compute the ciphertext components $C_0$, $C_2$ and $C_3$ as in Game 0, and the rest components are computed as follows: \begin{align*} C_1&=\rho ^{2}\ mod\ N^{2}, \ C_4=C_1^{\alpha }\ mod \ N^2,\tag{9} \end{align*} View SourceRight-click on figure for MathML and additional features. \begin{align*} C_5&=\left\lbrace ct_i=C_1^{s_i} (1+N\sigma)^{x^{(\mu)}_i}\ mod \ N^{2}\right\rbrace _{i\in [1,n]}. \tag{10} \end{align*} View SourceRight-click on figure for MathML and additional features. Because $C_1$ is the perfectly uniform in the subgroup of the 2Nth residues, the challenge ciphertext $C_{x^{(\mu)}}$ has the same distribution as in Game 0 . So we have \begin{equation*} \left|Pr[S_1]-Pr[S_0]\right|\leq \frac{1}{2^{\lambda }}. \tag{11} \end{equation*} View SourceRight-click on figure for MathML and additional features. Game 2. This game is the same as Game 1 except that the encryption of the challenge vector $x^{(\mu)}$ is different from that in Game 1. $\mathcal {C}$ chooses $\rho \ {\in _{R}}\ \mathbb {Z}^{\ast }_{N^2}$ and computes $C_1=\rho ^2\ mod\ N^2.$ The rest ciphertext components are computed as in Game 1. If the DCR assumption holds, the ciphertexts in Game 1 and Game 2 are indistinguishable from $\mathcal {A}$'s view. So we can obtain that \begin{equation*} \left|Pr[S_2]-Pr[S_1]\right|\leq Adv_{\mathcal {A}}^{\text{DCR}}(\lambda). \tag{12} \end{equation*} View SourceRight-click on figure for MathML and additional features. Game 3. This game is the same as Game 2 except that the encryption of the challenge message $x^{(\mu)}$ is different from that in Game 2. $\mathcal {C}$ chooses $a_\rho \ {\in _{R}}\ \mathbb {Z}_N^{\ast }$ and $r_\rho \ {\in _{R}}\ \lbrace 0,\ldots,\lfloor \frac{N}{4}\rfloor \rbrace $, then it computes $C_1=g^{r_\rho }\cdot (1+Na_\rho)\ mod \ N^2.$ And the rest ciphertext components are computed as in Game 1. Clearly, the statistical distance between the distribution of $C_1$ in Game 3 and in Game 2 is smaller than $\frac{1}{2^{\lambda }}$. So we can obtain \begin{equation*} \left|Pr[S_3]-Pr[S_2]\right|\leq \frac{1}{2^{\lambda }}. \tag{13} \end{equation*} View SourceRight-click on figure for MathML and additional features. In Game 3, for every $i\in \lbrace 1,\ldots,n\rbrace$ \begin{equation*} ct_i=h_i^{r_\rho }(1+\sigma N)^{(x^{(\mu)}_{ i}+a_{\rho }\cdot s_i)mod / N}\ mod \ N^2. \tag{14} \end{equation*} View SourceRight-click on figure for MathML and additional features. Next, we will prove that Equation (14) statistically hides the bit $\mu \ {\in }_{R}\ \lbrace 0,1\rbrace$. So we can obtain In order to prove the above claim, we consider the vector \begin{equation*} x=(x_1,\ldots,x_n)=\frac{1}{d} \left(x^{(1)}-x^{(0)}\right), \tag{15} \end{equation*} View SourceRight-click on figure for MathML and additional features. where $d=gcd (x_{1}^{(1)}-x_{1}^{(0)},\ldots,x_{n}^{(1)}-x_{n}^{(0)})$. For the inherent limitation of the inner product functional encryption, all of the legal secret key queries regarding the vector $y\in \mathbb {Z}^{n}$ must be in the lattice \begin{equation*} \lbrace y\in \mathbb {Z}^{n}|\left<x,y\right>=0\rbrace . \tag{16} \end{equation*} View SourceRight-click on figure for MathML and additional features. For simplicity, we assume the first $n_0$ entries of the vector $x$ are zeroes, whereas the rest entries are non-zeroes. We could construct the following matrix \begin{equation*} Y_{top}=\begin{pmatrix}E_{n_0}& O\\ O & D\\ \end{pmatrix}\in \mathbb {Z}^{(n-1)\times n}, \tag{17} \end{equation*} View SourceRight-click on figure for MathML and additional features. where $E_{n_0}$ is an identity matrix over $\mathbb {Z}^{n_0\times n_0}$ and \begin{equation*} D=\begin{pmatrix}-x_{n_0+2}& x_{n_0+1}& & & \\ & -x_{n_0+3}& x_{n_0+2}& & \\ & & \ddots & \ddots & \\ & & & -x_{n}&x_{n-1} \\ \end{pmatrix}. \end{equation*} View SourceRight-click on figure for MathML and additional features. Clearly, the rows of the matrix $Y_{top}$ could be seen as a basis of the full-dimension sublattice resulting from Equation (16). Furthermore, we know $\left\Vert x\right\Vert ^2< N$ and $gcd (\left\Vert x\right\Vert ^2, N)=1$.

We define the matrix $Y=\begin{pmatrix}Y_{top}\\ x \end{pmatrix}\in \mathbb {Z}^{n\times n}.$ For $\left\Vert x\right\Vert ^2<N$, the determinant of $Y$ is non-zero over $\mathbb {Z}_{N}$ unless this determinant reveals a non-trivial factor of $N$.

For all $i \in \lbrace 1,\ldots, n\rbrace$, the Equation (14) information-theoretically reveals the following vector: \begin{align*} z^{(\mu)}&=\left(\left(x_{ 1}^{(\mu)}+a_{\rho } s_1\right)mod\; N, \ldots, \left(x_{ n}^{(\mu)}+a_{\rho } s_n\right)mod / N\right) \\ &=\left(x^{(\mu)}+a_{\rho }\cdot s\right)\ mod\ N. \tag{18} \end{align*} View SourceRight-click on figure for MathML and additional features. Next, we will show that $z^{(\mu)}$ is independent of $\mu \in \lbrace 0,1\rbrace$ from the view of $\mathcal {A}$. Based on this, we could obtain that $Y\cdot (z^{(\mu)})^{T} \in \mathbb {Z}_{N}^{n}$ is independent of $\mu \in \lbrace 0,1\rbrace$. Given the condition that $Y_{top}\cdot x^{T}=0$, we obtain \begin{equation*} Y_{top}\cdot \left(z^{(\mu)}\right)^{T}\ mod \ N \end{equation*} View SourceRight-click on figure for MathML and additional features. \begin{align*} &=\left(Y_{top}\cdot \left(x^{(\mu)}\right)^{T}+\;a_{\rho }\cdot Y_{top}\cdot s^{T}\right)\ mod \ N \\ &=a_{\rho }\cdot Y_{top}\cdot s^{T}\ mod \ N. \tag{19} \end{align*} View SourceRight-click on figure for MathML and additional features.

The Equation (19) implies that $Y_{top}\cdot z_{\mu }^{T} \in \mathbb {Z}_{\tilde{p}}^{n-1}$ is independent of $\mu \in \lbrace 0,1\rbrace$. We also need to show that $x\cdot \left(z^{(\mu)}\right)^{T}$ is also independent of $\mu \in \lbrace 0,1\rbrace$. Clearly \begin{equation*} Y_{top} \left(z^{(\mu)}\right)^{T}mod / N=\left(\left<x,x^{(\mu)}\right>+a_{\rho } \left<x,s\right>\right)mod \ N. \tag{20} \end{equation*} View SourceRight-click on figure for MathML and additional features. We assume that the information which $\mathcal {A}$ can infer about $s=(s_1,\ldots,s_n)$ is absolutely determined by $Y_{top}\cdot s^{T}\in \mathbb {Z}^{n-1}$. Let $s^{(0)}=(s_{1}^{(0)},\ldots,s_{n}^{(0)})$ be an arbitrary vector such that $Y_{top}\cdot \left(s^{(0)}\right)^{T}=Y_{top}\cdot s^{T}\ \text{and} \ h_i=g^{s_{i}^{(0)}}\ mod \ N^2$ for all $i \in \lbrace 1,\ldots,n\rbrace$. For $\mathcal {A}$'s view, the distribution of $s$ is $s^{(0)}+\mathcal {D}_{\Lambda,\delta,-s^{(0)}}$ where \begin{equation*} \Lambda =\lbrace t\in \mathbb {Z}^{n}|Y_{top}\cdot t=O\ \text{and}\ t=O\ mod\ p^{\prime }q^{\prime }\rbrace . \tag{21} \end{equation*} View SourceRight-click on figure for MathML and additional features. Clearly, $\Lambda$ is the lattice $(p^{\prime }q^{\prime })\cdot \mathbb {Z}\cdot x$. So the distribution of the inner product $\left<s,x\right>$ is $\left<s^{(0)},x\right>+\mathcal {D}_{(p^{\prime }q^{\prime })\left\Vert x\right\Vert ^2\cdot \mathbb {Z}, \left\Vert x\right\Vert \delta,-c},$ where $c=\left<s^{(0)},y\right>\in \mathbb {Z}$. Based on the Lemma 8 in the full version of [19], the distance between $\left<s,x\right>\ mod \ N$ and the uniform distribution over $((p^{\prime }q^{\prime })\left\Vert x\right\Vert ^{2}\cdot \mathbb {Z})/((p^{\prime }q^{\prime })\left\Vert x\right\Vert ^{2}\cdot (N\mathbb {Z}))\cong \mathbb {Z}_N$ is within $\frac{1}{2^{\lambda }}$ when \begin{align*} &\left|(p^{\prime }q^{\prime })\left\Vert x\right\Vert ^{2}\cdot N\right|<N^2\left\Vert x\right\Vert ^2,\ gcd(p^{\prime }q^{\prime }\left\Vert x\right\Vert ^2,N)=1, \\ &\left\Vert x\right\Vert ^2<N,\ \ \ \sigma >\lambda ^{\frac{1}{2}}N^{\frac{5}{2}}. \end{align*} View SourceRight-click on figure for MathML and additional features.

Because $a_{\rho }$ is invertible in $\mathbb {Z}_N$ with the negligible probability, the right hand of the Equation (20) statistically hides $\left<x,x^{(\mu)}\right>\ mod\ N$. We can obtain \begin{equation*} \left|Pr[S_0]-\frac{1}{2}\right|\leq Adv_{\mathcal {A}}^{\text{DCR}}(\lambda)+\frac{1}{2^{\lambda -1}}. \tag{22} \end{equation*} View SourceRight-click on figure for MathML and additional features. If the DCR assumption holds, $\left|Pr[S_0]-\frac{1}{2}\right|$ is negligible.

5.1.3 The Master Secret Key Hiding of Ada-IPFE Scheme

In the Ada-IPFE scheme, the master secret key consists of a vector $s=(s_1,\ldots,s_n)$ and a bound parameter $Y$. We do not consider the revealing of $Y$, since it is kept as a secret value by the decryptor and no longer involved in the subsequent operations. However, thanks to the linearity of inner product, the crucial component $s$ could be recovered by solving a system of linear equations in the existing works. The master secret key hiding property requires that $s$ should be hidden all the time. The Ada-IPFE scheme achieves this property, and we have the following theorem.

Theorem 3.

The proposed Ada-IPFE scheme is master secret key hiding.

Proof.

In order to prove this theorem, we will show that $\mathcal {A}$ can recover the master secret key with We assume that several decryptors are controlled by $\mathcal {A}$. The details are described as follows.

  • $\mathbf {Setup.}$ $\mathcal {C}$ produces the key pair $\left(msk,mpk\right)$ by running $\mathbf {Setup}(1^{\lambda }, 1^n,X,Y)$, where $msk=\left(s,Y\right)=\left(\left(s_1,\ldots,s_n\right), Y\right)$ and $mpk=(g,\left\lbrace h_i\right\rbrace _{i\in \left[1,n\right]}, N, X)$. It sends $mpk$ to $\mathcal {A}$.

  • $\mathbf {Query.}$ $\mathcal {A}$ adaptively chooses the vectors $y^{(1)},\ldots,y^{(l)}$ for $\mathcal {C}$. $\mathcal {C}$ runs $\mathbf { KeyGen}(y^{(i)},msk)$ to generate $sk^{(i)}=\left<s,y^{(i)}\right>+\;\alpha ^{(i)}+\beta ^{(i)}$ \begin{equation*} pk_1^{(i)}= g^{\alpha ^{(i)}}mod\ N^2,\ pk_2^{(i)}=g^{\beta ^{(i)}}mod\ N^2, \tag{23} \end{equation*} View SourceRight-click on figure for MathML and additional features. where $\alpha ^{(i)},\beta ^{(i)}\ {\in }_{R}\ \mathbb {Z}_{N}$. It sends the following items to $\mathcal {A}$, $\lbrace sk_{y^{(i)}}=\left(\beta ^{(i)},sk^{(i)}\right)\rbrace _{i\in [1,l]}$ and $\lbrace pk_{y^{(i)}}=(pk_1^{(i)},pk_2^{(i)})\rbrace _{i\in [1,l]}$.

  • $\mathbf {Guess.}$ $\mathcal {A}$ outputs its guess of the master secret key $msk^{\ast }=\left(s^{\ast },Y^{\ast }\right)=\left(\left(s_1^{\ast },\ldots,s_n^{\ast }\right), Y^{\ast }\right)$. $\mathcal {A}$ can obtain the vector $s^{\ast }$ by below two ways.

    Way 1: $\mathcal {A}$ chooses a value $v\in \mathcal {D}_{\mathbb {Z},\delta }$ to compute $g^{v}$, and then match it with $\left\lbrace h_i\right\rbrace _{i\in \left[1,n\right]}$ to determine whether $v$ is equal to $s_i$ for some $i\in \left[1,n\right]$. This is a brute-force way that is usually considered as an infeasible strategy to attack one scheme.

    Way 2: $\mathcal {A}$ solves the following system of linear equations where $l\geq n$ to obtain $s$ under the condition that $y^{\left(1\right)}$, $\ldots$, $y^{\left(l\right)}$ are linearly independent \begin{equation*} \left\lbrace \begin{array}{l}\left<s,y^{(1)}\right>+\;\alpha ^{(1)}+\beta ^{(1)}=sk^{(1)},\\ \qquad \cdots \\ \left<s,y^{(l)}\right>+\;\alpha ^{(l)}+\beta ^{(l)}=sk^{(l)}.\\ \end{array} \right. \tag{24} \end{equation*} View SourceRight-click on figure for MathML and additional features. Next, we analyze the successful probability of this way.

In order to obtain the vector $s$ by Way 2, $\mathcal {A}$ needs to determine the random values $\alpha ^{\left(i\right)}$ and $\beta ^{\left(i\right)}$ $\in$ $\mathbb {Z}_{N}$ for all $i\in \left[1,l\right]$. We denote the event of $\mathcal {A}$ correctly obtaining $\alpha ^{\left(i\right)}$ and $\beta ^{\left(i\right)}$ as $\Gamma _i$ and $\Lambda _i$, respectively. Thanks to the randomness of $\alpha ^{\left(i\right)}$ and $\beta ^{\left(i\right)}$, we can obtain $Pr\left[\Gamma _i\right]=Pr\left[\Lambda _i\right]=\frac{1}{N}.$ So, we have \begin{align*} Pr\left[s=s^{\ast }\right]&=Pr\left[\Gamma _1\wedge \cdots \wedge \Gamma _l\wedge \Lambda _1\wedge \cdots \wedge \Lambda _l\right]\tag{25} \end{align*} View SourceRight-click on figure for MathML and additional features. \begin{align*} &=\prod _{i=1}^{l}Pr\left[\Gamma _i\right]Pr\left[\Lambda _i\right]\tag{26} \end{align*} View SourceRight-click on figure for MathML and additional features. \begin{align*} &=\left(\frac{1}{N}\right)^{2l}. \tag{27} \end{align*} View SourceRight-click on figure for MathML and additional features. The Equation (25) can be derived from Equation (26), because the processes of choosing the values $\alpha ^{\left(i\right)}$ and $\beta ^{\left(i\right)}$ are independent from each other. This implies that $\mathcal {A}$ can correctly recover the vector $s$ with the probability $\left(\frac{1}{N}\right)^{2l}$ that is negligible. So, the proposed Ada-IPFE scheme is master secret key hiding

5.1.4 Standard Consistency Constraint of Ada-IPFE Scheme

The standard consistency constraint states that the public key $pk_y$ is bonded to the secret key $sk_y$, so that the ciphertext $C_x$ generated with $pk_y$ can only be decrypted by $sk_y$ to reveal the inner product $\left<x,y\right>$, and the ciphertext $C_x$ generated with $pk_y$ cannot be decrypted by $sk_{y^{\prime }}$ to reveal the inner product $\left<x,y^{\prime }\right>$. However, the inner product $\left<x^{\prime },y\right>$ is allowed to reveal if the ciphertext for the vector $x^{\prime }$ is generated with $pk_y$. Clearly, the standard consistency constraint can prevent the encrypted vector $x$ from being recovered. Our Ada-IPFE scheme guarantees the standard consistency constraint. We have the following theorem.

Theorem 4.

The proposed Ada-IPFE scheme guarantees the standard consistency constraint.

Proof.

We assume that the inner product $\left<x,\hat{y}\right>$ is revealed by the another secret key $sk_{\hat{y}}$ where the ciphertext $C_x$ is generated by the public key $pk_y$. For the vector $y=\left(y_1,\ldots,y_n\right)$, the secret key is $sk_y=\left(\beta, sk\right)$ and the public key is $pk_y=\left(pk_1,pk_2\right)$ where \begin{align*} pk_1&=g^{\alpha }\ mod\ N^2,\ pk_2=g^{\beta }\ mod\ N^2, \ \alpha, \beta \ {\in }_{R}\ \mathbb {Z}_{N},\\ sk&=\left<s,y\right>+\;\alpha +\beta . \end{align*} View SourceRight-click on figure for MathML and additional features. Correspondingly, the ciphertext for the vector $x$ is $C_x=\left(C_0,C_1,C_2,C_3,C_4,C_5\right)$ where $a{\in }_{R}\ \mathbb {Z}_{N}^{\ast }$, $b$, $c\ {\in }_{R}\ \mathbb {Z}_{N}$ \begin{align*} \sigma &=\left(pk_2^{c}\ mod\ N^2\right)\ mod\ N,\ C_0=a,\ C_1=g^{r}\ mod \ N^2, \\ C_2&=g^{b}\ mod \ N^2, \ C_3=(c\cdot a-b)\ mod \ N,\\ C_4&=pk_1^{r}\ mod \ N^2,\ r\ {\in }_{R}\ \bigg\lbrace 0,\ldots,\bigg\lfloor \frac{N}{4}\bigg\rfloor \bigg\rbrace,\ \\ C_5&=\left\lbrace ct_i=h_i^{r}(1+N\sigma x_i) \ mod \ N^2\right\rbrace _{i\in \left[1,n\right]}. \end{align*} View SourceRight-click on figure for MathML and additional features. For the vector $\hat{y}=\left(\hat{y}_1,\ldots,\hat{y}_n\right)$, the secret key is $sk_{\hat{y}}=(\hat{\beta }, \hat{sk})$ and the public key is $\hat{pk}=(\hat{pk}_1,\hat{pk}_2)$ where \begin{align*} &\hat{pk}_1=g^{\hat{\alpha }}\ mod\ N^2, \ \hat{pk}_2=g^{\hat{\beta }}\ mod\ N^2, \ \hat{\alpha }, \hat{\beta }\ {\in }_{R}\ \mathbb {Z}_{N}, \\ & \hat{\alpha }\ne \alpha,\ \hat{\beta }\ne \beta,\ \hat{sk}=\left<s,\hat{y}\right>+\;\hat{\alpha }+\hat{\beta }. \end{align*} View SourceRight-click on figure for MathML and additional features. To obtain the inner product $\left<x,\hat{y}\right>$ by the secret key $sk_{\hat{y}}$, we need to compute \begin{align*} \hat{\omega }_1^{-1}&=\left(\left(C_2\cdot g^{C_3}\right)^{\hat{\beta }\cdot C_0^{-1}\ mod\ N}mod\ N^2\right)^{-1}mod\ N \\ &=\left(g^{\hat{\beta } c}\ mod\ N^2\right)^{-1}\ mod\ N,\\ \hat{ \omega }_2&=\left(\left(C_1^{(\hat{\beta }-\hat{sk})\ mod\ N} C_4 \prod _{i=1}^{n}ct_i^{\hat{y}_i}\right)^{\hat{\omega }_1^{-1}}-1\right)mod \ N^2 \\ &=\left(g^{\hat{\omega }_1^{-1}r(\hat{\alpha }-\alpha)}+N\hat{\omega }_1^{-1}\sigma g^{\hat{\omega _1}^{-1}r(\hat{\alpha }-\alpha)}\left<x,\hat{y}\right>-1\right)mod \;N^2, \end{align*} View SourceRight-click on figure for MathML and additional features. we can obtain \begin{equation*} \left(g^{\hat{\omega }_1^{-1}r(\hat{\alpha }-\alpha)}-1\right)+N\hat{\omega }_1^{-1}\sigma g^{\hat{\omega _1}^{-1}r(\hat{\alpha }-\alpha)}\left<x,\hat{y}\right>=N\left<x,\hat{y}\right>, \end{equation*} View SourceRight-click on figure for MathML and additional features. which holds all the time. So the following holds all the time: \begin{equation*} \left\lbrace \begin{array}{l}g^{\hat{\omega }_1^{-1}r(\hat{\alpha }-\alpha)}-1=0,\\ N\hat{\omega }_1^{-1}\sigma g^{\hat{\omega _1}^{-1}r(\hat{\alpha }-\alpha)}\left<x,\hat{y}\right>=N\left<x,\hat{y}\right>.\\ \end{array} \right. \tag{28} \end{equation*} View SourceRight-click on figure for MathML and additional features. This implies that \begin{equation*} \left\lbrace \begin{array}{l}g^{\hat{\omega }_1^{-1}r(\hat{\alpha }-\alpha)}=1,\\ g^{(\beta -\hat{\beta })c}=1,\\ \end{array} \right. \tag{29} \end{equation*} View SourceRight-click on figure for MathML and additional features. holds all the time. Therefore, $\hat{\alpha }=\alpha$ and $\hat{\beta }=\beta$, which contradicts the condition that $\hat{\alpha }\ne \alpha$ and $\hat{\beta }\ne \beta$. So, the Ada-IPFE scheme guarantees the standard consistency constraint.

5.1.5 Encrypted Vector Hiding of Ada-IPFE Scheme

In the existing works, the encrypted vector $x$ can be recovered if several inner products $\left<x,y^{(1)}\right>,\ldots,\left<x,y^{(n)}\right>$ are allowed to reveal, where $y^{(1)},\ldots,y^{(n)}$ are linearly independent. The encrypted vector hiding requires that $x$ cannot be recovered in any case. The Ada-IPFE scheme can hide the encrypted vector. Formally, we have the following theorem.

Theorem 5.

The Ada-IPFE scheme is encrypted vector hiding.

Proof.

From Theorem 4, the Ada-IPFE scheme guarantees the standard consistency constraint, which indicates that the ciphertext of the vector $x$ is only qualified for one specific secret key. This avoids recovering $x$ by resolving the system of linear equations resulting from the $\left<x,y^{(1)}\right>,\ldots,\left<x,y^{(n)}\right>$, where $y^{(1)},\ldots,y^{(n)}$ are linearly independent. So, the Ada-IPFE scheme is encrypted vector hiding.

5.2 The Security Analysis for OIPFE-ACED Scheme

In this section, we give the security analysis of OIPFE-ACED scheme from the correctness, the outsourced vector privacy and the unforgeability.

5.2.1 Correctness of the OIPFE-ACED Scheme

The intuitive sense of the correctness is that the final result obtained by DU is $\left<x,y\right>$ for $x$ and $y$ if the procedures are honestly executed. The proposed OIPFE-ACED scheme is correct. Formally, we have the following theorem.

Theorem 6.

The proposed OIPFE-ACED scheme is correct.

Proof.

Let $\varphi _i\ \in \ \mathbb {Z}_p$ be the value such that $A_i=g_1^{\varphi _i}$ for $i\in \lbrace 1,\ldots,\left|U\right|\rbrace$. We can obtain the following results if the procedures are honestly executed and $\left|U\cap U^{\prime }\right|\geq d$ \begin{align*} \omega _1&=\frac{e\left(C_0,sk^{\prime }_{0,0}\right)}{\prod _{i\in U^{\prime }}\left(e\left(c_{i1},sk_{0,1}^{\prime }\right)e\left(c_{i2},sk^{\prime }_i\right)\right)^{\Delta _{i,U^{\prime }}(0)}} \\ &=e\left(g_1,g_1\right)^{\beta c\xi _2}, \tag{30} \end{align*} View SourceRight-click on figure for MathML and additional features. \begin{align*} \omega _2&=pk_1\cdot pk_2\cdot \prod _{i=2}^{n}ct_i^{y_i} mod\ N^2 \\ &=g^{r\alpha +r\xi _1+r\sum _{i=2}^{n}s_iy_i}\left(1+N\sigma \sum _{i=2}^{n} x_iy_i\right)\;mod\ N^2, \tag{31} \end{align*} View SourceRight-click on figure for MathML and additional features. \begin{align*} \omega _3&=ct_1^{y_1}\omega _2/ C_1^{sk^{\prime }}\ mod\ N^2 \\ &=\frac{g^{r\alpha +r\xi _1+r\sum _{i=1}^{n}s_iy_i}\left(1+N\sigma \sum _{i=1}^{n} x_iy_i\right)}{g^{r\sum _{i=1}^{n}s_iy_i+r\alpha +r\xi _1}} \;mod\ N^2 \\ &=\left(1+N\sigma \sum _{i=1}^{n}x_iy_i\right)\;mod \ N^2, \tag{32} \end{align*} View SourceRight-click on figure for MathML and additional features. \begin{align*} \omega _4&=H_1\left(\omega _1^{\pi ^{-1}}\right) \\ &=H_1\left(e\left(g_1,g_1\right)^{\beta c \xi _2\xi _2^{-1}}\right) \\ &=\sigma, \tag{33} \end{align*} View SourceRight-click on figure for MathML and additional features. \begin{align*} \omega _5&=\frac{1}{N}\left(\left(\omega _3^{\omega _4^{-1}}-1\right)\ mod \ N^2\right) \\ &=\frac{1}{N}\left(\left(N\sum _{i=1}^{n}x_iy_i\right)\ mod \ N^2\right). \tag{34} \end{align*} View SourceRight-click on figure for MathML and additional features. $N\sum _{i=1}^{n} x_iy_i$ is less than $N^2$ since we assume that $x$ and $y$ respectively satisfy $\left\Vert x\right\Vert \leq X$, $\left\Vert y\right\Vert \leq Y$ and $X\cdot Y < N$ in the beginning of Section 4, so we can obtain \begin{align*} \omega _5&=\frac{1}{N}\left(\left(N\sum _{i=1}^{n}x_iy_i\right)\ mod \ N^2\right) \\ &=\frac{1}{N}\cdot N\cdot \sum _{i=1}^{n}x_iy_i \\ &=\sum _{i=1}^{n}x_iy_i. \tag{35} \end{align*} View SourceRight-click on figure for MathML and additional features. It is obvious that Equations (2), (4) and (3) are satisfied.

5.2.2 The Outsourced Vector Privacy of OIPFE-ACED Scheme

The outsourced vector privacy is a very important issue in the OIPFE-ACED scheme. The basic requirement for the data storage in CS is that the privacy of the outsourced data should be preserved. More formally, we have the below theorem.

Theorem 7.

The OIPFE-ACED scheme achieves the outsourced vector privacy.

Proof.

The proposed OIPFE-ACED scheme is adapted from the proposed Ada-IPFE scheme. The outsourced vector is encrypted based on the proposed Ada-IPFE scheme. Since the proposed Ada-IPFE scheme achieves the adaptive security, it is difficult for $\mathcal {A}$ to distinguish the ciphertext is encrypted from which vector. Furthermore, the intermediate results are random from the view of CS, CS cannot obtain the additional useful information to break the vector privacy. In addition, the security of our Ada-IPFE scheme guarantees that DU with the qualified attributes can learn the desired inner product no more than the other information. So the OIPFE-ACED scheme achieves the outsourced vector privacy.

5.2.3 The Unforgeability of OIPFE-ACED Scheme

The unforgeability of OIPFE-ACED scheme states that the malicious CS cannot make DU accept the wrong inner product. To be more specific, the forged result by CS which is not equal to the desired inner product cannot pass the verification. Formally, we have the following theorem.

Theorem 8.

The OIPFE-ACED scheme achieves the unforgeability.

Proof.

When $\left|U\cap U^{\prime }\right|\geq d$, $\mathcal {A}$ can obtain more information from $\mathcal {C}$'s response that simulates the intermediate result returned by CS than that in the case $\left|U\cap U^{\prime }\right|< d$. This implies that if the OIPFE-ACED scheme achieves the unforgeability in the case $\left|U\cap U^{\prime }\right|\geq d$, it can also achieve the unforgeability in the case $\left|U\cap U^{\prime }\right|< d$. So, we just give this proof when $\left|U\cap U^{\prime }\right|\geq d$. In order to prove this theorem, we first assume that $\mathcal {A}$ can make $\mathcal {C}$ accept the forged result with a non-negligible probability $\widetilde{\epsilon }$, and then obtain the contradiction. Under this assumption, the details of interactions between $\mathcal {A}$ and $\mathcal {C}$ are described as follows, where the forged proof and forged result are denoted as $\widetilde{P}=(\widetilde{P}_1,\widetilde{P}_2)$ and $\widetilde{I}=\left(\widetilde{\omega }_1,\widetilde{\omega }_3\right)$, respectively.

  • $\mathbf {Setup.}$ $\mathcal {C}$ runs $\mathbf {Setup}(1^{\lambda }, 1^n,X,Y,U)$ to produce the master secret key $msk$ and the master public key $mpk$, where $msk=\left(s,h,Y \right)$ \begin{align*} & mpk=(g,\lbrace h_i\rbrace _{i\in \left[1,n\right]}, \lbrace A_i\rbrace _{i\in \left[1,\left|U\right|\right]}, e,\mathbb {G},\mathbb {G}_T,g_1,H_1,\\ &\quad \quad \quad \ \ H_2, A, E, N, X). \end{align*} View SourceRight-click on figure for MathML and additional features. Then, $\mathcal {C}$ sends $mpk$ to $\mathcal {A}$. However, $\mathcal {A}$ cannot learn $s$ from the master public key thanks to the master secret key hiding of underlying Ada-IPFE scheme. Furthermore, $h$ and $Y$ are both independent from the master public key. So, $\mathcal {A}$ is unable to learn master secret key from the master public key.

  • $\mathbf {Query\ phase.}$ $\mathcal {C}$ chooses a vector $x=\left(x_1,\ldots,x_n\right)$ to run $\mathbf {Store}(x,mpk,d)$ to produce the verification key $VK$ and the ciphertext $C_x$ for $\mathcal {A}$ as follows. $\mathcal {C}$ chooses $c\ {\in }_{R}\ \mathbb {Z}_{p}$, $r\ {\in }_{R}\ \lbrace 0,\ldots,\lfloor \frac{N}{4}\rfloor \rbrace$, the random values $\left\lbrace a_i\right\rbrace _{i\in [1,\left|U\right|]}$ from $\mathbb {Z}_p$ and a $(d-1)$-degree polynomial $f(\chi)\ {\in }_{R}\ \mathbb {Z}_p[\chi ]$ such that $f(0)=c$.

    It computes $\sigma =H_1(E^{c})$, $C_0=g_1^{c}$, $C_1=g^{r}mod\ N^2$ \begin{align*} C_2&=\left\lbrace ct_i=h_i^{r}\cdot (1+N\sigma x_i) \ mod \ N^2\right\rbrace _{i\in \left[1,n\right]}, \\ C_3&=\left\lbrace \left(c_{i,1},c_{i,2}\right)=\left(A^{f(i)}A_{i}^{-a_i},g_1^{a_i}\right)\right\rbrace _{i\in \left[1,\left|U\right|\right]}, \\ vk&=H_2(ct_1), \ vk_1=g^{\sigma }\ mod \ N^2. \end{align*} View SourceRight-click on figure for MathML and additional features. Finally, it sends the ciphertext $C_x=\left(C_0,C_1,C_2,C_3\right)$ and the verification key $VK=\left(VK_1,VK_2,VK_3\right)=\left(vk,vk_1,C_1\right)$ to $\mathcal {A}$. In this process, the security of underlying Ada-IPFE scheme can prevent $\mathcal {A}$ from learning $x$.

    After this, $\mathcal {A}$ adaptively chooses the vectors $y^{(1)}=(y^{(1)}_1,\ldots,y^{(1)}_n),\ldots,y^{(l)}=(y^{(l)}_1,\ldots,y^{(l)}_n)$ and the attribute set $U^{\prime }$ for $\mathcal {C}$. $\mathcal {C}$ runs $\mathbf {Query}(y^{(j)},msk,U^{\prime })$ for $j\in \lbrace 1,\ldots,l\rbrace$ to produce $(pk_1^{(j)},pk_2^{(j)},EK_{y^{(j)}})$ for $\mathcal {A}$ as follows. $\mathcal {C}$ chooses the values $\alpha ^{(j)}\ {\in }_{R}\ \mathbb {Z}_{N}$ and $t^{(j)}\ {\in }_{R}\ \mathbb {Z}_p$, $\xi _1^{(j)} \ {\in }_{R}\ \mathbb {Z}_{N}$ and $\xi _2^{(j)} \ {\in }_{R}\ \mathbb {Z}_{p}^{\ast }$ to compute \begin{align*} &pk_1^{(j)}=C_1^{\alpha ^{(j)}}\ mod\ N^2,\ pk_2^{(j)}=C_1^{\xi _1^{(j)}}\ mod\ N^2,\\ &sk_{0,0}^{\prime (j)}=\left(h A^{t^{(j)}}\right)^{\xi _2^{(j)}},\ sk_{0,1}^{\prime (j)}=\left(g_1^{t^{(j)}}\right)^{\xi _2^{(j)}}, \\ &sk^{\prime (j)}=\left\langle s,y^{(j)}\right\rangle +\alpha ^{(j)}+\xi _1^{(j)},\ \left\lbrace sk_i^{\prime (j)}=A_i^{t^{(j)}}\right\rbrace _{i\in U^{\prime }}. \end{align*} View SourceRight-click on figure for MathML and additional features. Then it sets \begin{equation*} EK_{y^{(j)}}=\left(y^{(j)},sk_{0,0}^{\prime (j)},sk_{0,1}^{\prime (j)},sk^{\prime (j)},\left\lbrace sk_i^{\prime (j)}\right\rbrace _{i\in U^{\prime }}\right). \end{equation*} View SourceRight-click on figure for MathML and additional features. Since the randomness of the values $\alpha ^{\left(j\right)}$, $t^{\left(j\right)}$, $\xi _1^{\left(j\right)}$ and $\xi _2^{\left(j\right)}$, the evaluation keys $sk_{0,0}^{\prime (j)}$, $sk_{0,1}^{\prime (j)}$ and $sk_i^{\prime (j)}$ are random from the view of $\mathcal {A}$. Although $U^{\prime }$ satisfies the condition that $\left|U\cap U^{\prime }\right|\geq d$, $\mathcal {A}$ cannot obtain the relevant actual inner product values thanks to the effect of secret value $\xi _2$. These can ensure that the vector $x$ is still secret for $\mathcal {A}$.

  • $\mathbf {Forgery.}$ $\mathcal {A}$ adaptively chooses a vector $y^{\ast }=\left(y_1^{\ast },\ldots,y_n^{\ast }\right)$ for $\mathcal {C}$. Then, $\mathcal {C}$ runs $\mathbf {Query}(y^{\ast },msk,U^{\prime })$ to produce $\left(pk_1^{\ast },pk_2^{\ast },EK_{y^{\ast }}\right)$ for $\mathcal {A}$ as follows. $\mathcal {C}$ chooses the values $\alpha ^{\ast }\ {\in }_{R}\ \mathbb {Z}_{N}$ and $t^{\ast }\ {\in }_{R}\ \mathbb {Z}_p$, $\xi _1^{\ast } \ {\in }_{R}\ \mathbb {Z}_{N}$ and $\xi _2^{\ast } \ {\in }_{R}\ \mathbb {Z}_{p}^{\ast }$ to compute \begin{align*} &pk_1^{\ast }=C_1^{\alpha ^{\ast }}\ mod\ N^2,\ pk_2^{\ast }=C_1^{\xi _1^{\ast }}\ mod\ N^2, \\ &sk_{0,0}^{\prime \ast }=\left(h A^{t^{\ast }}\right)^{\xi _2^{\ast }},\ sk_{0,1}^{\prime \ast }=\left(g_1^{t^{\ast }}\right)^{\xi _2^{\ast }}, \\ &sk^{\prime \ast }=\left\langle s,y^{\ast }\right\rangle +\alpha ^{\ast }+\xi _1^{\ast },\ \left\lbrace sk_i^{\prime \ast }=A_i^{t^{\ast }}\right\rbrace _{i\in U^{\prime }}. \end{align*} View SourceRight-click on figure for MathML and additional features. Then it sets \begin{equation*} EK_{y^{\ast }}=\left(y^{\ast },sk_{0,0}^{\prime \ast },sk_{0,1}^{\prime \ast },sk^{\prime \ast },\left\lbrace sk_i^{\prime \ast }\right\rbrace _{i\in U^{\prime }}\right). \end{equation*} View SourceRight-click on figure for MathML and additional features.

    $\mathcal {A}$ outputs its forged intermediate result $\widetilde{I}$ and the forged proof $\widetilde{P}$ for $\mathcal {C}$. Clearly, $sk_{0,0}^{\ast }$, $sk_{0,1}^{\ast }$ and $sk_i^{\ast }$ are also random from the view of $\mathcal {A}$.

Since we assume that $\mathcal {A}$ can make $\mathcal {C}$ accept the forged result with the non-negligible probability $\widetilde{\epsilon }$ in the beginning of this proof, the following equations hold with the probability $\widetilde{\epsilon }$ \begin{align*} &H_2\left(\widetilde{P}_1\right)=VK_1,\tag{36} \end{align*} View SourceRight-click on figure for MathML and additional features. \begin{align*} &g^{\widetilde{\omega }_4}\ mod\ N^2=VK_2,\tag{37} \end{align*} View SourceRight-click on figure for MathML and additional features. \begin{align*} &\widetilde{P}_1^{y_1}\widetilde{P}_2\ mod\ N^2= VK_2^{sk^{\prime }}\left(1+N\right)^{\widetilde{\omega }_4 \widetilde{\omega }_5}\ mod\ N^2, \tag{38} \end{align*} View SourceRight-click on figure for MathML and additional features. where $\widetilde{\omega }_4$ and $\widetilde{\omega }_5$ are the corresponding values resulting from $\widetilde{\omega }_1$ and $\widetilde{\omega }_3$. Since $H_2$ is a secure cryptographic hash function, it is resistant to the second-preimage attacks. This implies $\widetilde{P}_1=P_1$. Equation (37) implies that $\widetilde{\omega }_4=\sigma$. We can derive the below equation from Equation (38) with the non-negligible probability $\widetilde{\epsilon }$ \begin{equation*} P_1^{y_1}\widetilde{P}_2\ mod\ N^2= VK_2^{sk^{\prime }}\left(1+N\right)^{\sigma \widetilde{\omega }_5}\ mod\ N^2. \tag{39} \end{equation*} View SourceRight-click on figure for MathML and additional features. Let $P^{\ast }=\left(P_1^{\ast },P_2^{\ast }\right)$ and $I=\left(I_1^{\ast },I_2^{\ast }\right)$ be the correct proof and intermediate result corresponding to the vector $y^{\ast }$ in OIPFE-ACED scheme. Thanks to the correctness of OIPFE-ACED scheme, we can obtain the below equation with the non-negligible probability $\widetilde{\epsilon }$ \begin{equation*} P_1^{y_1}P_2^{\ast }\ mod\ N^2= VK_2^{sk^{\prime }}\left(1+N\right)^{\sigma \left<x,y^{\ast }\right>}\ mod\ N^2. \tag{40} \end{equation*} View SourceRight-click on figure for MathML and additional features.

Since $\mathcal {C}$ can compute $P_2^{\ast }=pk_1^{\ast }\cdot pk_2^{\ast }\cdot \prod _{i=2}^{n}ct_i^{y_i^{\ast }}\ mod\ N^2,$$\widetilde{P}_2$ should satisfies $\widetilde{P}_2=P^{\ast }_2$. Otherwise, $\mathcal {C}$ must reject the forged result. This implies that Equation (39) can be written as the below equation with the non-negligible probability $\widetilde{\epsilon }$ \begin{equation*} P_1^{y_1}P_2^{\ast }\ mod\ N^2= VK_2^{sk^{\prime }}\left(1+N\right)^{\sigma \widetilde{\omega }_5}\ mod\ N^2. \tag{41} \end{equation*} View SourceRight-click on figure for MathML and additional features. Combining Equations (40) and (41), we can obtain the below equation with the non-negligible probability $\widetilde{\epsilon }$ \begin{equation*} \left(1+N\right)^{\sigma \left(\left<x,y^{\ast }\right>-\widetilde{\omega }_5\right) }\ mod\ N^2=1. \tag{42} \end{equation*} View SourceRight-click on figure for MathML and additional features. We can obtain from Equation (42) that $\sigma \cdot \left(\left<x,y^{\ast}\right>-\widetilde{\omega }_5\right)=0$ holds with the non-negligible probability $\widetilde{\epsilon }$. Note that $H_1:\mathbb {G}_T\rightarrow \mathbb {Z}_N^{\ast }$ and $\sigma =H_1(E^{c})$, so $\sigma \ne 0$. This in turn implies that $\left<x,y^{\ast }\right>-\widetilde{\omega }_5=0$ holds with the non-negligible probability $\widetilde{\epsilon }$. However, $\widetilde{\omega }_5$ is the forged result corresponding to the assumption that $\mathcal {A}$ can make $\mathcal {C}$ accept the forged result with the non-negligible probability $\widetilde{\epsilon }$, so $\left<x,y^{\ast }\right>=\widetilde{\omega }_5$ holds with a negligible probability. This introduces a contradiction. Based on this contradiction, we can conclude that $\mathcal {A}$ cannot make $\mathcal {C}$ accept the forged result with a non-negligible probability, and only the correct result can pass the verification.

SECTION 6

Performance Analysis

In this section, we give the performance analysis of our proposed schemes, which includes functionality analysis and efficiency analysis. We first give the performance analysis for our proposed Ada-IPFE scheme, and then give the performance analysis for our proposed OIPFE-ACED scheme.

In order to obtain the experimental results, C programming language with the GMP-6.1.2 (GNU Multiple Precision Arithmetic Library-6.1.2), the PBC-0.5.14 (Pairing-Based Cryptography Library-0.5.14) and the CiFEr (Functional Encryption Library) are used. And all of the experimental evaluation results are obtained on the same machine with Intel(R) Core(TM) i7-8565U CPU @ 1.80 GHz 1.99 GHz and 8 GB RAM (7.85GB is available) running Ubuntu 18.04. When implementing the proposed schemes, the parameters of elliptic curve are (160,512).

6.1 Performance Analysis for Ada-IPFE Scheme

6.1.1 Functionality Analysis

In Table 2, we give the functionality comparisons for our Ada-IPFE scheme with existing works [16], [17], [18], [19], [21] in the public key setting, where different encryptors can generate ciphertexts for the same decryptor. The DDH-based IPFE scheme in [16] is the first concrete scheme for the novel idea of IPFE. In order to obtain the desired inner product, it needs to compute the expensive discrete logarithm in the decryption algorithm. So, this instantiation from ElGamal encryption is restricted to computing the inner product in a prescribed short interval, which makes this scheme not practical. This limitation also exists in other DDH-based schemes. To overcome this limitation, the DCR-based schemes, the LWE-based schemes and the schemes based on variants of DDH assumption are proposed. In these schemes, the desired inner product can be efficiently obtained in decryption algorithm, since they can avoid computing the expensive discrete logarithm. So, the short result interval does not need to be imposed on these IPFE schemes. In order to solve the issue regarding master secret key privacy for the vector that has $n$ components, the existing works such as [17], [19] have considered solving it over a subspace of $n$-dimension space that is generated from $n-1$ linearly independent vectors. The master secret key hiding over the total space (i.e., generated from $n$ linearly independent $n$-dimension vectors) and the encrypted vector hiding are not fully considered in the existing works.

TABLE 2 Functionality Comparisons for Ada-IPFE With Existing Works
Table 2- 
Functionality Comparisons for Ada-IPFE With Existing Works

6.1.2 Efficiency Analysis

In Table 3, we give the computation cost comparisons between work [19] and our Ada-IPFE scheme. We intend to show that our Ada-IPFE scheme achieves the stronger privacy guarantees at reasonable price of efficiency. Since the security of these schemes is based on the DCR assumption, it is more reasonable to compare our Ada-IPFE scheme with the scheme in [19] than with that in [16]. In this table, we denote an exponent operation, the operation of choosing a random value, a multiplication operation, an addition operation, a subtraction operation and inversion operation by $Exp$, $Rand$, $Mul$, $Add$, $Sub$ and $Inv$ in $\mathbb {Z}_{N^2}$, respectively. We also denote the operation of choosing a random value, a multiplication operation, an addition operation, a subtraction operation and an inversion operation by $rand$, $mul$, $add$, $sub$ and $inv$ in $\mathbb {Z}_{N}$, respectively.

TABLE 3 Computation Cost Comparisons for Ada-IPFE With the Scheme in [19]
Table 3- 
Computation Cost Comparisons for Ada-IPFE With the Scheme in [19]

In $\mathbf {Setup }$, these two schemes need to take the same actions to initialize the encryption system. In $\mathbf {KeyGen}$, our Ada-IPFE scheme needs to perform additional computations to achieve the desired privacy guarantees. We need to choose two random values to generate the secret key and the public key for one specific vector. We also need to compute the corresponding public commitments for the subsequent procedures. The master secret key hiding is achieved in this phase. In $\mathbf {Encrypt}$, our Ada-IPFE scheme needs to perform additional computations to generate ciphertext for the designated decryptor. That is, the ciphertext is generated corresponding to the specific one secret key held by designated decryptor. These additional computations mainly contribute to building the relationship between ciphertext and designated decryptor. In $\mathbf {Decrypt}$, our Ada-IPFE scheme needs to perform additional computations to remove the items introduced by privacy solutions.

In addition to the theoretical analysis, we also give the experimental results in Fig. 3. And Figs. 3a, 3c and 3d show that the time cost in $\mathbf {Setup }$, $\mathbf {Encrypt }$ and $\mathbf {Decrypt }$ of the scheme in [19] and our IPFE scheme are respectively almost the same. Fig. 3b shows that the time cost of our IPFE scheme in $\mathbf {KeyGen}$ is a bit large than that of the scheme in [19]. As is introduced before, the additional time cost results from the fact that we intend to achieve the privacy guarantees.

Fig. 3. - 
Time cost comparisons for IPFE.
Fig. 3.

Time cost comparisons for IPFE.

6.2 Performance Analysis for OIPFE-ACED Scheme

6.2.1 Functionality Analysis

Our OIPFE-ACED scheme is a new outsourced inner product computation scheme. This scheme focuses on not only the outsourced inner product computation but also the outsourced storage. For data privacy concerns, the data owner in the system can use this scheme to encrypt the data and then store the encrypted data in the cloud server. The data privacy is preserved based on the security of the underlying IPFE scheme. In our mentioned setting, there are also several data users who may be different entities from data owner. In addition to the traditional privacy issues, the revealed information and the data user are also regulated in this scheme. So, it is proper for the setting where multiple data owners and multiple data users are involved. These entities can share the inner product derived from the outsourced data.

6.2.2 Efficiency Analysis

When making the efficiency analysis, the storage efficiency is also a major aspect of our work. The basic requirements are that the data user can avoid downloading the outsourced data from cloud server and the storage overhead is independent of the vector size, if the data user makes use of the outsourced encrypted data. In Table 4, we show the storage overhead for every entity and the computation cost in every stage. We intend to show that data owner is free of the storage burden (i.e., nothing needs to be stored locally once the data is outsourced to cloud server) and the storage overhead is independent of the vectors size (i.e., constant). Furthermore, the total time cost that data user spends in the evaluation key generation stage of $\mathbf {Query}$ and $\mathbf {Recover}$ is less than that in $\mathbf {Compute}$.

TABLE 4 Computation Cost in OIPFE-ACED Scheme
Table 4- 
Computation Cost in OIPFE-ACED Scheme

For storage, we denote an element in $\mathbb {Z}$, $\mathbb {Z}_p$, $\mathbb {Z}_N$, $\mathbb {Z}_{N^2}$, $\mathbb {G}$ and $\mathbb {G}_T$ by $Z$, $Z_p$, $Z_N$, $Z_{N^2}$, $G$ and $G_T$, respectively. For computation, we denote the operation of choosing a random value and an inversion operation in $\mathbb {Z}_p$ by $R_1$ and $I_1$, respectively; we denote the exponent operation, the multiplication operation, the operation of choosing a random value, the addition operation and the inversion operation in $\mathbb {Z}_N$ by $E_2$, $M_2$, $R_2$, $A_2$ and $I_2$, respectively; we denote the exponent operation, the multiplication operation, the operation of choosing a random value and the subtraction operation in $\mathbb {Z}_{N^2}$ by $E_3$, $M_3$, $R_3$ and $S_3$, respectively; we denote an exponent operation, a multiplication operation, the operation of choosing a random value and an inversion operation in $\mathbb {G}$ by $E_4$, $M_4$, $R_4$ and $I_4$, respectively; we denote an exponent operation and a multiplication operation in $\mathbb {G}_T$ by $E_5$ and $M_5$, respectively; we denote a hash computation $H_1$, the hash computation $H_2$ and a pairing computation by $H_1$, $H_2$ and $P$, respectively.

From Tables 4 and 5, the data owner is free of the computation burden once the data is outsourced to cloud server. The data user just stores one element of $\mathbb {Z}$, one element of $\mathbb {Z}_p$ and one element of $\mathbb {G}$. So the storage efficiency is achieved as desired. The data user's computation cost involved in the evaluation key generation stage of $\mathbf { Query}$ and $\mathbf {Recover}$ are respectively $R_1+R_2+A_2+E_3+\left(2+\left|U^{\prime }\right|\right)E_4$ and $2I_1+E_2+M_2+I_2+A_2+4E_3+M_3+S_3+H_1+H_2$, which are both independent of the vector size $n$. If the data user first downloads the outsourced data and then performs the computation locally, the storage overhead and the computation cost for cloud server would be transmitted to data user besides the huge communication overhead. This is infeasible for the resource-limited data user to complete. From these, our proposed OIPFE-ACED scheme reduces lots of storage overhead for both data owner and data user as well as the computation burden for data user.

TABLE 5 Storage Overhead and Communication Cost in OIPFE-ACED Scheme
Table 5- 
Storage Overhead and Communication Cost in OIPFE-ACED Scheme

In Table 5, we also show the communication overhead of every entity in OIPFE-ACED scheme. The key generation center's communication overhead is $Z+\left(\left|U^{\prime }\right|+2\right)G$ because it needs to send the secret key to data user. The cloud server's communication overhead is $3Z_{N^2}+G_T$ that results in the process of returning intermediate result to data user. The data user's communication overhead in requesting cloud server to compute the inner product is $\left(n+1\right)Z+\left(\left|U^{\prime }\right|+2\right)Z_p$. When the data owner stores the data in cloud server, the communication overhead is $\left(n+1\right)Z_{N^2}+\left(2\left|U^{\prime }\right|+1\right)G$.

The experimental results are shown in Fig. 4, where the size of universal attribute set is 20 (i.e., $\left|U\right|=20$) and the size of data user attribute set is 10 (i.e., $\left|U^{\prime }\right|=10$). In order to make the results more credible, the vector size varies from 1000 to 10000. Fig. 4a shows that the time cost in data user's side is constant. And Fig. 4b shows that the time cost in cloud server's side grows with the vector size. These two subfigures explicitly show that the time cost in data user's side is less than that in cloud server's side. And the difference becomes distinct as the vector size grows. This implies that our OIPFE-ACED scheme is practical when the vector size is large.

Fig. 4. - 
Time cost comparisons for OIPFE-ACED scheme.
Fig. 4.

Time cost comparisons for OIPFE-ACED scheme.

SECTION 7

Conclusion

In this paper, we propose a concrete IPFE scheme based on the Paillier cryptographic system. The proposed Ada-IPFE scheme can preserve privacy for the master secret key and the encrypted vector. Based on this improved Ada-IPFE scheme, we also propose an OIPFE-ACED scheme. In addition to the basic requirements of verification and computational efficiency, the proposed OIPFE-ACED scheme can relieve data user's storage burden. This scheme is adequate for computing the inner product on the outsourced encrypted database. It can preserve the data privacy by the access control over the revealed information and the data users. Furthermore, we have given the security analysis and the experimental results, which show that our proposed schemes are secure and practical.

ACKNOWLEDGMENTS

The authors appreciate Dr. Fuchun Lin for the useful discussions to improve the article writing. This work was supported by National Natural Science Foundation of China under Grant (No.61772311), Open Project of State Key Laboratory of Cryptology (No. kyxm-70577), Singapore Ministry of Education under Research Grant RG12/19, A*STAR under its RIE2020 Advanced Manufacturing and Engineering (AME) Programmtic Programme (Award A19E3b0099), and China Scholarship Council (No.201906220077).

References

References is not available for this document.