COMPUTER-IMPLEMENTED SYSTEM AND METHOD FOR PROTECTING SENSITIVE DATA VIA DATA RE-ENCRYPTION

Abstract

A computer-implemented method for protecting sensitive data via data re-encryption is provided. Encrypted data is maintained. A data query is received from a user associated with a public key and a secret key. Results of the query are computed by identifying at least a portion of the encrypted data and by adding plaintext for the identified portion of the encrypted data as the results. A re-encryption key is generated for the results using the public key of the user and the results are re-encrypted using the re-encryption key. The re-encrypted results are then transmitted to the user.

Claims

1. A computer-implemented system for protecting sensitive data via data re-encryption, comprising: a database to maintain encrypted data, wherein the encrypted data comprises a property of supporting additions of plaintext underlying the encrypted data; a server comprising a central processing unit, memory, an input port, and an output port, wherein the central processing unit is configured to generate a re-encryption key for the encrypted data using a public key of one of a plurality of users; and a further server comprising a central processing unit, memory, an input port to receive at least a portion of the encrypted data from the database and the re-encryption key from the server, and an output port, wherein the central processing unit is configured to: re-encrypt the portion of encrypted data using the re-encryption key; and transmit the re-encrypted data to the user.

2. A system according to claim 1, further comprising: a search generator to process the encrypted data in response to a query from the user and to determine results of the query, wherein the results comprise the portion of encrypted data.

3. A system according to claim 1, further comprising: a public key generator to generate public parameters for the user and generate the public key using at least one of the public parameters.

4. A system according to claim 1, further comprising: a secret key generator to generate private parameters for the user and compute a secret key for the user using at least one of the private parameters.

5. A system according to claim 1, further comprising: a message encryptor to encrypt each message by dividing each message into segments, further dividing each segment into two blocks comprising a first block and a second block, collecting the first block from each segment in the message and generating ciphertext, collecting the second block from each segment in the message and generating ciphertext, and combining the ciphertext from the first and the second blocks as an encryption of that message.

6. A system according to claim 1, further, comprising: a re-encryption key generator to calculate the re-encryption key by accessing a secret key associated with an owner of the encrypted data, parsing each of the secret key associated with the owner and the public key of the user into two sections, selecting two random elements, computing a first part of the re-encryption key based on one of the random elements, a first part of the secret key, and a first part of the public key, computing a second part of the re-encryption key based on the other random element, a second part of the secret key, and a second part of the public key, and combining the first and second parts as the re-encryption key.

7. A system according to claim 1, further comprising: a key access module to identify the user of the query and access the re-encryption key associated with the identified user for re-encryption.

8. A system according to claim 1, further comprising: a re-encryption module to perform the re-encryption on one such encrypted message result by splitting the encrypted message into two parts, computing first re-encryption component using elements from the re-encryption key and the first part of the encrypted message, computing second re-encryption component using elements form the re-encryption key and the second part of the encrypted message, and combining the first and second re-encryption components as the re-encrypted message.

9. A system according to claim 1, wherein the re-encrypted results comprise ciphertext different from ciphertext of the encrypted data.

10. A system according to claim 9, further comprising at least one of: a decryption module to decrypt the re-encrypted ciphertext of one such message by dividing the re-encrypted ciphertext into two parts, applying an oracle and a decode algorithm to the first part and the decode algorithm to the second part and combining the first and second parts as the ciphertext of the encrypted message.

11. A computer-implemented method for protecting sensitive data via data re-encryption, comprising: maintaining encrypted data, wherein the encrypted data comprises a property of supporting additions of plaintext underlying the encrypted data; generating a re-encryption key for the encrypted data using a public key of one of a plurality of users; and re-encrypting at least a portion of the encrypted data using the re-encryption key; and transmitting the re-encrypted data to the user.

12. A method according to claim 11, further comprising: processing the encrypted data in response to a query from the user; and determining results of the query, wherein the results comprise the portion of encrypted data.

13. A method according to claim 11, further comprising: generating public parameters for the user; and generating the public key using at least one of the public parameters.

14. A method according to claim 11, further comprising: generating private parameters for the user; and computing a secret key for the user using at least one of the private parameters.

15. A method according to claim 11, further comprising: encrypting each message, comprising: dividing each message into segments; further dividing each segment into two blocks comprising a first block and a second block; collecting the first block from each segment in the message and generating ciphertext; collecting the second block from each segment in the message and generating ciphertext; and combining the ciphertext from the first and the second blocks as an encryption of that message.

