Secure and Efficient Multiparty Computation on ...

5 downloads 0 Views 371KB Size Report
Mar 30, 2016 - either rely on homomorphic encryption or Yao's garbled circuit [27]. ... This protocol extensively uses garbled circuit which is the major reason ...

Secure and Efficient Multiparty Computation on Genomic Data

March 30, 2016

Abstract Large scale biomedical research projects involve analysis of huge amount of genomic data which is owned by different data owners. The collection and storing of genomic data is sometimes beyond the capability of a sole organization. Genomic data sharing is a feasible solution to overcome this problem. These scenarios can be generalized into the problem of aggregating data distributed among multiple databases and owned by different data owners. However, we should guarantee that an adversary cannot learn anything about the data or the individual contribution of each party towards the final output of the computation. In this paper, we propose a practical solution for secure sharing and computation of genomic data. We adopt the Paillier cryptosystem and the order preserving encryption to securely execute the count query and the ranked query. Experimental results demonstrate that the computation time is realistic enough to make our system adoptable in the real world.

Keywords: Genomic data security, secure multiparty computation, homomorphic encryption, secure genomic computation

1

Introduction

Today genomic data is widely used by different research organizations for analysis to undercover information useful for different aspects of human life. For the purpose of future analysis, data is collected, processed, stored and then computations are done on data. Researchers are interested in executing aggregate queries over genomic data (e.g., sum and count). The query results can be used for data mining purposes to come up with new pieces of information about diseases. The accuracy of this computation is largely dependent on the amount of data available for analysis. As more data yields more accurate results, organizations tend to collect as much data as possible prior to performing the computational tasks. A single organization often does not possess the amount of genomic data adequate enough to take a certain decision. Moreover, the collection, processing and storing of data is very time consuming. As a result disparate organizations tend to share data among each others. 1

Sharing genomic data possesses severe security threats. Numerous attack models have been developed to infer information from this shared data and those can be explained and classified into three major areas [19, 9, 2] — a) re-identification attack from relational data, b) inference about phenotype and kinship and c) legal, forensics and other attacks. Different privacy policies have been developed and a number of methodologies have been adopted to thwart these attacks. Cryptographic techniques are adopted to ensure the security of shared data as those allow some functions to be computed on data without revealing anything about data from different parties [10]. Encryption of the data before sharing and then conducting the required computations on the encrypted data is a popular solution [3]. However, genomic data tend to be very large in size and performing computations on these large encrypted data is very slow and much more complex than performing computation on the plaintext. In this paper we propose a method which can solve the problem of sharing and conducting computations on genomic data in a secure and a time-efficient way. In our model data itself resides in the premises of data owners in plaintext format. Data owners have their own database systems and with proper authentication any researcher can execute queries on them. As there are multiple data owners involved, getting access control from all of them is difficult for the researcher who wants to perform a query on the integrated data. Our proposed system allows any researcher to execute queries on the integrated data using a simple web architecture or Application Programming Interface (API). The computation required to answer a query is performed independently on each data owner’s premise. The individual output of each party is then encrypted and sent to a central server that obliviously performs further computations to produce the final output. This output, which is sent to the researcher from the central server, is the final result of the query. As most of the computation is done on the plaintext and only individual encrypted contributions are used to produce the final result, the overall computation process is very fast than the computation done on encrypted data. The system overview and related parties are explained in section (2). In the following, we summarize our major contributions in this paper: 1. We securely execute count and ranked queries (Top-N or Bottom-N) on data distributed and owned by different owners. This is the first paper to address ranked query problem for distributed data. 2. Each data owners does not know anything about the contributions of the other data owners. Moreover, the final result is revealed to researchers without disclosing the contribution of each data owner to the researcher. 3. We implement an Application Programming Interface (API) where researchers can execute queries with desired inputs and plug it into their programs for further analysis. 4. We conduct multiple experiments in different realistic settings. The time overhead for secure computations are much closer to their plaintext counterparts (∼ 1 second). 2