16. A method according to claim 11, further, comprising: calculating the re-encryption key, comprising: accessing a secret key associated with an owner of the encrypted data; parsing each of the secret key associated with the owner and the public key of the user into two sections; selecting two random elements; computing a first part of the re-encryption key based on one of the random elements, a first part of the secret key, and a first part of the public key; computing a second part of the re-encrption key based on the other random element, a second part of the secret key, and a second part of the public key; and combing the first and second parts as the re-encrption key.

17. A method according to claim 11, further comprising: identifying the user; and accessing the re-encryption key associated with the identified user for re-encryption.

18. A method according to claim 11, further comprising: performing the re-encryption on one such encrypted message result, comprising: splitting the encrypted message into two parts; computing first re-encryption component using elements from the re-encryption key and the first part of the encrypted message; computing second re-encryption component using elements form the re-encryption key and the second part of the encrypted message; and combining the first and second re-encryption components as the re-encrypted message.

19. A method according to claim 11, wherein the re-encrypted results comprise ciphertext different from ciphertext of the encrypted data.

20. A method according to claim 19, further comprising at least one of: decrypting the re-encrypted ciphertext of one such message, comprising: dividing the re-encrypted ciphertext into two parts; applying an oracle and a decode algorithm to the first part and the decode algorithm to the second part; and combining the first and second parts as the ciphertext of the encrypted message; and decrypting the re-encrypted data via a secret key of the user.

Description

BRIEF DESCRIPTION OF THE DRAWINGS

[0010] FIG. 1 is a block diagram showing a computer-implemented system for protecting sensitive data via data re-encryption, in accordance with one embodiment.

[0011] FIG. 2 is a flow diagram showing a computer-implemented method for protecting sensitive data via data re-encryption, in accordance with one embodiment.

[0012] FIG. 3 is a flow diagram showing, by way of example, a process for performing encryption set up.

[0013] FIG. 4 is a flow diagram showing, by way of example, a process for generating public and secret keys.

[0014] FIG. 5 is a flow diagram showing, by way of example, a process for encrypting data using the public key of FIG. 4.

[0015] FIG. 6 is a flow diagram showing, by way of example, a process for generating a re-encryption key.

[0016] FIG. 7 is a flow diagram showing, by way of example, a process for re-encrypting ciphertext using the re-encryption key of FIG. 6.

[0017] FIG. 8 is a flow diagram showing, by way of example, a process for decrypting ciphertext.

DETAILED DESCRIPTION

[0018] Companies collect and store large amounts of data. Hired analysts can analyze the collected data, such as for use in business intelligence. However, analysts are often considered to be a weak link since each is trusted with extremely important tools, such as a decryption key to decrypt encrypted data prior to analysis. Unfortunately, most of the analysts are not equipped with strong intrusion prevention mechanisms and thus, attacks are common. Separately encrypting data for each data owner and re-encrypting the data for a particular user authorized by a data owner, helps prevent breach of the data due to unauthorized access to the server, untrustworthy users, or attacks on a user privy to security information of the data.

[0019] Re-encryption facilitates that a decryption key, used to decrypt an encrypted database, no longer resides at the endpoints. FIG. 1 is a block diagram showing a computer-implemented system 10 for protecting sensitive data via data re-encryption, in accordance with one embodiment. Over time, a data owner can collect large amounts of data 16 during the normal course of business, which can be originally stored on a local database 15 that is interconnected to a server 11 associated with the owner. The data 16 can include documents, messages, voice recordings, video clips, medical records, financial transactions, and location data, as well as other types of data. The database 15 can also include a public key 17 and secret key 18 for the data owner.

[0020] The server 11 includes an encryptor 12, set-up module 13, and key generator 14. The encryptor 12 utilizes the public key of the data owner to encrypt the data 16 stored on the database 15. Once encrypted, the data 23 is transmitted for storage in a database 22 associated with a cloud based server 19. Cloud based storage offers extremely large amounts of storage space, which relieves data owners of the burden of storing all data locally. To access the encrypted data 23 from the cloud based servers, authorized users are each associated with a public key 29 and a secret key 30, where the public key can be maintained in a database 28 associated with a computing device 24 of that user. Alternatively, the public 29 key can be stored on in a database of a cloud based server. The users' public 29 and secret 30 keys can be generated by the owner's server 11 via the set up module 13, which outputs parameters that can be used by the key generator 14 to generate the keys for each user authorized to access the data 23, as further described below with reference to FIG. 3.

[0021] Each authorized user can access the owner's encrypted data 23 via the computing device 24, such as a desktop or laptop computer, as well as a mobile device, for performing analytics on the data. Specifically, the computing device 24 is associated with a server 25 having a query generator 26 to generate the query and a decryptor 27. The query is transmitted to the cloud based server 19, which includes a query receiver 20 to receive and parse the query, and a result finder 21 that processes the encrypted data 23 in response to the query and generates one or more encrypted results. The results of the query are computed by adding the underlying plaintext of the results. However, prior to providing the encrypted results to the user, the results are transmitted to a proxy re-encryption server 31, which includes a key generator 32 and a re-encryptor 33. The key generator 32 generates a re-encryption key 35 for each authorized user based on the secret key of the data owner and the public key of that requesting user, as described below in further detail with respect to FIG. 6. The re-encryption keys 35 for the users can support additively homomorphic operations in the ciphertext domain and are stored in a database 34 associated with the proxy re-encryptor 31. The re-encryptor 33 re-encrypts ciphertext of the encrypted data results from under the data owner's public key to the requesting user's public key and transmits the re-encrypted results to the requesting user. Once received by the requesting user, the re-encrypted data results can be decrypted using the requesting user's secret key by the decryptor 27. Decryption of the re-encrypted ciphertext reveals the underlying plaintext, namely the query results.

[0022] The mobile computing devices and servers can each include one or more modules for carrying out the embodiments disclosed herein. The modules can be implemented as a computer program or procedure written as source code in a conventional programming language and is presented for execution by the central processing unit as object or byte code. Alternatively, the modules could also be implemented in hardware, as integrated circuitry and each of the client and server can act as a specialized computer. The various implementations of the source code and object and byte codes can be held on a computer-readable storage medium, such as a floppy disk, hard drive, digital video disk (DVD), random access memory (RAM), read-only memory (ROM) and similar storage mediums. Other types of modules and module functions are possible, as well as other physical hardware components.

[0023] Re-encrypting ciphertext helps prevent data breaches, as well as minimizes the effect of any breach that occurs, by preventing the sharing of decryption keys and adding an additional level of security. Specifically, if a re-encryption key is stolen, all the unauthorized user can do with the key is convert the ciphertext from one public key to another. In other words, the unauthorized user is not able to decrypt the ciphertext. FIG. 2 is a flow diagram showing a computer-implemented method 40 for protecting sensitive data via data re-encryption, in accordance with one embodiment. A data owner performs set-up (block 41), including identifying parameters for generating (block 42) public and secret keys for the data owner itself and users authorized to access data of the owner. Generating the parameters are further described below in detail with respect to FIG. 3, while generating the public and secret keys for the data owner and user is further described below with reference to FIG. 4. Simultaneously with or subsequent to set up, re-encryption keys for one or more of the authorized users can be generated (block 43) using that user's public key, as further described below with reference to FIG. 6.

[0024] Data collected by the owner can be encrypted (block 44) using the owner's public key and stored on one or more cloud based servers, as further described below with reference to FIG. 5. One or more authorized users can perform analytics on the encrypted data by submitting (block 45) a query for at least a subset of the data. Using an additively homomorphic algorithm and based on the encrypted data, results of the query are computed (block 46) by adding underlying plaintext of the encrypted results that satisfy the query. Prior to providing the results to the requesting user, the results, including the encrypted and plaintext results, are re-encrypted (block 47) using the re-encryption key, as further described below with reference to FIG. 7. The re-encrypted results can then be provided (block 48) to the requesting user and decrypted (block 49) for use by the user, as further described below with reference to FIG. 8.

[0025] Each user authorized to access data of an owner is associated with a public key and secret key. The keys of the users should be related based on their common relationship with the data owner. The set-up phase determines parameters for generating the keys, such that the keys of all the authorized users are tied together based on a common set of parameters. FIG. 3 is a flow diagram showing, by way of example, a process 50 for performing encryption set up. During set up, a bilinear group generator algorithm is run (block 51) to identify two multiplicative cyclic groups G and G.sub.T, each of order N=p.sub.1.sup.kp.sub.2.sup.kp.sub.3. Each of p.sub.1, p.sub.2, and p.sub.3 are distinct prime numbers that are also output via the bilinear group generator algorithm, along with ġ, a generator of G, and a bilinear map e: G×G.fwdarw.G.sub.T, and k is a positive integer less than N. Thus, once run, the bilinear group generator identifies each of the following parameters: (, .sub.T, e, N, ġ, p.sub.1, p.sub.2, p.sub.3), where ġ is the group generator.