Figure 1: Proposed Architecture of the System The rest of the paper is organized as follows. Section 2 describes the system architecture. The required background information is presented in Section 3. Section 4 details the approach. Practical results and discussions are presented in Section 5. Section 6 discusses related work whereas Section 7 concludes the paper.

2

System Overview

In this section we detail the system architecture followed by the threat model.

2.1

Architecture and Entities

The proposed system as shown in Figure 1 has four main entities: • Researchers: They might be an individual or an organization who wants to execute queries over databases. Researchers communicate their queries to the central server. • Data Owners: They possess databases upon which queries are performed. Data owners might be clinics or hospitals who want to share their genomic databases. The proposed model supports any number of data owners. When a query is forwarded to a data owner, it executes the query locally and then encrypts the local result. Afterwards, it sends the encrypted result to the central server for further computation. • Crypto Service Provider (CSP): It manages the keys that are used for encryption and decryption in different stages of our system. Each data owner receives a key from the CSP and uses it to encrypt its local result of the query. Finally, CSP is responsible for decrypting the final result which is sent to the researcher.

3

• Central Server: The central server communicates with all the other entities. It receives queries from the researcher, forwards them to all data owners and collects individual encrypted results from data owners. Individual encrypted results from data owners are obliviously combined by the central server to produce the final result. The central server also decrypts the final result with the help of CSP before sending it to the researcher.

2.2

Threat Model

Our goal is to ensure that the data owners, the central server, and the crypto service provider (CSP) learn nothing more about local databases (owned by data owners) beyond what is released by the final query result. Note that we do not provide any privacy guarantee on the query result itself. Hence, it might be possible for a researcher to derive private information of an individual using only query results. Such problem can be avoided by adding noise to the query results and it has been extensively studied in the literature [8]. In this paper, we adopt the semi-honest adversary model (also known as honest-but-curious). In semi-honest adversary model, adversaries follow the protocol but may attempt to derive additional information from the received messages. This is a common security definition and it is realistic in our problem scenario since different organizations are collaborating to securely share their data for scientific and social benefits. Thus, neither the data owners, the central server, nor the CSP has any motivation to behave maliciously in the hope of producing incorrect output. In addition, we have the following assumptions regarding our proposed model. • CSP does not collude with the central server or data owners to learn information about local databases. • Data owners do not collude among themselves to violate the security of an individual data owner. In section 4.2, we present a validation protocol that can be used by the CSP to validate the computation of the central server. This protocol enables the CSP to identify any incorrect query result.

3

Background

In this section we briefly review the concept of ranked query, homomorphic encryption and order preserving encryption.

3.1

Ranked Query

One of the most promising and attractive examples of the use of genomic data is the Similar Patient Query (SPQ) operation. The purpose of this operation is to understand the association 4

between the disease and genetic variation – thus increasing the accuracy of medical decisions. Edit distance is a proven and most frequent used metric for this SPQ operation and it is extensively adopted in literature [25]. The edit distance between two sequences A and B is defined as the minimum number of edits (insertion, deletion or substitution of a single character) required to change A into B. Suppose, A = T T GCCT GAG and B = AT T CAG Then, the minimum edits required to convert A to B are — substitute T at position 1 with A; delete G, C and C from position 3, 4 and 5; replace G at position 7 with C. So the edit distance between A and B is 5 as the total number of required edits are 5. Through our proposed Secure Ranked Query (4.3), any researcher can get the ranked results and their corresponding distances based on the sequence given in the query. Based on the results returned by data owners, the central server ranks the query and returns the top-n number of results where n is explicitly mentioned in the query. The distance measure we consider is secured with order preserving encryption described next.

3.2

Homomorphic Encryption