[0026] A set of elements, Z.sub.N={0, 1, . . . N−1}, is accessed (block 53) and two subsets of elements are randomly selected (block 54) from the set Z.sub.N. Each randomly selected element is processed (block 55) through exponentiation to generate two calculated sets of elements. For example, two subsets of elements α.sub.0, α.sub.1, . . . α.sub.k-1 and β.sub.0, . . . β.sub.k-1 can be randomly selected from the set Z.sub.N, and separately employed in the following equations:

[00001]$h_i={\left({\stackrel{.}{g}}^{p_2^k.Math.p_3}\right)}^{{\alpha }_i.Math.p_1^i}$$f_i={\left({\stackrel{.}{g}}^{p_1^k.Math.p_2}\right)}^{{\beta }_i.Math.p_2^i}$

to generate parameters h.sub.0, . . . , h.sub.k-1, f.sub.0, . . . , f.sub.k-1

[0027] Also during the set-up phase, a decryption oracle is constructed (block 56) for use with a decode algorithm to decrypt encrypted and re-encrypted ciphertext using one of the prime numbers, as further described below with reference to FIG. 8. Finally, parameters G, G.sub.T, N, g, e, and the calculated groups of parameters h.sub.0, . . . , h.sub.k-1, f.sub.0, . . . , f.sub.k-1 are output as public parameters (block 57), while p.sub.1, p.sub.2, and p.sub.3 are stored (block 58) by the data owner as private parameters.

[0028] Once set-up has been performed, public keys and secret keys for the data owner and one or more users can be generated. For example, upon hiring a new employee, a public and secret key can be generated for the employee to access the encrypted data stored on a cloud based server and owned by the employer. FIG. 4 is a flow diagram showing, by way of example, a process 60 for generating public and secret keys. Group G is accessed from the public set-up parameters and two elements from the group are randomly selected (block 61). In one embodiment, the elements can be determined by sampling γ and {tilde over (γ)} from group Z.sub.N, another public set-up parameter, and then using the group generator ġ from the set up phase as follows, g=ġ.sup.γ, {tilde over (g)}=ġ.sup.{tilde over (γ)}.

[0029] Additionally, two groups of two elements each are randomly selected (block 62) from set Z.sub.N. For example, α, {tilde over (α)}←.sub.N and b, {tilde over (b)}←.sub.N. The public key is computed (block 63) using the random elements from G and the two groups of random elements for Z.sub.N. Specifically, the random elements from G and from Z.sub.N are computed to generate g.sup.a, g.sup.b, {tilde over (g)}.sup.ã, and {tilde over (g)}.sup.{tilde over (b)}. The public key is then output (block 65) as pk=((g, g.sup.a, g.sup.b), ({tilde over (g)}, {tilde over (g)}.sup.ã, {tilde over (g)}.sup.{tilde over (b)})).

[0030] Meanwhile, the secret key is computed (block 64) based on both groups of random elements selected from Z.sub.N and one of the secret parameters. In one embodiment, p.sub.1 is used for the secret parameter; however, another one of the secret parameters can be used. The private key is then output (block 65) as sk=((a, b, g), (ã, {tilde over (b)}, {tilde over (g)}), p.sub.1). Upon output (block 65), the public and secret keys can be maintained by the data owner, as well as provided to the associated user for accessing stored data. Use of the parameters from the set-up phase can also be used to generate public and secret keys for the data owner using the above identified processes.

[0031] Prior to storing data, especially sensitive data, on cloud based servers, the data owner can encrypt the data to help prevent breach, as well as reduce access to the data should breach occur. FIG. 5 is a flow diagram showing, by way of example, a process 70 for encrypting data using the public key of FIG. 4. Data, such as messages, to be encrypted are received (block 71) with a public key of the data owner. Each message is divided (block 72) into segments n and each segment is then divided (block 73) into two blocks, M.sub.i.sup.[1] and M.sub.i.sup.[2]. In one embodiment, the message segments are divided using secret sharing; however, other processes for dividing the message segments are possible.