Homomorphic encryption allows anybody to run any function on encrypted data without first decrypting the data without any knowledge of the secret key. The scheme was defined soon after RSA in 1978 [23] but was in theory for 30 years. The scheme in a nutshell is: if c1 = ξ(m1 ) and c2 = ξ(m2 ) (where m1 and m2 are the plaintexts, c1 and c2 are the ciphertexts and ξ = Any randomized encryption), we can compute any function on c1 and c2 and get the same result as if we were computing with m1 and m2 . In our proposed framework we have adopted a partial homomorphic system named Paillier cryptosystem [20] to do linear operations on ciphertexts. With paillier we can compute the following specific functions (n is the public key): ξ(m1 + m2 ) = (c1 ∗ c2 ) mod n2

(1)

ξ(m1 ∗ k) = ck1 mod n2

(2)

We have avoided lattice based cryptography [22] which has been recently popularized by Craig Gentry [11] as it supports any computations over encrypted data. However it is not feasible as this cryptosystem adds small noise to the ciphertext to ensure its security. After a few level of computations, the noise becomes too large to decrypt the ciphertext using the correct decryption key. In order to refresh the ciphertexts to reduce the noise, a computationally costly procedure is used called bootstrapping.

3.3

Order Preserving Encryption

Order Preserving Encryption (OPE) is a method which preserves the order of the plaintext in the ciphertext. Below we give an example of OPE where the orders of the plaintexts are 5

maintained while they are encrypted. Plaintext OPE Ciphertext Frequency Hiding OPE

1 15 10

2 24 24

2 24 28

3 30 32

4 49 59

5 52 72

There are different OPE schemes proposed in the literature. Some schemes do not hide the frequency of a plaintext, while others provide more security by hiding the frequency of a plaintext as shown in the example above. Although frequency hiding OPE schemes [12, 5, 21] provide more security, these schemes fall short for our application purpose (discussed in Section 4.3). In this paper, we adopt the OPE scheme proposed by Liu and Wang [16] to perform the secure ranked query operation. There are two constants a, b for any plaintext p1 , p2 and the encryption of these plaintexts are: ξ(p1 ) = a ∗ p1 + b + noise1

(3)

ξ(p2 ) = a ∗ p2 + b + noise2

(4)

where 0 ≤ noise1 , noise2 < a Though a and b are constants, due to the addition of the random noise, this scheme provides enough security for our scheme. The security discussions are detailed in Section 4.5.

4

Secure Computation over Genomic Data

Say there are total n number of hospitals (H1 , H2 , ..., Hn ) in our system which represent data owners. For a single query provided by a researcher, each hospital will have a single output — H1 will have output x1 , H2 will have output x2 and similarly Hn will have output xn . In total, there will be n outputs. CSP generates the required public and private keys for the encryption. Data owners get the public keys from CSP. The data owners’ outputs (x1 , x2 , . . . xn ) the encrypted values using the public keys provided by the CSP and send to the central server for merging. The central server then runs the desired addition with the Paillier cryptosystem. The sequence diagram of the system is shown in Figure 2. The sequence diagram is detailed in the Basic Protocol (4.1) which is essential for all the computations. The validation Protocol 2 (4.2) is about verifying the results. Ranked query execution is described in 4.3.

4.1

Basic Protocol

This protocol defines the main mechanism of the framework which ensures the individual contributions of the data owners are secure. For instance, the researcher wants to know how many patients have CC in their SNP ‘rs4426491’, GG in their SNP ‘rs4630725’ and cancer diagnosis Positive in Table 1 (i.e., integrated database from 4 data owners). 6

Table 1: Data representation in each party

# Data Owner 1 Data Owner 2 Data Owner 3 Data Owner 4

Case 1 2 3 1 2 3 1 2 3 1 2 3

rs4426491 CC CT CC CC CT CC CT CT TT TT CC CC

Sequence rs4305230 rs4630725 CT GG CT AG CT GG CT GG CC GG CT GG CC AG CT AG CC GG CC AA CC GG CT GG

... ... ... ... ... ... ... ... ... ... ... ...

Cancer Negative Negative Negative Negative Positive Positive Positive Negative Positive Positive Positive Positive

Input: A query from the researcher Output: The query result Process: 1. The central server accepts a query from a researcher and sends it to CSP for initialization. 2. CSP generates a secret key and a public key pair and sends the public key to the active data owners and the Central Server for further computation. 3. After receiving the public key the server sends the query to the individual data owners who will participate in this query. 4. The data owners execute the query on their data and send the encrypted results to the central server. 5. The central server adds the values from the individual parties and sends the encrypted result to CSP for validation and decryption. 6. CSP decrypts the submitted value (as it is the only entity holding the secret key) by the central server and validates it (Section 4.2). 7. This result is submitted to the researcher as a final output.

If CSP, the central server and data owners follow the protocol mentioned above, the individual result for this count operation at data owner 1 will be 0, at data owner 2 will be 1, at data 7

Figure 2: Sequence diagram of the approach owner 3 will be 0 and at data owner 4 will be 2. Each data owner will encrypt its result using the public key provided by CSP and send the encrypted result to the central server. The central server will aggregate the local results to produce the final encrypted result ξ(3). After decrypting the encrypted result with the help of CSP, the central server will forward the final result to the researcher.

4.2

Validation Protocol

This protocol validates the computations made in the central server. Two big prime numbers (assuming they are bigger than the results) are sent along with the keys by CSP. One of these numbers (x1 ) is multiplied by the individual result and the other one (x2 ) is added. For example if there are 2 (n = 2) parties then CSP will send {x1 , x2 }, {x1 , x3 } to those individual parties. The individual parties now have z1 and z2 as outputs of the query which are modified using those primes. z10 = ξ(x1 ∗ x1 + x2 )

(5)

z20 = ξ(x2 ∗ x1 + x3 )

(6)

The new outputs that the parties generate and send to the server is shown in Equation 5 and Equation 6. After decrypting, CSP subtracts the values p2 and p3 , divides the result with n∗p1 to get the original result and sends it back to the server. If the result is not divisible with n ∗ p1

8

then there might be a miscalculation on the server. This method ensures that the final output is valid which is important as many data owners are involved in a single query over the network.

4.3

Ranked Query

Suppose, we have a list of unique genomic sequences of patients from different hospitals or data owners (Table 1). The researcher wants to execute a Similar Patient Query [25] operation on every dataset based on the value of Edit Distance with respect to a given query sequence. He might want the Top-5 sequences for a particular associated disease. The query might be like the following — SELECT * FROM Sequences WHERE rs4426491=‘CC’ AND rs4305230=‘CT’ AND rs4630725=‘GG’ LIMIT 5 Each data owner has a table named ‘Sequences’. Genomic sequences from all of the data owners are shown together in Table 1 for a better understanding. Each data owner calculates the individual distances (edit distance) of all the genomic data rows with the query sequence. Then it sends only k encrypted results using OPE to the central server. The number k is specified in the query by the LIMIT command. This encryption, which is performed at each of the data owner’s end, is done by using the OPE described in Section 3.3. Consider two data owners with different distance sets {10, 11, 13, 14, 15} and {11, 12, 13, 14, 15}. We can add a random noise while encrypting them and it will hide the frequency of the original distance. But the original order of the distances will be perturbed as most of the distance values are relatively close to each other. Hence, wrong order of the ranked data will cause an erroneous output. We followed Liu and Wang’s OPE scheme [16] (preceded by [17]) where noises are equal to the individual distance measure. This protocol allows the researcher to get his desired Top-k results for the given query. The server is able to know only the relative distances. The keys (Equation 3, 4) provided by CSP are changed for every new query. This ensures stronger security as every edit distance query will have different order range according to the keys. The security of this scheme is discussed in detail in 4.5.

4.4

Offline CSP

If we want to make the CSP less active on the computation and become offline after the key generation and propagation, the researcher should be responsible for the decryption. In this context, CSP becomes inactive after initializing the system and gives the secret key to the researcher. With secret key, the researcher can retrieve the final result by decrypting (previously done by CSP). The only difference from the previous protocols is the key generation is done on CSP and afterwards the researcher does the rest. 9