[0032] For each message, all of the first message blocks M.sub.i.sup.[1] are collected (block 74) and all of the second message blocks M.sub.i.sup.[2] are collected (block 77). Subsequently, an encode algorithm is run (blocks 75, 78) separately on the first set of blocks and the second set of blocks. The algorithm for each group of blocks can be run simultaneously or asynchronously. The encode algorithm receives as input the public key of the data owner pk=((g, g.sup.a, g.sup.b), ({tilde over (g)}, {tilde over (g)}.sup.{tilde over (α)}, {tilde over (g)}.sup.{tilde over (b)})) and a message. In one embodiment, the encode algorithm is as follows:

[00002]$\mathrm{Encode}\left({\left\{g_i\right\}}_{i=0}^{k-1},\left(m_0,\mathrm{.Math.}.Math..Math.m_{k-1}\right)\right)=\underset{i=0}{\overset{k-1}{.Math.}}.Math..Math.g_i^{m_i}$

During running of the encode algorithm, two groups of two elements are sampled from Z.sub.N, r, s←Z.sub.N and {tilde over (r)}, {tilde over (s)}←Z.sub.N, and are used to encode the message. Specifically, the group of first message blocks are encrypted to generate (block 76) ciphertext C.sub.1 according to the following equation:

C.sub.1=((g.sup.a).sup.r,(g.sup.b).sup.s,g.sub.r+s.Math.Encode({h.sub.i}.sub.I=0.sup.k-1,(m.sub.0[1], . . . ,m.sub.k-1[1])))

where h.sub.i represents a portion of the public parameters identified during the set-up phase, as described above with reference to FIG. 3. Meanwhile, the group of second message blocks are encrypted to generate (block 79) ciphertext C.sub.2 according to the following equation:

C.sub.2=(({tilde over (g)}.sup.ã).sup.{tilde over (r)},({tilde over (g)}.sup.{tilde over (b)}),{tilde over (g)}.sup.{tilde over (r)}+{tilde over (s)}.Math.Encode({f.sub.i}.sub.I=0.sup.k-1,(m.sub.0[2], . . . ,m.sub.k-1[2])))

where f.sub.i represents a portion of the public parameters identified during the set up phase, as described above with reference to FIG. 3. Ciphertext for the first message blocks C.sub.1 and the second message blocks C.sub.2 are then combined (block 80) as the ciphertext C=(C.sub.1, C.sub.2) for the message, which is then output (block 81) as the encrypted message.

[0033] Once the encrypted data is stored, a user can analyze the data by submitting a query. Results of the query can be identified via a cloud based server, for example. However, prior to providing the results to the requesting user, the encrypted results are re-encrypted from under the data owner's public key to under the user's public key. FIG. 6 is a flow diagram showing, by way of example, a process 90 for generating a re-encryption key. The secret key sk=((a, b, g), (ã, {tilde over (b)}, {tilde over (g)}), p.sub.1) of the data owner and the public key pk=((g, g.sup.a, g.sup.b), ({tilde over (g)}, {tilde over (g)}.sup.ã, {tilde over (g)}.sup.{tilde over (b)})) of the user are received (block 91) as input. Each of the secret key of the data owner and the public key of the user are parsed (block 92), and two elements are randomly selected (block 93) from the set Z.sub.N, z, {tilde over (z)}←Z.sub.N. The re-encryption key, r.sub.k, is computed in two parts as follows:

[00003]${\mathrm{rk}}_{S.fwdarw.R}=\left(\left(Z_1,Z_2,Z_3\right),\left({\tilde{Z}}_1,{\tilde{Z}}_2,{\tilde{Z}}_3\right)\right),\mathrm{where}.Math.\left(Z_1,Z_2,Z_3\right)=\left({\left(g_R^{a_R}\right)}^{\frac{z}{a_s}},{\left(g_R^{b_R}\right)}^{\frac{z}{b_s}},g_R^z\right)$$\left({\tilde{Z}}_1,{\tilde{Z}}_2,{\tilde{Z}}_3\right)=(\left({\left({\tilde{g}}_R^{{\tilde{a}}_R}\right)}^{\frac{\tilde{z}}{{\tilde{a}}_s}},{\left({\tilde{g}}_R^{{\tilde{b}}_R}\right)}^{\frac{\tilde{z}}{{\tilde{b}}_s}},{\tilde{g}}_R^{\tilde{z}}\right)$

Specifically, a first half of the re-encryption key is computed (block 94) using the first random element z selected from the set Z.sub.N, a first part of the data owner's secret key (a, b, g), and a first part of the user's public key (a, g.sup.a, g.sup.b). Also, a second half of the reencyption key is computed (block 95) using the second random element {tilde over (z)} selected from the set Z.sub.N, a second part of the data owner's secret key (ã, {tilde over (b)}, {tilde over (g)}), and a second part of the user's public key ({tilde over (g)}, {tilde over (g)}.sup.ã, {tilde over (g)}.sup.{tilde over (b)}). Once calculated, the two parts of the reencyption key are combined (block 96) and output (block 97) for reencypting the encrypted data results.

[0034] Re-encrypting ciphertext of the encrypted data allows a user to decrypt the data using his secret key, rather than the secret key of the data owner, and provides an additional level of security. FIG. 7 is a flow diagram showing, by way of example, a process 100 for re-encrypting ciphertext using the re-encryption key of FIG. 6. The re-encryption key rk.sub.S.fwdarw.R=((Z.sub.1, Z.sub.2, Z.sub.3), ({tilde over (Z)}.sub.1, {tilde over (Z)}.sub.2, {tilde over (Z)}.sub.3)) for the requesting user and ciphertext C=(C.sub.1, C.sub.2) of the encrypted data results are received (block 101) as input. In one embodiment, C.sub.1=(W, X, Y), where: [0035] W=(g.sup.a).sup.r [0036] X=(g.sup.b).sup.s [0037] Y=g.sup.r+s.Math.Encode ({h.sub.i}.sub.i=0.sup.k-1, (m.sub.0[1], . . . , m.sub.k-1[1]))
and C.sub.2=({tilde over (W)}, {tilde over (X)}, {tilde over (Y)}), where: [0038] {tilde over (W)}=({tilde over (g)}.sup.ã).sup.{tilde over (r)} [0039] {tilde over (X)}=({tilde over (g)}.sup.{tilde over (b)}).sup.{tilde over (s)} [0040] {tilde over (Y)}={tilde over (g)}.sup.{tilde over (r)}+{tilde over (s)}.Math.Encode ({f.sub.i}.sub.i=0.sup.k-1, (m.sub.0[2], . . . , m.sub.k-1[2]))
Component wise pairing of a first half of the re-encryption key and a first half of the ciphertext is computed (block 102) as a first part of the re-encrypted ciphertext as follows: [0041] E=e(W, Z.sub.1) [0042] F=e(X, Z.sub.2) [0043] G=e(Y, Z.sub.3)
Component-wise pairing of the second half of the re-encryption key and the second half of the ciphertext is computed (block 103) as a second part of the re-encrypted ciphertext as follows: [0044] {tilde over (E)}=e({tilde over (W)}, {tilde over (Z)}.sub.1) [0045] {tilde over (F)}=e({tilde over (X)}, {tilde over (Z)}.sub.2) [0046] {tilde over (G)}=e({tilde over (Y)}, {tilde over (Z)}.sub.3)
The first and second parts of the re-encrypted ciphertext are combined (block 104) as C.sub.R=((E, F, G),({tilde over (E)}, {tilde over (F)}, {tilde over (G)})) and output (block 105) as the re-encrypted data.

[0047] Once the user receives the re-encrypted data results, the secret key of the user can be used to decrypt the re-encrypted data. Additionally, the data owner can decrypt the encrypted data, if necessary, using the data owner's secret key. FIG. 8 is a flow diagram showing, by way of example, a process 110 for decrypting ciphertext. Ciphertext and a decryption key are received (block 111) as input. The ciphertext can be a fresh ciphertext, C=(C.sub.1, C.sub.2), such as data encrypted by the data owner, or a sum of fresh ciphertexts, which includes re-encrypted ciphertext, C.sub.R=((E, F, G), ({tilde over (E)}, {tilde over (F)}, {tilde over (G)})). Also, the decryption key can include a secret key, sk=((a, b, g), (ã, {tilde over (b)}, {tilde over (g)}), p.sub.1) of the data owner or a secret key of the user, depending on the ciphertext to be decrypted. A user or data owner submits (block 112) a request for decryption of the ciphertext and a decode algorithm is accessed (block 113). A determination of the ciphertext type is made, including whether the ciphertext is fresh or a sum of fresh ciphertext, such as the re-encrypted ciphertext. In one embodiment, the ciphtertext can be classified automatically or alternatively, the classification type can be input by an individual or other user.

[0048] If the ciphertext is fresh, the oracle generated during set-up is accessed (block 114) and a first part of the fresh ciphertext is processed (block 115) via the oracle and a Decode algorithm. Specifically, the first part of the fresh ciphertext C.sub.1=(W, X, Y) is used to compute the following:

[00004]$\frac{Y}{W^{1/a}.Math.X^{1/b}},$

where a and b are obtained from the secret key.
Once the values of W, X, and Y, which are provided above with respect to FIG. 5, are entered, the equation appears as follows:

[00005]$\frac{g^{r+s}.Math.\mathrm{Encode}\left({\left\{h_i\right\}}_{i=0}^{k-1},\left(m_0\left[1\right],\mathrm{.Math.}.Math.,m_{k-1}\left[1\right]\right)\right)}{g^r.Math.g^s}=\mathrm{Encode}\left({\left\{h_i\right\}}_{i=0}^{k-1},\left(m_0\left[1\right],\mathrm{.Math.}.Math.,m_{k-1}\left[1\right]\right)\right)$

[0049] The oracle is queried via the encode algorithm and

[00006]$\frac{Y}{W^{1/a}.Math.X^{1/b}}$

is input into me oracle, which outputs (block 116) the first message blocks M.sub.i.sup.[1] associated with the first part of the ciphertext using the decode algorithm below:

Decode(0,2.sup.ω−1,p.sub.1,{h.sub.i}.sub.i=0.sup.k-1inp),

where p.sub.1 is a private parameter and h.sub.i includes public parameters, both of which are discussed above with respect to FIG. 3. Further, the minimum i=0 and maximum k−1 parameters of the decode algorithm represent an expected range of original plaintext values, 2̂{k(w−1)}. Output of the oracle includes plaintext of the first blocks of the message segments (m.sub.0[1], . . . , m.sub.k-1[1]).

[0050] Simultaneously to or asynchronously to processing of the first part of the ciphertext, processing (block 117) of the second part of the ciphertext C.sub.2=({tilde over (W)}, {tilde over (X)}, {tilde over (Y)}) can occur via the Decode algorithm, without the oracle. Specifically, the following is computed using the second part of the ciphertext, as follows:

[00007]$\frac{\tilde{Y}}{{\tilde{W}}^{\tilde{a}-1}.Math.{\tilde{X}}^{\tilde{b}-1}}$

Once the values of {tilde over (W)}, {tilde over (X)}, and {tilde over (Y)}, which are provided above with respect to FIG. 5, the equation appears as follows:

[00008]$\frac{{\tilde{g}}^{\tilde{r}+\tilde{s}}.Math.\mathrm{Encode}\left({\left\{f_i\right\}}_{i=0}^{k-1},\left(m_0\left[2\right],\mathrm{.Math.}.Math.,m_{k-1}\left[2\right]\right)\right)}{{\tilde{g}}^{\tilde{r}}.Math.{\tilde{g}}^{\tilde{s}}}=\mathrm{Encode}\left({\left\{f_i\right\}}_{i=0}^{k-1},\left(m_0\left[2\right],\mathrm{.Math.}.Math.,m_{k-1}\left[2\right]\right)\right)$

Subsequently, the Decode algorithm is run as provided below:

Decode(0,2.sup.ω−1,p.sub.2,{f.sub.i}.sub.i=0.sup.k-1),Encode({f.sub.i}.sub.i=0.sup.k-1,(m.sub.0[2], . . . ,m.sub.k-1[2]))

Results of the Decode algorithm include plaintext of the second blocks (block 118) of the message segments, (m.sub.0[2], . . . , m.sub.k-1[2]). Finally, the plaintext of the first and second blocks of the message segments are combined (block 119) as the decrypted message, which is output (block 120) to the user for processing and analysis, such as for conducting market research or identifying behavior trends and patterns.

[0051] If the ciphertext is determined to be a sum of freshly generated ciphertext, such as the re-encrypted ciphertext, decryption can be performed as provided above, except that the minimum and maximum parameters in the decode algorithm are computed based on the expected range of plaintext messages in the original fresh ciphertexts and a total number of such fresh ciphertexts added.

[0052] While the invention has been particularly shown and described as referenced to the embodiments thereof, those skilled in the art will understand that the foregoing and other changes in form and detail may be made therein without departing from the spirit and scope of the invention.