Table 2: Server locations and average ping Server Location Singapore Brazil Ireland USA(Oregon) Canada(Manitoba)

4.5

IP Address 52.77.210.123 54.94.175.199 52.48.14.85 52.32.83.223 130.179.30.133

Ping(ms) 244 186 110 37 1

Security Discussion

For the count query we use Paillier Encryption [20] which is an established cryptosystem. This cryptosystem has been extensively used in the literature as a probabilistic additive homomorphic encryption scheme and it provides IND-CPA (indistinguishability under chosen plain text) security guarantee [7, 18]. For the rank query, we use an OPE scheme that does not satisfy formal definition of INDOCPA (indistinguishability under ordered chosen-plaintext attack) security[4]. Recent research demonstrates that it is possible to determine the constants a and b of the encryption scheme (see Equations 3 and 4) [21, 13]. For example, if an adversary takes p1 = any integer and p2 = 0 then the adversary can compute c1 − c2 = a ∗ p1 + noise1 − noise2 . As 0 ≤ noise1 , noise2 < a, the adversary can learn in which interval a belongs (i.e.,

c1 −c2 k+1

≤ a ≤

c1 −c2 k−1 ).

Given a, the

adversary can then obtain b in some iterations and can eventually decrypt all the values. However, this attack is not applicable for our proposed scenario as the adversary (i.e., central server) does not provide any inputs (p1 and p2 ) of the OPE scheme and therefore unable to determine the constants a and b. Also each query result will have a different a and b from the CSP along with the noise which is the original distance. The central server only compares different order preserved encrypted values coming from different data owners and publishes the final ranked result. Hence, it is secure to employ the OPE scheme of Liu and Wang [16] for our application scenario.

5

Results and Discussions

We considered data owners and researchers on different locations in our experiments so that we can measure the performance of the system in a real world scenario. We fixed the position of CSP and the central server in two different locations and used Amazon EC2 cloud servers with the same configuration for all the data owners and CSP. The full system is connected to a cloud server in Canada (Manitoba) which is also the endpoint for the API for researchers. For genomic dataset we used IDASH 2015 SNP dataset [1] which were distributed among the data owners. Additionally, for better measurement of Ranked Query, we used a larger dataset ‘Bag of Words’ [15] (96, 618 records) distributed between the data owners so that every party owns a different set of words. The code is shared on github 10

Table 3: Experiments Experiment # Experiment 1

Experiment 2

Experiment 3

Experiment 4

Experiment 5

Actors Hospital Researcher CSP Hospital Researcher CSP Hospital Researcher CSP Hospital Researcher CSP Hospital Researcher CSP

Canada

USA

Ireland

Singapore

Brazil

3 7 7 7 3 7 3 3 7 3 3 7 3 3 7

7 3 3 7 7 3 7 7 3 7 7 3 3 7 3

3 7 7 3 7 7 3 7 7 3 7 7 3 7 7

7 7 7 3 7 7 3 7 7 3 7 7 3 7 7

7 7 7 3 7 7 7 7 7 3 7 7 3 7 7

(https://github.com/mominbuet/smc_genome_clients.git). We used different combinations of active data owners which are described in Table 3. For example Experiment 1 shows that we have data owners in Canada and Ireland where Experiment 5 has 5 different data owners on 5 different locations in the world. Table 2 shows the 5 server locations and their latency with respect to the central server (which hosts the API) in Manitoba. Secure count query, ranked query and their plaintext counterparts were executed under these settings. Fig. 3 shows the runtime of 10 iterations of these individual protocols. The difference of time for secure and regular query operations are negligible. Our proposed framework can not only perform the query operations in a secured way but also the time required to execute those secure query operations are almost as the same as performing those operations on plaintext. Figure 3 also shows that adding more data owners affects all the protocols (regular and secure) which is completely logical as it will endorse more network communications. But interestingly increasing data owners in different regions does not effect the secure protocols that much as the network communication were almost the same as the plaintext ones. The only overhead the secure method had is decrypting the final result by CSP. This way we achieved faster, secure protocols of the query build like an API which is pluggable to any program.

11

Figure 3: Experiment results for different settings in milliseconds (ms)

6

Related Work

We are only securing the computations in the cloud but not the final output of the query. To be specific the individual contribution provided by each owner is hidden from the central server but the computations are still done with the encrypted values. There were previous attempts to address a similar problem but no solutions or attempts are available for Secure Multiparty Ranked Query. There are some approaches which relates to our problem architecture but they either rely on homomorphic encryption or Yao’s garbled circuit [27]. There is a recent work SecureMA [26], which has similar architecture but proposed a secure computation for a single function. The proposed method considered the secure count but it introduced some approximation over the final result to maintain the security of the protocol. This protocol extensively uses garbled circuit which is the major reason behind its security but also increases bandwidth cost (because of circuits) and runtime along the way. There are also many use of Fully Homomorphic Encryption (FHE) or SomeWhat Homomorphic Encryption (SWHE) in genomic data [14, 6]. One example would be Healer [24] which is architecturally similar to ours and provides Secure Logistic Regression in genomic data. Foresee [28] is also similar and proposes secure chi-square statistics on genomic data. These approaches are computationally secure but the overhead involved makes it impractical to use in real world application scenario. Also these methods did not address Secure Ranked Query problem.

12

7

Conclusion

We have proposed in this paper an approach to securely compute the count and the ranked query over genomic data in an efficient way. The most important characteristics of the approach is the computation time. The computation time of the secure computations is closer to the time of the corresponding regular computations over the plaintext. As a future work, we are thinking to extend the approach such that it can securely and privately execute the required queries. A noise may be added to the final result to protect the identity of the patients. Additionally, we may define another approach to directly compute the ranked query on encrypted data.

References [1] Idash-privacy

and

security

workshop

on

genomic

data.

http://www.

humangenomeprivacy.org/2015/competition-tasks.html, 2015. [2] M. Akg¨ un, A. O. Bayrak, B. Ozer, and M. S ¸ . Sa˘gıro˘glu. Privacy preserving processing of genomic data: A survey. Journal of biomedical informatics, 56:103–111, 2015. [3] S. Barouti, D. Alhadidi, and M. Debbabi. Symmetrically-private database search in cloud computing. In 2013 IEEE 5th International Conference on Cloud Computing Technology and Science (CloudCom), volume 1, pages 671–678, Dec 2013. [4] A. Boldyreva, N. Chenette, Y. Lee, and A. Oneill. Order-preserving symmetric encryption. In Advances in Cryptology-EUROCRYPT 2009, pages 224–241. Springer, 2009. [5] D. Boneh, K. Lewi, M. Raykova, A. Sahai, M. Zhandry, and J. Zimmerman. Semantically secure order-revealing encryption: Multi-input functional encryption without obfuscation. In Advances in Cryptology-EUROCRYPT 2015, pages 563–594. Springer, 2015. [6] J. W. Bos, K. Lauter, and M. Naehrig. Private predictive analysis on encrypted medical data. Journal of biomedical informatics, 50:234–243, 2014. [7] D. Catalano, R. Gennaro, and N. Howgrave-Graham. The bit security of pailliers encryption scheme and its applications. In Advances in CryptologyEUROCRYPT 2001, pages 229–243. Springer, 2001. [8] C. Dwork, F. McSherry, K. Nissim, and A. Smith. Calibrating noise to sensitivity in private data analysis. In Theory of cryptography, pages 265–284. Springer, 2006. [9] Y. Erlich and A. Narayanan. Routes for breaching and protecting genetic privacy. Nature Reviews Genetics, 15(6):409–421, 2014. [10] Y. Erlich, J. B. Williams, D. Glazer, K. Yocum, N. Farahany, M. Olson, A. Narayanan, L. D. Stein, J. A. Witkowski, and R. C. Kain. Redefining genomic privacy: Trust and empowerment. 12(11):e1001983, 11 2014. 13

[11] C. Gentry et al. Fully homomorphic encryption using ideal lattices. In STOC, volume 9, pages 169–178, 2009. [12] F. Kerschbaum. Frequency-hiding order-preserving encryption. In Proceedings of the 22nd ACM SIGSAC Conference on Computer and Communications Security, pages 656–667. ACM, 2015. [13] F. Kerschbaum and A. Schr¨ opfer.

Optimal average-complexity ideal-security order-

preserving encryption. In Proceedings of the 2014 ACM SIGSAC Conference on Computer and Communications Security, pages 275–286. ACM, 2014. [14] K. Lauter, A. L´ opez-Alt, and M. Naehrig. Private computation on encrypted genomic data. In Progress in Cryptology-LATINCRYPT 2014, pages 3–27. Springer, 2014. [15] M. Lichman. UCI machine learning repository, 2013. [16] D. Liu and S. Wang. Programmable order-preserving secure index for encrypted database query. In IEEE 5th International Conference on Cloud Computing (CLOUD), pages 502– 509. IEEE, 2012. [17] D. Liu and S. Wang. Nonlinear order preserving index for encrypted database query in service cloud environments. Concurrency and Computation: Practice and Experience, 25(13):1967–1984, 2013. [18] M. Naor and M. Yung. Public-key cryptosystems provably secure against chosen ciphertext attacks. In Proceedings of the twenty-second annual ACM symposium on Theory of computing, pages 427–437. ACM, 1990. [19] M. Naveed, E. Ayday, E. W. Clayton, J. Fellay, C. A. Gunter, J.-P. Hubaux, B. A. Malin, and X. Wang. Privacy in the genomic era. ACM Computing Surveys (CSUR), 48(1):6, 2015. [20] P. Paillier. Public-key cryptosystems based on composite degree residuosity classes. In Advances in cryptology,EUROCRYPT99, pages 223–238. Springer, 1999. [21] R. A. Popa, F. H. Li, and N. Zeldovich. An ideal-security protocol for order-preserving encoding. In Security and Privacy (SP), 2013 IEEE Symposium on, pages 463–477. IEEE, 2013. [22] O. Regev. On lattices, learning with errors, random linear codes, and cryptography. Journal of the ACM (JACM), 56(6):34, 2009. [23] R. L. Rivest, L. Adleman, and M. L. Dertouzos. On data banks and privacy homomorphisms. Foundations of secure computation, 4(11):169–180, 1978.

14

[24] S. Wang, Y. Zhang, W. Dai, K. Lauter, M. Kim, Y. Tang, H. Xiong, and X. Jiang. Healer: Homomorphic computation of exact logistic regression for secure rare disease variants analysis in gwas. Bioinformatics, 32(2):211–218, 2016. [25] X. S. Wang, Y. Huang, Y. Zhao, H. Tang, X. Wang, and D. Bu. Efficient genome-wide, privacy-preserving similar patient query based on private edit distance. In Proceedings of the 22nd ACM SIGSAC Conference on Computer and Communications Security, pages 492–503. ACM, 2015. [26] W. Xie, M. Kantarcioglu, W. S. Bush, D. Crawford, J. C. Denny, R. Heatherly, and B. A. Malin. Securema: protecting participant privacy in genetic association meta-analysis. Bioinformatics, page btu561, 2014. [27] A. C.-C. Yao. Protocols for secure computations. In FOCS, volume 82, pages 160–164, 1982. [28] Y. Zhang, W. Dai, X. Jiang, H. Xiong, and S. Wang. Foresee: Fully outsourced secure genome study based on homomorphic encryption. BMC medical informatics and decision making, 15(Suppl 5):S5, 2015.

15

Suggest Documents