# Patent

## Title
Methods and apparatus for providing secure two-party public key cryptosystem

## Abstract

Techniques for an efficient and provably secure protocol by which two parties, each holding a share of a Cramer-Shoup private key, can jointly decrypt a ciphertext, but such that neither party can decrypt a ciphertext alone. In an illustrative embodiment, the secure protocol may use homomorphic encryptions of partial Cramer-Shoup decryption subcomputations, and three-move Σ-protocols for proving consistency.

## Background
FIELD OF THE INVENTION
The present invention relates to cryptography and, more particularly, to techniques for providing a secure two-party public key cryptosystem implementing Cramer-Shoup based decryption.
BACKGROUND OF THE INVENTION
A two-party Cramer-Shoup cryptosystem would fall into the general category of threshold cryptography. There have been previous proposals for threshold cryptosystems secure against adaptive chosen ciphertext attack.
For example, in V. Shoup et al, “Securing Threshold Cryptosystems Against Chosen Ciphertext Attack,” EUROCRYPT '98, pp. 1-16, 1998; R. Canetti et al., “An Efficient Threshold Public Key Cryptosystem Secure Against Adaptive Chosen Ciphertext Attack,” EUROCRYPT '99 (LNCS 1592), pp. 90-106, 1999; M. Abe, “Robust Distributed Multiplication without Interaction,” CRYPTO '99 (LNCS 1666), pp. 130-147, 1999; S. Jarecki et al, “Adaptively Secure Threshold Cryptography: Introducing Concurrency, Removing Erasures,” EUROCRYPT 2000 (LNCS 1807), pp. 221-242, 2000; and P. Fouque et al., “Threshold Cryptosystems Secure Against Chosen-Ciphertext Attack,” ASIACRYPT '01 (LNCS 2248), pp. 351-368, 2001, the disclosures of which are incorporated by reference herein, cryptosystems are disclosed wherein it is assumed that an adversary corrupts t out of n decryption servers.
Both the V. Shoup et al. proposal and the P. Fouque et al. proposal may be used in the two-party case (t=1, n=2) if one is only concerned with security and not robustness, but they also both use the non-standard assumption that hashes are modeled as random oracles. The random oracle assumption is discussed in M. Bellare et al., “Random Oracles are Practical: A Paradigm for Designing Efficient Protocols,” 1st ACM Conference on Computer and Communications Security, pp. 62-73, November 1993; and O. Goldreich et al., “Random Oracle Methodology, Revisited,” 30th ACM Symposium on Theory of Computing, pp. 209-218, 1998, the disclosures of which are incorporated by reference herein.
Certain of the above-mentioned proposals are based on the Cramer-Shoup cryptosystem. R. Canetti et al. assumes that there are users that wish to have messages decrypted, and that servers of the cryptosystem do not communicate with each other, but only with the users. R. Canetti et al. shows a secure system for n>2t, a secure and robust system for n>t2, and a secure and robust system for n>2t if the users are given extra per-ciphertext robustness information. In M. Abe, the servers are allowed to communicate with each other, and the disclosed techniques present secure and robust systems for n>2t. However, none of these proposals apply to the scenario where t=1 and n=2. In fact, it is often the case that threshold cryptosystems (assuming a strict minority of corrupted players) are developed before the corresponding two-party cryptosystems.
In summary, previous proposals on threshold cryptosystems secure against adaptive chosen ciphertext attack require: (1) the random oracle assumption and are thus not proven secure in a standard model; or (2) a strict majority of uncorrupted decryption servers.
Thus, there exists a need for techniques which overcome the drawbacks associated with the proposals described above and which thereby provide more efficient protocols for performing two-party Cramer-Shoup based decryption.
SUMMARY OF THE INVENTION
The present invention provides a provably secure protocol for a two-party Cramer-Shoup cryptosystem. More specifically, techniques are provided for an efficient and provably secure protocol by which two parties, each holding a share of a Cramer-Shoup private key, can jointly decrypt a ciphertext, but such that neither party can decrypt a ciphertext alone.
For example, in one aspect of the invention, a technique for use in a device associated with a first party for decrypting a ciphertext, according to a Cramer-Shoup based encryption scheme, comprises the following steps/operations. First, the ciphertext is obtained in the first party device. Then, the first party device generates a plaintext corresponding to the ciphertext based on assistance from a device associated with a second party, the plaintext representing a result of the decryption according to the Cramer-Shoup based encryption scheme.
The generating step/operation may further comprise an exchange of information between the first party device and the second party device whereby at least a portion of the information is encrypted using an encryption technique such that one party encrypts information using its own public key and another party can not read the information but can use the information to perform an operation.
The generating step/operation may further comprise an exchange of information between the first party device and the second party device whereby at least a portion of the information is encrypted using an encryption technique having a homomorphic property.
Further, the first party device and the second party device may additively share components of a private key.
The generating step/operation may further comprise: generating a share of a random secret; generating information representing encryptions of a form of the random secret, a share of a private key, and the ciphertext; transmitting at least the encrypted information to the second party device; and computing the plaintext based at least on the share of the random secret, the share of the private key, the ciphertext, and the data received from the second party device.
The generating step/operation may further comprise generation and exchange of proofs between the first party device and the second party device that serve to verify operations performed by each party. The proofs may be consistency proofs based on three-move Σ-protocols.
Accordingly, in an illustrative embodiment, the secure protocol may use homomorphic encryptions of partial Cramer-Shoup decryption subcomputations, and three-move Σ-protocols for proving consistency.
These and other objects, features and advantages of the present invention will become apparent from the following detailed description of illustrative embodiments thereof, which is to be read in connection with the accompanying drawings.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 is a flow diagram illustrating a two-party Cramer-Shoup based decryption protocol in accordance with an embodiment of the present invention; and
FIG. 2 is a block diagram illustrating a generalized hardware architecture of a data network and computer systems suitable for implementing one or more of the methodologies according to the present invention.



DETAILED DESCRIPTION OF PREFERRED EMBODIMENTS
The following description will illustrate the invention in the context of an illustrative distributed environment implementing Cramer-Shoup based decryption. However, it should be understood that the invention is not limited to such an environment. Rather, the invention is instead more generally applicable to any environment where it is desirable to provide a cryptosystem wherein two parties can efficiently perform secure Cramer-Shoup based decryption. By way of example and without limitation, it is to be understood that a “device,” as used herein, may include any type of computing system, e.g., a personal computer (including desktops and laptops), a personal digital assistant (PDA), a smartcard, a cellular phone, a server, a hardware token, a software program, etc. However, it is to be understood that the protocols of the invention may be implemented between any two parties or entities using one or more of such devices.
As will be illustratively explained in detail below, the present invention provides an efficient and provably secure protocol by which two parties, respectively designated herein as “alice” (or a first party) and “bob” (or a second party), each holding a share of a Cramer-Shoup private key, can jointly decrypt a ciphertext, but such that neither alice nor bob can decrypt a ciphertext alone. It is to be appreciated that the general concepts and definitions associated with Cramer-Shoup encryption/decryption operations are well known in the field of cryptography. By way of example, R. Cramer et al., “A Practical Public-key Cryptosystem Provably Secure Against Adaptive Chosen Ciphertext Attack,” CRYPTO '98 (LNCS 1462), pp. 13-25, 1998; and R. Cramer et al., “Universal Hash Proofs and a Paradigm for Adaptive Chosen Ciphertext Secure Public-key Encryption,” EUROCRYPT 2002 (LNCS 2332), pp. 45-64, 2002, the disclosures of which are incorporated by reference herein, describe details on Cramer-Shoup encryption/decryption operations.
Advantageously, the present invention provides a provably secure protocol for a two-party Cramer-Shoup cryptosystem. The invention may be used in accordance with a variety of applications.
By way of one example, the invention can be used for a secure distributed third-party decryption service, which requires the joint agreement by two parties to decrypt a ciphertext. For example, this may be used to provide added security to: (1) a key recovery system by law enforcement, e.g., S. Micali, “Fair Public-key Cryptosystems,” CRYPTO '92 (LNCS 740), pp. 113-138, 1992, the disclosure of which is incorporated by reference herein; or (2) an “offline trusted third party” system in a fair exchange protocol, e.g., N. Asokan et al., “Optimistic Protocols for Fair Exchange,” 3rd ACM Conference on Computer and Communications Security, pp. 6-17, 1996, the disclosure of which is incorporated by reference herein.
Another application involves techniques by which a device that performs private key operations (signatures or decryptions) in networked applications, and whose local private key is activated with a password or PIN (personal identification number), can be immunized against offline dictionary attacks in case the device is captured, e.g., P. MacKenzie et al., “Networked Cryptographic Devices Resilient to Capture,” DIMACS Technical Report 2001-19, May 2001, extended abstract in 2001 IEEE Symposium on Security and Privacy, May 2001; and the U.S. patent application identified as Ser. No. 10/072,331, filed on Feb. 7, 2002 in the name of P. MacKenzie et al., and entitled “Methods and Apparatus for Providing Networked Cryptographic Devices Resilient to Capture,” the disclosures of which are incorporated by reference herein.
Briefly, the goal of immunization against offline attack may be achieved by involving a remote server in the device's private key computations, essentially sharing the cryptographic computation between the device and the server. The above work by P. MacKenzie et al. shows how to accomplish this for the case of RSA (Rivest-Shamir-Adleman) functions and certain discrete-log-based functions.
The work in P. MacKenzie et al., “Two-party Generation of DSA Signatures,” CRYPTO 2001 (LNCS 2139), pp. 137-154, 2001; and the U.S. patent application identified as Ser. No. 10/183,900, filed on Jun. 26, 2002 in the name of P. MacKenzie et al., and entitled “Methods and Apparatus for Two-Party Generation of DSA Signatures,” the disclosures of which are incorporated by reference herein, provides techniques for immunization against offline attack in accordance with two-party DSA signatures.
The present invention may be implemented so as to provide techniques for immunization against offline attack in accordance with two-party Cramer-Shoup encryption/decryption operations. Moreover, the inventive cryptosystem makes no extra assumptions beyond those made in the original Cramer-Shoup cryptosystem (disclosed in the above-referenced work by R. Cramer et al.), and the inventive cryptosystem is proven secure in the standard model (without random oracles).
To achieve the above and other features and advantages, the invention introduces novel techniques including the use of homomorphic encryptions of partial Cramer-Shoup decryption subcomputations, and special three-move Σ-protocols for proving consistency. These Σ-protocols are especially noteworthy in that: (1) they are not required to be (fully) zero-knowledge, and are used as proofs of consistency rather than proofs of knowledge, and thus they can be used in a concurrent setting (since neither simulation of provers nor extraction of witnesses is needed); and (2) their secure use relies in a fundamental way on the hardness of DDH (Decision Diffie-Hellman), though their soundness and (honest-verifier) zero-knowledge properties do not.
Before explaining an illustrative protocol of the invention, we first introduce some definitions and notations which will be used in accordance with the explanation.
Security parameter. Let κ be the cryptographic security parameter used for, e.g., hash functions and discrete log group orders. Exemplary values may be κ=160 or κ=256.
Notation and definitions. We use (a, b)×(c, d) to mean element-wise multiplication, i.e., (ac, bd). We use (a, b)r to mean element-wise exponentiation, i.e., (ar, br). For a tuple V, the notation V[j] means the jth element of V.
Let Gq denote a finite (cyclic) group of prime order q, where |q|=κ. Let g be a generator of Gq, and assume it is included in the description of Gq. Note that in the following definitions and descriptions, we will relax notation slightly and let Gq denote its own description. For instance, when we say the input to a function is Gq, we mean that the input is the description of the group Gq.
Let “zS” denote the assignment to z of an element of S selected uniformly at random. Let ≡q denote equivalence modulo q.
Encryption schemes. An encryption scheme cis a triple (Gε, E, D) of algorithms, the first two being probabilistic polynomial-time, and the last being deterministic polynomial time. Gε takes as input Gq and outputs a public key pair pk, sk), i.e., (pk, sk)←Gε(Gq). Note that, for convenience, instead of using input 1κ, we will simply use a fixed group Gq with |q|=κ and define encryption schemes over this group. E takes a public key pk and a message m as input and outputs an encryption c for m; we denote this c←Epk(m). D takes a ciphertext c and a secret key sk as input and returns either a message m such that c is a valid encryption of m under the corresponding public key, if such an m exists, and otherwise returns an arbitrary value.
Now we define the Cramer-Shoup encryption scheme using a fixed universal one-way hash function H and over a fixed group Gq, in which solving DDH is difficult. Note that one possible group Gq may be found by generating a large prime p such that q divides p−1, and letting Gq be the subgroup of order q in ZP*.
GCS(Gq): Let g be the generator of Gq (implicitly included in the description of Gq). Generate




  
    
      g
      2
    
    ⁢
    
      ←
      R
    
    ⁢
    
      G
      q
    
  
  ,




and a, b, c, d,





  
    e
    ⁢
    
      ←
      R
    
    ⁢
    
      Z
      q
    
  
  ,




and set U←ga(g2)b, V←gc(g2)d, and W←ge. Let <g, g2, U, V, W> be the public key and <a, b, c, d, e> be the secret key.

E<g, g2, U, V, W>(m): Generate




  r
  ⁢
  
    ←
    R
  
  ⁢
  
    Z
    q
  




and compute x←gr, y←(g2)r, w←Wrm, σ←H(x, y, w), and v←UrVrσ. Return <x, y, w, v> as the ciphertext.

D<a, b, c, d, e>(<x, y, w, v>): Generate σ←H(x, y, w). If v≠xa+cσyb+dσ, return ⊥, else return w/xe.
The above-referenced work of R. Canetti et al. gives a variation of this protocol in which D<a, b, c, d, e>(<x, y, w, v>) generates σ as above, but then generates




  s
  ⁢
  
    ←
    R
  
  ⁢
  
    Z
    q
  




and returns w/(xe(v/v′)s), where v′=xa+cσyb+dσ. One can see that for invalid encryptions (those in which the original D function returns ⊥) the new decryption function will return a completely random value, and for all other encryptions, the new decryption function returns the same value as the original. The two-party protocol of the invention is able to perform the R. Canetti et al. variation of the decryption procedure.

System Model.
The inventive system includes two parties, alice and bob, who obtain public and secret data through a trusted initialization procedure. Here we will simply assume alice and bob receive all their public and secret data from a trusted party. After initialization, communication between alice and bob occurs in sessions (or decryption protocol runs), one per ciphertext that they decrypt together. Alice plays the role of session initiator in the decryption protocol. That is, alice receives requests to decrypt ciphertexts, and communicates with bob to decrypt these ciphertexts. We presume that each message between alice and bob is implicitly labeled with an identifier for the session to which it belongs. Multiple decryption sessions may be executed concurrently.
There is a network that alice and bob use to communicate with each other in the inventive protocol. For purposes of the proof of security, we may assume an adversary controls the network, inserting and manipulating communication as it chooses. In addition, the adversary takes one of two forms: an alice-compromising adversary that has perpetual read access to the private storage and computation of alice, and a bob-compromising adversary that has perpetual read access to the private storage and computation of bob.
We note that a proof of security in this two-party system extends to a proof of security in an n-party system in a natural way, assuming the adversary decides which parties to compromise before any session begins. The basic idea is to guess for which pair of parties the adversary decrypts a ciphertext without the assistance of the non-corrupted party, and focus the simulation proof on those two parties, running all other parties as in the real protocol. The only consequence is a factor of roughly n2 lost in the reduction argument from the security of the encryption scheme.
Labeled Ciphertexts.
Note that in this illustrative scenario, alice decides on which ciphertexts to decrypt. This removes the need to include in the illustrative model separate users that communicate with alice and bob to obtain decryptions, and allows us not to have to change the encryption scheme to use explicit labels. Of course, the Cramer-Shoup encryption scheme does allow an easy way to introduce labels, and this could also be done in the inventive protocol.
1. Definition and Basic Theory of Σ-Protocols
The illustrative two-party decryption system of the invention, to be described in detail below, may use special types of Σ-protocols to deal with malicious adversaries. Thus, here we overview the basic definitions and properties of Σ-protocols. Σ-protocols are generally described in R. Cramer et al., “Proofs of Partial Knowledge and Simplified Design of Witness Hiding Protocols,” CRYPTO '94 (LNCS 839), pp. 174-187, 1994; and R. Cramer, “Modular Design of Secure Yet Practical Cryptographic Protocols, Ph.D. Thesis, CWI and University of Amsterdam, 1997, the disclosures of which are incorporated by reference herein.
First, we start with definitions and notation. Let R={(x, w)} be a binary relation and assume that for some given polynomial p(•) it holds that |w|≦p(|x|) for all (x, w)εR. Furthermore, let R be testable in polynomial time. Let LR={x: ∃w, (x, w)εR} be the language defined by the relation, and for all xεLR, let WR(x)={w: (x, w)εR} be the witness set for x. For any NP language L, note that there is a natural witness relation R containing pairs (x, w) where w is the witness for the membership of x in L, and that LR=L.
Now we define a Σ-protocol (A, B) to be a three-move interactive protocol between a probabilistic polynomial-time prover A and a probabilistic polynomial-time verifier B, where the prover acts first. The verifier is only required to send random bits as a challenge to the prover. For some (x, w)εR, the common input to both players is x while w is private input to the prover. For such given x, let (a, c, z) denote the conversation between the prover and the verifier. To compute the first and final messages, the prover invokes efficient algorithms a(•) and z(•), respectively, using (x, w) and random bits as input. Using an efficient predicate φ(•), the verifier decides whether the conversation is accepting with respect to x. The relation R, the algorithms a(•), z(•) and φ(•) are public. The length of the challenges is denoted tB, and we assume that tB only depends on the length of the common string x. In the following, we will always use challenges randomly drawn from Zq.
This definition is slightly broadened to deal with cheating provers. We will define {circumflex over (L)}R to be the input language, with the properties that LR⊂{circumflex over (L)}R, and that membership in {circumflex over (L)}R may be tested in polynomial time. We implicitly assume B only executes the protocol if the common input xε{circumflex over (L)}R.
All Σ-protocols presented here will satisfy the following security properties:
1. weak special soundness: Let (a, c, z) and (a, c′, z′) be two conversations, that are accepting for some given x. If c≠c′, then xεLR. Often these protocols are assumed to satisfy special soundness: On input x and those two conversations, a witness w such that (x, w)εR can be computed efficiently. We do not need special soundness for the illustrative results. The pair of accepting conversations (a, c, z) and (a, c′, z′) with c≠c′ is called a collision.
2. special honest verifier zero knowledge (special HVZK): There is a (probabilistic polynomial time) simulator M that on input xεLR generates accepting conversations with the exact same distribution as when A and B execute the protocol on common input x (and A is given a witness w for x), and B indeed honestly chooses its challenges uniformly at random. The simulator is special in the sense that it can additionally take a random string c as input, and output an accepting conversation for x where c is the challenge. In fact, the simulator will have this special property for not only xεLR, but also any xε{circumflex over (L)}R.
A simple but important fact is that if a Σ-protocol is HVZK, the protocol is perfectly witness indistinguishable (WI), e.g., U. Feige et al., “Witness Indistinguishable and Witness Hiding Protocols,” 22nd ACM Symposium on Theory of Computing, pp. 416-426, 1990, the disclosure of which is incorporated by reference herein. Although HVZK by itself is defined with respect to a very much restricted verifier, i.e., an honest one, this means that if for a given instance x there are at least two witnesses w, then even an arbitrarily powerful and malicious verifier cannot distinguish which witness the prover uses.
As an example, we give a Σ-protocol (ADH, BDH) for RDH, the Diffie-Hellman relation over Gq, i.e., RDH={(g′, h, h′), w)} where h=gw and h′=(g′)w, and {circumflex over (L)}RDH=(Gq)3. Given public input (g′, h, h′), say ADH knows w such that ((g′, h, h′), w)εRDH. For its first message, ADH chooses r←Zq, computes y←gr, and y′←(g′)r, and outputs (y, y′). On challenge c, ADH computes s←wc+r and outputs s. BDH verifies gs=hcy and (g′)s=(h′)cy′.
In the illustrative results to follow, we use a generalization of a corollary in R. Cramer et al. (“Proofs of Partial Knowledge and Simplified Design of Witness Hiding Protocols,” CRYPTO '94 (LNCS 839), pp. 174-187, 1994) which enables a prover, given two relations (R1, R2), values (x1, x2)ε{circumflex over (L)}R1×{circumflex over (L)}R2, and corresponding 3-move Σ-protocols ((A1, B1), (A2, B2)), to present a 3-move Σ-protocol (Aor, Bor) for proving the existence of a w such that either (x1, w)εR1 or (x2, w)εR2. We call this the “OR” protocol for ((A1, B1), (A2, B2)).
We will describe the protocol assuming the challenges from (A1, B1) and (A2, B2) are of the same length. This can easily be generalized, as long as the challenge length in the combined protocol is at least as long as the challenges from either protocol. The protocol comprises (A1, B1) and (A2, B2) running in parallel, but with the verifier's challenge c split into c=c1⊕c2, with c1 as the challenge for (A1, B1), and c2 as the challenge for (A2, B2).
The protocol for Aor is as follows: Without loss of generality, say Aor knows w such that (x1, w)εR1. Let M2 be the simulator for S2. Then Aor runs M2 (x2) to generate (m, e, z). The protocol sends the first message of (A1, B1), along with m as the first message of (A2, B2). On challenge c, the protocol chooses c2=e, and c1=c⊕c2. The protocol is able to provide the final response in (A1, B1) because it knows w, and the final response in (A2, B2) is simply z. The final message of Aor includes c1 along with the final responses for (A1, B1) and A2, B2).
For a relation R, let Σ[R] denote a Σ-protocol over R. For a predicate P, let Σ[P] denote Σ[R] for the relation R defined by P, with public values defined by P. Furthermore, let LP=LR and {circumflex over (L)}P={circumflex over (L)}R, for the relation R defined by P. Let Σ[X, Y] denote the “OR” protocol for (Σ[X], Σ[Y]).
2. S-CS System
In this section, an illustrative system, called S-CS (for “Secure Cramer-Shoup”), is described by which alice and bob can jointly decrypt Cramer-Shoup ciphertexts, according to an embodiment of the present invention.
The S-CS system will be illustratively described in accordance with the above-mentioned immunization against offline attack application. Such application naturally admits a trusted party for initializing the system. Alternatively, in accordance with the present invention, one could build a distributed initialization protocol involving only alice and bob, and no trusted center. To achieve provable security, this initialization could be executed in a sequential manner prior to any decryption sessions, even though the decryption sessions themselves may be executed concurrently with respect to each other.
Specifically, in accordance with the illustrative embodiment, we assume a trusted party is given a (public) group Gq with generator g and generates a Cramer-Shoup public key along with secret values for alice and bob to allow decryption:




   
  
    
      
        
          
            
              g
              2
            
            ⁢
            
              
                
                ←
              
              R
            
            ⁢
            
              G
              q
            
          
          ,
        
      
    
    
      
        
          
            a
            1
          
          ,
          
            a
            2
          
          ,
          
            b
            1
          
          ,
          
            b
            2
          
          ,
          
            c
            1
          
          ,
          
            c
            2
          
          ,
          
            d
            1
          
          ,
          
            d
            2
          
          ,
          
            e
            1
          
          ,
          
            
              e
              2
            
            ⁢
            
              
                
                ←
              
              R
            
            ⁢
            
              Z
              q
            
          
          ,
        
      
    
    
      
        
          
            <
            
              U
              1
            
          
          ,
          
            
              
                U
                2
              
              >
            
            ⁢
            
            ←
            
              <
              
                
                  
                    g
                    
                      a
                      1
                    
                  
                  ⁡
                  
                    (
                    
                      g
                      2
                    
                    )
                  
                
                
                  b
                  2
                
              
            
          
          ,
          
            
              
                
                  g
                  
                    a
                    2
                  
                
                ⁡
                
                  (
                  
                    g
                    2
                  
                  )
                
              
              
                b
                2
              
            
            >
          
          ,
        
      
    
    
      
        
          
            <
            
              V
              1
            
          
          ,
          
            
              
                V
                2
              
              >
            
            ⁢
            
            ←
            
              <
              
                
                  
                    g
                    
                      c
                      1
                    
                  
                  ⁡
                  
                    (
                    
                      g
                      2
                    
                    )
                  
                
                
                  d
                  2
                
              
            
          
          ,
          
            
              
                
                  g
                  
                    c
                    2
                  
                
                ⁡
                
                  (
                  
                    g
                    2
                  
                  )
                
              
              
                d
                2
              
            
            >
          
          ,
        
      
    
    
      
        
          
            <
            
              W
              1
            
          
          ,
          
            
              
                W
                2
              
              >
            
            ⁢
            
            ←
            
              <
              
                g
                
                  e
                  1
                
              
            
          
          ,
          
            
              g
              
                e
                2
              
            
            >
          
          ,
        
      
    
    
      
        
          
            β
            1
          
          ,
          
            
              β
              2
            
            ⁢
            
              
                
                ←
              
              R
            
            ⁢
            
              Z
              q
            
          
          ,
        
      
    
    
      
        
          
            <
            
              h
              1
            
          
          ,
          
            
              
                h
                2
              
              >
            
            ⁢
            
            ←
            
              <
              
                g
                
                  β
                  1
                
              
            
          
          ,
          
            
              g
              
                β
                2
              
            
            >
          
          ,
        
      
    
    
      
        
          
            D
            1
          
          ,
          
            D
            2
          
          ,
          
            D
            3
          
          ,
          
            D
            1
            ′
          
          ,
          
            D
            2
            ′
          
          ,
          
            
              D
              3
              ′
            
            ⁢
            
              
                
                ←
              
              R
            
            ⁢
            
              G
              q
            
          
        
      
    
  




The trusted party gives alice the values <a1, b1, c1, d1, e1, β1>, gives bob the values <a2, b2, c2, d2, e2>, and gives both alice and bob the values:

    
    
        <g, g2, U1, U2, V2, W1, W2, h1, h2, D1, D2, D3, D1′, D2′, D3′>
    
    


Letting U←U1U2, V←V1V2 and W←W1W2, the Cramer-Shoup public key is <g, g2, U, V, W>. Note that this public key is drawn from the same distribution as in the standard Cramer-Shoup key generation. Also note that only this public key is necessary for encryption, and not the partial public key values U1, U2, etc.
With respect to this initialization, it is easy to see how the standard Cramer-Shoup private keys are split between alice and bob, with their associated public values. Next, the h1 and h2 values will be used as ElGamal (e.g., T. ElGamal, “A Public Key Cryptosystem and a Signature Scheme Based on Discrete Logarithms,” IEEE Transactions on Information Theory, 31:469-472, 1985, the disclosure of which is incorporated by reference herein) public keys for alice and bob, respectively. Note that it is not necessary for bob to receive β2, since bob does not need to decrypt anything encrypted with h2. Encryptions using h2 will simply be used for consistency checking, as described below. Finally, the D1, D2, D3, D1′, D2′, D3′ values are used in order to make consistency proofs work in the concurrent setting based on DDH.
2.1 Decryption Protocol
Referring now to FIG. 1, a flow diagram illustrates a two-party decryption protocol in accordance with an embodiment of the present invention. In particular, FIG. 1 illustratively depicts a protocol 100 by which alice and bob cooperate to decrypt ciphertexts with respect to the public key <g, g2, U, V, W>. This is referred to as the S-CS protocol. As input to this protocol, alice receives a ciphertext c to be decrypted. Bob receives no input (but receives c=<x, y, w, v> from alice in the first message). The predicates Ψ, Ψ′, Γ, and Γ′ used for consistency checking are displayed without their parameters in the figure for readability. We give their full descriptions below, with parameter names that correspond to the parameters in the S-CS protocol.
The decryption protocol proceeds as follows. Upon receiving c to decrypt, alice first generates a share s1 of a random secret s as used in the above-described R. Canetti et al. variant of Cramer-Shoup decryption. Steps 102 and 104 respectively illustrate generation of hash function σ and generation of s1, r1, r2, r3, r4, in accordance with the Cramer-Shoup decryption described above. Then, alice generates ElGamal encryptions of xs1, ys1, vs1, and x−(a1+c1σ)y−(b1+d1σ) (respectively, in steps 106, 108, 110 and 112). All of these values, except vs1, are needed by bob to be able to perform bob's part of the decryption, but it is necessary to include vs1 for consistency checking, and more specifically, for the protocol's proof of security. Alice generates these encryptions under the public key h1, for which she knows the secret key. Finally, alice proves that she has generated these encryptions consistently.
Alice sends bob c and the four encryptions in step 114. Exchange 116 denotes the three-round proof that is particular to the Σ-protocol. The proof is in the form of “commit” (sent from alice to bob), “challenge” (sent from bob to alice), and “response” (sent from alice to bob, who then verifies the response).
Once bob receives c and the four encryptions from alice and accepts the proof, bob generates the hash function and his own share s2 of s (respectively, in steps 118 and 120). Note that this is an intuitive description since s itself is actually determined by s1 and s2. Next bob uses the homomorphic properties of the ElGamal encryption scheme used by alice to compute an encryption (still under the public key for which alice knows the secret key) of a partial decryption of c, using the first, second, and fourth encryptions sent by alice (step 124). Then, bob generates ElGamal encryptions of xs2, ys2, vs2, and x−s2(a2+c2σ)y−s2(b2+d2σ) (respectively, in steps 126, 128, 130 and 132) under the public key h2, for which the secret key is not known to alice. Finally, bob proves that he has generated these encryptions consistently. Note that the extra encryptions are not necessary for any computations of alice, but are used for consistency checking, and more specifically, for the protocol's proof of security.
Bob sends alice the encryptions in step 134. Exchange 136 denotes the three-round proof that is particular to the Σ-protocol. Again, the proof is in the form of “commit” (sent from bob to alice), “challenge” (sent from alice to bob), and “response” (sent from bob to alice, who then verifies the response).
When alice receives the encryptions from bob and accepts the proof, alice decrypts the encryption containing bob's partial decryption of c, and then finishes the decryption of c using her local values step 138. In step 140, the result of the two-party Cramer-Shoup decryption is output.
Given g, g2, c=<x, y, w, v>, and σ=H(x, y, w), the predicates Ψ, Ψ′, Γ, and Γ′ are defined as follows:




  
    
      
        
          Ψ
          ⁡
          
            [
            
              
                U
                1
              
              ,
              
                V
                1
              
              ,
              
                E
                1
              
              ,
              
                E
                2
              
              ,
              
                E
                3
              
              ,
              
                E
                4
              
            
            ]
          
        
        ⁢
        
          =
          def
        
        ⁢
        
          
        
        ⁢
        
          [
          
            
              
                
                  
                    
                      ∃
                      
                        r
                        1
                      
                    
                    ,
                    
                      r
                      2
                    
                    ,
                    
                      r
                      3
                    
                    ,
                    
                      r
                      4
                    
                    ,
                    
                      a
                      1
                    
                    ,
                    
                      b
                      1
                    
                    ,
                    
                      c
                      1
                    
                    ,
                    
                      d
                      1
                    
                    ,
                    
                      
                        s
                        1
                      
                      ⁢
                      
                        :
                      
                    
                  
                  ⁢
                  
                    
                  
                
              
            
            
              
                
                  
                    U
                    1
                  
                  =
                  
                    
                      
                        g
                        
                          a
                          1
                        
                      
                      ⁡
                      
                        (
                        
                          g
                          2
                        
                        )
                      
                    
                    
                      b
                      1
                    
                  
                
              
            
            
              
                
                  
                    ⩓
                    
                      V
                      1
                    
                  
                  =
                  
                    
                      
                        g
                        
                          c
                          1
                        
                      
                      ⁡
                      
                        (
                        
                          g
                          2
                        
                        )
                      
                    
                    
                      d
                      1
                    
                  
                
              
            
            
              
                
                  
                    ⩓
                    
                      E
                      1
                    
                  
                  =
                  
                    (
                    
                      
                        g
                        
                          r
                          1
                        
                      
                      ,
                      
                        
                          
                            (
                            
                              h
                              1
                            
                            )
                          
                          
                            r
                            1
                          
                        
                        ⁢
                        
                          x
                          
                            s
                            1
                          
                        
                      
                    
                    )
                  
                
              
            
            
              
                
                  
                    ⩓
                    
                      E
                      2
                    
                  
                  =
                  
                    (
                    
                      
                        g
                        
                          r
                          2
                        
                      
                      ,
                      
                        
                          
                            (
                            
                              h
                              1
                            
                            )
                          
                          
                            r
                            2
                          
                        
                        ⁢
                        
                          y
                          
                            s
                            1
                          
                        
                      
                    
                    )
                  
                
              
            
            
              
                
                  
                    ⩓
                    
                      E
                      3
                    
                  
                  =
                  
                    (
                    
                      
                        g
                        
                          r
                          3
                        
                      
                      ,
                      
                        
                          
                            (
                            
                              h
                              1
                            
                            )
                          
                          
                            r
                            3
                          
                        
                        ⁢
                        
                          v
                          
                            s
                            1
                          
                        
                      
                    
                    )
                  
                
              
            
            
              
                
                  
                    ⩓
                    
                      E
                      4
                    
                  
                  =
                  
                    (
                    
                      
                        g
                        
                          r
                          4
                        
                      
                      ,
                      
                        
                          
                            (
                            
                              h
                              1
                            
                            )
                          
                          
                            r
                            4
                          
                        
                        ⁢
                        
                          x
                          
                            -
                            
                              (
                              
                                
                                  a
                                  1
                                
                                +
                                
                                  
                                    c
                                    1
                                  
                                  ⁢
                                  σ
                                
                              
                              )
                            
                          
                        
                        ⁢
                        
                          y
                          
                            -
                            
                              (
                              
                                
                                  b
                                  1
                                
                                +
                                
                                  
                                    d
                                    1
                                  
                                  ⁢
                                  σ
                                
                              
                              )
                            
                          
                        
                      
                    
                    )
                  
                
              
            
          
          ]
        
      
    
  
  
    
      
        
      
    
  
  
    
      
        
          
            
              
                
                  Ψ
                  ′
                
                ⁡
                
                  [
                  
                    
                      U
                      2
                    
                    ,
                    
                      V
                      2
                    
                    ,
                    
                      W
                      2
                    
                    ,
                    
                      E
                      5
                    
                    ,
                    
                      E
                      1
                      ′
                    
                    ,
                    
                      E
                      2
                      ′
                    
                    ,
                    
                      E
                      3
                      ′
                    
                    ,
                    
                      E
                      4
                      ′
                    
                  
                  ]
                
              
              ⁢
              
                =
                def
              
            
          
        
        
          
            
              
                
              
              ⁢
              
                [
                
                  
                    
                      
                        
                          
                            ∃
                            
                              r
                              5
                            
                          
                          ,
                          
                            r
                            1
                            ′
                          
                          ,
                          
                            r
                            2
                            ′
                          
                          ,
                          
                            r
                            3
                            ′
                          
                          ,
                          
                            r
                            4
                            ′
                          
                          ,
                          
                            a
                            2
                          
                          ,
                          
                            b
                            2
                          
                          ,
                          
                            c
                            2
                          
                          ,
                          
                            d
                            2
                          
                          ,
                          
                            e
                            2
                          
                          ,
                          
                            
                              s
                              2
                            
                            ⁢
                            
                              :
                            
                          
                        
                        ⁢
                        
                          
                        
                      
                    
                  
                  
                    
                      
                        
                          U
                          2
                        
                        =
                        
                          
                            
                              g
                              
                                a
                                2
                              
                            
                            ⁡
                            
                              (
                              
                                g
                                2
                              
                              )
                            
                          
                          
                            b
                            2
                          
                        
                      
                    
                  
                  
                    
                      
                        
                          ⩓
                          
                            V
                            2
                          
                        
                        =
                        
                          
                            
                              g
                              
                                c
                                2
                              
                            
                            ⁡
                            
                              (
                              
                                g
                                2
                              
                              )
                            
                          
                          
                            d
                            2
                          
                        
                      
                    
                  
                  
                    
                      
                        
                          ⩓
                          
                            W
                            2
                          
                        
                        =
                        
                          g
                          
                            e
                            2
                          
                        
                      
                    
                  
                  
                    
                      
                        
                          ⩓
                          
                            E
                            5
                          
                        
                        =
                        
                          (
                          
                            
                              g
                              
                                r
                                5
                              
                            
                            ,
                            
                              
                                
                                  (
                                  
                                    h
                                    1
                                  
                                  )
                                
                                
                                  r
                                  5
                                
                              
                              ⁢
                              
                                
                              
                              ⁢
                              
                                
                                  
                                    x
                                    
                                      
                                        e
                                        2
                                      
                                      ⁢
                                      
                                        
                                      
                                    
                                  
                                  ⁡
                                  
                                    (
                                    
                                      
                                        vx
                                        
                                          -
                                          
                                            (
                                            
                                              
                                                a
                                                2
                                              
                                              +
                                              
                                                
                                                  c
                                                  2
                                                
                                                ⁢
                                                σ
                                              
                                            
                                            )
                                          
                                        
                                      
                                      ⁢
                                      
                                        y
                                        
                                          -
                                          
                                            (
                                            
                                              
                                                b
                                                2
                                              
                                              +
                                              
                                                
                                                  d
                                                  2
                                                
                                                ⁢
                                                σ
                                              
                                            
                                            )
                                          
                                        
                                      
                                    
                                    )
                                  
                                
                                
                                  s
                                  2
                                
                              
                            
                          
                          )
                        
                      
                    
                  
                  
                    
                      
                        ⩓
                        
                          ×
                          
                            
                              (
                              
                                E
                                1
                              
                              )
                            
                            
                              -
                              
                                (
                                
                                  
                                    a
                                    2
                                  
                                  +
                                  
                                    
                                      c
                                      2
                                    
                                    ⁢
                                    σ
                                  
                                
                                )
                              
                            
                          
                          ⁢
                          
                            
                              (
                              
                                E
                                2
                              
                              )
                            
                            
                              
                                
                                  -
                                  
                                    b
                                    2
                                  
                                
                                +
                                
                                  
                                    d
                                    2
                                  
                                  ⁢
                                  σ
                                
                              
                              )
                            
                          
                          ×
                          
                            
                              (
                              
                                E
                                4
                              
                              )
                            
                            
                              s
                              2
                            
                          
                        
                      
                    
                  
                  
                    
                      
                        
                          ⩓
                          
                            E
                            1
                            ′
                          
                        
                        =
                        
                          (
                          
                            
                              g
                              
                                r
                                1
                                ′
                              
                            
                            ,
                            
                              
                                
                                  (
                                  
                                    h
                                    2
                                  
                                  )
                                
                                
                                  r
                                  1
                                  ′
                                
                              
                              ⁢
                              
                                x
                                
                                  s
                                  2
                                
                              
                            
                          
                          )
                        
                      
                    
                  
                  
                    
                      
                        
                          ⩓
                          
                            E
                            2
                            ′
                          
                        
                        =
                        
                          (
                          
                            
                              g
                              
                                r
                                2
                                ′
                              
                            
                            ,
                            
                              
                                
                                  (
                                  
                                    h
                                    2
                                  
                                  )
                                
                                
                                  r
                                  2
                                  ′
                                
                              
                              ⁢
                              
                                y
                                
                                  s
                                  2
                                
                              
                            
                          
                          )
                        
                      
                    
                  
                  
                    
                      
                        
                          ⩓
                          
                            E
                            3
                            ′
                          
                        
                        =
                        
                          (
                          
                            
                              g
                              
                                r
                                3
                                ′
                              
                            
                            ,
                            
                              
                                
                                  (
                                  
                                    h
                                    2
                                  
                                  )
                                
                                
                                  r
                                  3
                                  ′
                                
                              
                              ⁢
                              
                                v
                                
                                  s
                                  2
                                
                              
                            
                          
                          )
                        
                      
                    
                  
                  
                    
                      
                        
                          ⩓
                          
                            E
                            4
                            ′
                          
                        
                        =
                        
                          (
                          
                            
                              g
                              
                                r
                                4
                                ′
                              
                            
                            ,
                            
                              
                                
                                  (
                                  
                                    h
                                    2
                                  
                                  )
                                
                                
                                  r
                                  4
                                  ′
                                
                              
                              ×
                              
                                
                                  (
                                  
                                    E
                                    1
                                    ′
                                  
                                  )
                                
                                
                                  -
                                  
                                    (
                                    
                                      
                                        a
                                        2
                                      
                                      +
                                      
                                        
                                          c
                                          2
                                        
                                        ⁢
                                        σ
                                      
                                    
                                    )
                                  
                                
                              
                              ×
                              
                                
                                  (
                                  
                                    E
                                    2
                                    ′
                                  
                                  )
                                
                                
                                  (
                                  
                                    
                                      b
                                      2
                                    
                                    +
                                    
                                      
                                        d
                                        2
                                      
                                      ⁢
                                      σ
                                    
                                  
                                  )
                                
                              
                            
                          
                        
                      
                    
                  
                
                ]
              
            
          
        
      
    
  
  
    
      
        
          Γ
          ⁡
          
            [
            
              
                D
                1
              
              ,
              
                D
                2
              
              ,
              
                D
                3
              
            
            ]
          
        
        ⁢
        
          =
          def
        
        ⁢
        
          [
          
            
              ∃
              
                r
                :
                
                  D
                  1
                
              
            
            =
            
              
                
                  g
                  r
                
                ⩓
                
                  D
                  3
                
              
              =
              
                
                  (
                  
                    D
                    2
                  
                  )
                
                r
              
            
          
          ]
        
      
    
  
  
    
      
        
          
            Γ
            ′
          
          ⁡
          
            [
            
              
                D
                1
                ′
              
              ,
              
                D
                2
                ′
              
              ,
              
                D
                3
                ′
              
            
            ]
          
        
        ⁢
        
          =
          def
        
        ⁢
        
          [
          
            
              ∃
              
                r
                :
                
                  D
                  
                    1
                    ′
                  
                  ′
                
              
            
            =
            
              
                
                  g
                  r
                
                ⩓
                
                  D
                  
                    3
                    ′
                  
                  ′
                
              
              =
              
                
                  (
                  
                    D
                    2
                    ′
                  
                  )
                
                r
              
            
          
          ]
        
      
    
  




The encryptions of alice are defined to be consistent if Ψ holds, but instead of simply constructing Σ[Ψ] to prove consistency, alice constructs Σ[Ψ, Γ], proving that either Ψ holds, or the triple (D1, D2, D3) is a Diffie-Hellman triple. Since (D1, D2, D3) was chosen randomly in initialization, most likely it will not be a Diffie-Hellman triple, and thus alice will essentially be proving that Ψ holds. The reason for including Γ is that we will be able to use it to simulate the Σ-protocols for alice, by having our simulator set (D1, D2, D3) to be a Diffie-Hellman triple in the initialization protocol. By the hardness of DDH, this should not noticeably affect the adversary. Note that this technique works in the case of static adversaries, and in particular, bob-compromising adversaries, since setting (D1, D2, D3) to be a Diffie-Hellman triple may also allow an adversary to give a valid proof Σ[Ψ, Γ] without ψ holding. However, it is easy to see (and follows from the proof) that a bob-compromising adversary gains no advantage from this.
The encryptions of bob are defined to be consistent if Ψ′ holds, and the reasoning behind the Σ[Ψ′, Γ] construction is similar to the reasoning behind the Σ[Ψ, Γ] construction of alice. Σ[Ψ, Γ] and Σ[Ψ′, Γ′] may be similar to other protocols for proving relations among discrete logs, e.g., J. Camenisch et al., “Proof Systems for General Statements about Discrete Logarithms,” Technical Report TR 260, Department of Computer Science, ETH Zurich, March 1997, the disclosure of which is incorporated by reference herein, and are given below.
At this point, we have stated that E3 and Ei′ for 1≦i≦4, as well as the two Σ-protocols, are used for consistency checking, and thus one might believe that they could all be removed from the protocol if one were only to consider security against “honest-but-curious” adversaries. However, this does not seem to be true. The Σ-protocols and E4′ could in fact be removed, but the other values serve another purpose in our security proofs, namely, to allow a simulator for one of the parties to obtain the results of partial decryption computations from the other party. Thus, if one were to consider the “simplified” protocol for honest-but-curious adversaries, only E4′ and the Σ-protocols would be removed, leaving alice and bob to send values to each other that are never actually used.
It is also to be noted that our simulator does not require knowledge of the other party's share of the decryption randomizer s, but only the results of partial decryption computations. These can be encrypted and checked for consistency easily, using techniques that rely solely on the hardness of DDH. This is one of the important advantages of the invention, since having the simulator obtain s itself, although not difficult to achieve in threshold Cramer-Shoup protocols assuming an honest majority, seems to require a much more complicated two-party protocol, and in fact may not admit a protocol whose security relies solely on the hardness of DDH.
As shown in FIG. 1, the illustrative protocol 100 may employ six messages (assuming message 114 and the first message from alice to bob of exchange 116 are combined into one message; and assuming message 134 and the first message from bob to alice of exchange 136 are combined into one message). This could be improved to four messages by using the “committed proof” technique of S. Jarecki et al. “Adaptively Secure Threshold Cryptography: Introducing Concurrency, Removing Erasures,” EUROCRYPT 2000 (LNCS 1807), pp. 221-242, 2000; or I. Damgård, “Efficient Concurrent Zero-knowledge in the Auxiliary String Model,” EUROCRYPT 2000 (LNCS 1807), pp. 418-430, 2000, the disclosures of which are incorporated by reference herein. In particular, one could replace bob's proof Σ[Ψ′, Γ′] by a committed proof of Σ[Ψ′, Γ′], where, in particular, E5 is kept secret until the third message of the committed proof. This would allow the proofs by alice and bob to be interleaved, since E5 would not be revealed until after bob verifies that Ψ holds. This would be a novel application of the committed proof technique, i.e., it would be used not for the purpose of obtaining security against adaptive adversaries, but for improving efficiency.
It should also be noted that the inventive protocol could be reduced to two messages using the standard Fiat-Shamir technique, e.g., A. Fiat et al., “How to Prove Yourself: Practical Solutions to Identification and Signature Problems,” CRYPTO '86 (LNCS 263), pp. 186-194, 1987, the disclosure of which is incorporated by reference herein, for making proofs non-interactive using a hash function to calculate a challenge, but then a proof of security would require the random oracle assumption.
Turning to computational complexity, one can see that each party must perform roughly 90 exponentiations. Although this number is somewhat high, most of the exponentiations are performed over one of a small number of bases, and thus preprocessing can be used to greatly reduce the computation time. Also, assuming that the group is of size q where |q|=160, the exponents are reasonably small (roughly 160 bits each).
3. Protocols Σ[Ψ] and Σ[Ψ′]
In this section, we present protocols for Σ[Ψ] and Σ[Ψ′]. These protocols may be proven secure. Protocols Σ[Ψ, Γ] and Σ[Ψ′, Γ′] can be constructed using the techniques described in section 1 above.
3.1 Σ[Ψ]
Consider the predicate Ψ=Ψ[U1, V1, E1, E2, E3] with input language {circumflex over (L)}ψ=(Gq)5. We assume g, g2, h1, x, y, vεGq and σεZq are fixed. We assume the prover knows a1, b1, c1, d1, rl, r2, r3, s1εZq.
The first prover message of Σ[Ψ] is:

    
    
        <Û1, {circumflex over (V)}1, Ê1, Ê2, Ê3>,

where

    
    






  
    
      r
      ^
    
    1
  
  ,
  
    
      r
      ^
    
    2
  
  ,
  
    
      r
      ^
    
    3
  
  ,
  
    
      a
      ^
    
    1
  
  ,
  
    
      b
      ^
    
    1
  
  ,
  
    
      c
      ^
    
    1
  
  ,
  
    
      d
      ^
    
    1
  
  ,
  
    
      
        s
        ^
      
      1
    
    ⁢
    
      ←
      R
    
    ⁢
    
      Z
      q
    
  




and

    
    
        Û1←gâ1(g2){circumflex over (b)}1 Ê1←(g{circumflex over (r)}1,(h1){circumflex over (r)}1xŝ1) Ê3←(g{circumflex over (r)}3,(h1){circumflex over (r)}3vŝ1)
        {circumflex over (V)}1←gĉ1(g2){circumflex over (d)}1 Ê2←(g{circumflex over (r)}2,(h1){circumflex over (r)}2yŝ1) Ê4←(g{circumflex over (r)}4,(h1){circumflex over (r)}4xâ1+ĉ1σy{circumflex over (b)}1+{circumflex over (d)}1σ
    
    


Given a challenge ρ, the second prover message for Σ[ψ] is <z1, z2, z3, z4, z5, z6, z7, z8, z9>, where:

    
    
        z1←r1ρ+{circumflex over (r)}1 z4←r4ρ+{circumflex over (r)}4 z7←c1ρ+ĉ1 
        z2←r2ρ+{circumflex over (r)}2 z5←a1ρ+â1 z8←d1ρ+{circumflex over (d)}1 
        z3←r3ρ+{circumflex over (r)}3 z6←b1ρ+{circumflex over (b)}1 z9←s1ρ+ŝ1 
    
    


The verifier then verifies that:

    
    
        (E1)ρ×Ê1=(gz1,(h1)z1xz9) (U1)ρÛ1=gz5(g2)z6 
        (E2)ρ×Ê2=(gz2,(h1)z2yz9) (V1)ρ{circumflex over (V)}1=gz7(g2)z8 
        (E3)ρ×Ê3=(gz3,(h1)z3vz9)
        (E4)ρ×Ê4=(qz4,(h1)z4xz5+z7σyz6+z8σ)

3.2 Σ[Ψ′]

    
    


Consider the predicate Ψ′=Ψ′[U2, V2, W2, E5, E1′, E2′, E3′, E4′] with input language {circumflex over (L)}Ψ′=(Gq)8. We assume g, g2, h1, h2, x, y, vεGq and σεZq are fixed. We assume the prover knows:

    
    
        a2, b2, c2, d2, r5, r1′, r2′, r3′, r4′, s2εZq.
    
    


The first prover message of the Σ[Ψ′] is:

    
    
        <Û2, {circumflex over (V)}2, Ŵ2, Ê5, Ê1′, Ê2′, Ê3′, Ê4′, Ê4′′>,

where

    
    






  
    
      a
      ^
    
    2
  
  ,
  
    
      b
      ^
    
    2
  
  ,
  
    
      c
      ^
    
    2
  
  ,
  
    
      d
      ^
    
    2
  
  ,
  
    
      e
      ^
    
    2
  
  ,
  
    
      s
      ^
    
    2
  
  ,
  
    
      r
      ^
    
    1
    ′
  
  ,
  
    
      r
      ^
    
    2
    ′
  
  ,
  
    
      r
      ^
    
    3
    ′
  
  ,
  
    
      r
      ^
    
    4
    ′
  
  ,
  
    
      r
      ^
    
    4
    ′′
  
  ,
  
    
      ξ
      ^
    
    ′
  
  ,
  
    
      
        ζ
        ^
      
      ′
    
    ←
    
      
        Z
        R
      
      q
    
  




and

    
    
        Ê1′←(g{circumflex over (r)}1,(h2){circumflex over (r)}1xŝ2) Û2←gâ2(g2){circumflex over (b)}2 
        Ê2′←(g{circumflex over (r)}2,(h2){circumflex over (r)}2yŝ2) {circumflex over (V)}2←gĉ2(g2){circumflex over (d)}2 
        Ê3′←(g{circumflex over (r)}3,(h2){circumflex over (r)}2vŝ2) Ŵ2←gê2 
        Ê4′←(g{circumflex over (r)}4,(h2){circumflex over (r)}4)×(E1′)−(â2+ĉ2σ)×(E2′)−({circumflex over (b)}2+{circumflex over (d)}2σ) 
        Ê4′′←(g{circumflex over (r)}4′′,(h2){circumflex over (r)}4′′)x{circumflex over (ξ)}′y{circumflex over (ζ)}′)
        Ê5←(g{circumflex over (r)}5,(h1){circumflex over (r)}5xê2vŝ2x{circumflex over (ξ)}′y{circumflex over (ζ)}′)×(E1)−(â2+ĉ2σ)×(E2)−({circumflex over (b)}2+{circumflex over (d)}2σ)×(E3)ŝ2 
    
    


Given a challenge ρ, the second prover message for Σ[Ψ′] is:

    
    
        <z1, z2, z3, z4, z5, z6, z7, z8, z9, z10, z11, z12, z13, z14>,

where:

        z1←r1′ρ+{circumflex over (r)}1′ z8←b2ρ+{circumflex over (b)}2 
        z2←r2′ρ+{circumflex over (r)}2′ z9←c2ρ+ĉ2 
        z3←r3′ρ+{circumflex over (r)}4′ z10←d2ρ+{circumflex over (d)}2 
        z4←r4′ρ+{circumflex over (r)}4′ z11←e2ρ+ê2 
        z5←(r4′−(a2+c2σ)r1′−(b2+d2σ)r2′)ρ+{circumflex over (r)}4′′ z12←s2ρ+ŝ2 
        z6←r5ρ+{circumflex over (r)}5 z13←−(a2+c2σ)s2ρ+{circumflex over (ξ)}′
        z7←a2ρ+â2 z14←−(b2+d2σ)s2ρ+{circumflex over (ζ)}′
    
    


The verifier then verifies that:

    
    
        (E1′)ρ×Ê1′=(gz1,(h2)z1xz12) (U2)ρÛ2=gz7(g2)z8 
        (E2′)ρ×Ê2′=(gz2,(h2)z2yz12) (V2)ρ={circumflex over (V)}2=gz9(g2)z10 
        (E3′)ρ×Ê3′=(gz3,(h2)z3vz12) (W2)ρŴ2=gz11 
        (E4′)ρ×Ê4′=(gz4,(h2)z4)×(E1′)−(z7+z9σ)×(E2′)−(z8+z10σ) 
        (E4′)ρ×Ê4′′=(gz5,(h2)z5xz13yz14)
        (E5)ρ×Ê5=(gz6,(h1)z6xz11vz12xz13yz14)×(E1)−(z7+z9σ)×(E2)−(z8+z10σ)×(E3)z12 

4. Illustrative Architecture

    
    


Referring now to FIG. 2, a block diagram illustrates a generalized hardware architecture of a distributed data network and computer systems suitable for implementing a two-party Cramer-Shoup decryption protocol (e.g., S-CS) between two parties (e.g., “alice” and “bob”) according to the present invention. As shown, the first party (alice) employs a computer system 202 to participate in the protocol, while the second party (bob) employs a computer system 204 to participate in the protocol. The two computer systems 202 and 204 are coupled via a data network 206. The data network may be any data network across which the two parties desire to communicate, e.g., the Internet. However, the invention is not limited to a particular type of network.
The computer systems in FIG. 2 represent “devices,” as mentioned above. The devices may be, for example, personal computers (including desktops and laptops), personal digital assistants (PDA), smartcards, cellular phones, servers, hardware tokens, software programs, etc. However, the invention is not limited to any particular device.
As is readily apparent to one of ordinary skill in the art, the computer systems of FIG. 2 may be implemented as programmed computers operating under control of computer program code. The computer program code is stored in a computer readable medium (e.g., a memory) and the code is executed by a processor of the computer system. Given this disclosure of the invention, one skilled in the art can readily produce appropriate computer program code in order to implement the protocols described herein.
In any case, FIG. 2 generally illustrates an exemplary architecture for each computer system communicating over the network. As shown, the first party device comprises I/O devices 208-A, processor 210-A, and memory 212-A. The second party device comprises I/O devices 208-B, processor 210-B, and memory 212-B. It should be understood that the term “processor” as used herein is intended to include one or more processing devices, including a central processing unit (CPU) or other processing circuitry. Also, the term “memory” as used herein is intended to include memory associated with a processor or CPU, such as RAM, ROM, a fixed memory device (e.g., hard drive), or a removable memory device (e.g., diskette or CDROM). In addition, the term “I/O devices” as used herein is intended to include one or more input devices (e.g., keyboard, mouse) for inputting data to the processing unit, as well as one or more output devices (e.g., CRT display) for providing results associated with the processing unit.
Accordingly, software instructions or code for performing the protocols/methodologies of the invention, described herein, may be stored in one or more of the associated memory devices, e.g., ROM, fixed or removable memory, and, when ready to be utilized, loaded into RAM and executed by the CPU.
Although illustrative embodiments of the present invention have been described herein with reference to the accompanying drawings, it is to be understood that the invention is not limited to those precise embodiments, and that various other changes and modifications may be made by one skilled in the art without departing from the scope or spirit of the invention.

## Claims

1. A method for use in a device associated with a first party for decrypting a ciphertext according to a Cramer-Shoup based encryption scheme, the method comprising the steps of:
obtaining the ciphertext in the first party device sent from a device associated with a second party; and
generating in the first party device a plaintext corresponding to the ciphertext based on assistance from the second party device, wherein the assistance comprises an exchange of information between the first party device and the second party device separate from the sending of the ciphertext from the second party device to the first party device, the plaintext representing a result of the decryption according to the Cramer-Shoup based encryption scheme, such that the first party device and the second party device jointly perform a Cramer-Shoup based decryption operation of the ciphertext by each respectively performing one or more Cramer-Shoup based subcomputations of the joint Cramer-Shoup based decryption operation based at least in part on respective partial shares of a Cramer-Shoup based key that each party holds, but such that neither can decrypt the ciphertext alone.

2. The method of claim 1, wherein the generating step further comprises an exchange of information between the first party device and the second party device whereby at least a portion of the information is encrypted using an encryption technique such that one party encrypts information using its own public key and another party can not read the information but can use the information to perform an operation.

3. The method of claim 1, wherein the generating step further comprises an exchange of information between the first party device and the second party device whereby at least a portion of the information is encrypted using an encryption technique having a homomorphic property.

4. The method of claim 1, wherein the generating step further comprises:
generating a share of a random secret;
generating information representing encryptions of a form of the random secret, a share of a private key, and the ciphertext;
transmitting at least the encrypted information to the second party device; and
computing the plaintext based at least on the share of the random secret, the share of the private key, the ciphertext, and the data received from the second party device.

5. The method of claim 1, wherein the first party device and the second party device additively share components of a private key.

6. The method of claim 1, wherein the generating step further comprises generation and exchange of proofs between the first party device and the second party device that serve to verify operations performed by each party.

7. The method of claim 6, wherein the proofs are consistency proofs based on three-move Σ-protocols.

8. A method for use in a device associated with a first party for assisting in decrypting a ciphertext according to a Cramer-Shoup based encryption scheme, the method comprising the steps of:
receiving a request generated in and transmitted by a second party device for the partial assistance of the first party device in decrypting the ciphertext according to the Cramer-Shoup based encryption scheme; and
generating results in the first party device based on the partial assistance provided thereby for use in the second party device to complete decryption of the ciphertext, wherein the assistance comprises an exchange of information between the first party device and the second party device separate from the sending of the ciphertext from the first party device to the second party device, such that the first party device and the second party device jointly perform a Cramer-Shoup based decryption operation of the ciphertext by each respectively performing one or more Cramer-Shoup based subcomputations of the joint Cramer-Shoup based decryption operation based at least in part on respective partial shares of a Cramer-Shoup based key that each party holds, but such that neither can decrypt the ciphertext alone.

9. An apparatus for use in a device associated with a first party for decrypting a ciphertext according to a Cramer-Shoup based encryption scheme, the apparatus comprising:
a memory; and
at least one processor coupled to the memory and operative to: (i) obtain the ciphertext in the first party device sent from a device associated with a second party; and (ii) generate in the first party device a plaintext corresponding to the ciphertext based on assistance from a the second party device, wherein the assistance comprises an exchange of information between the first party device and the second party device separate from the sending of the ciphertext from the second party device to the first party device, the plaintext representing a result of the decryption according to the Cramer-Shoup based encryption scheme, such that the first party device and the second party device jointly perform a Cramer-Shoup based decryption operation of the ciphertext by each respectively performing one or more Cramer-Shoup based subcomputations of the joint Cramer-Shoup based decryption operation based at least in part on respective partial shares of a Cramer-Shoup based key that each party holds, but such that neither can decrypt the ciphertext alone.

10. The apparatus of claim 9, wherein the generating operation further comprises an exchange of information between the first party device and the second party device whereby at least a portion of the information is encrypted using an encryption technique such that one party encrypts information using its own public key and another party can not read the information but can use the information to perform an operation.

11. The apparatus of claim 9, wherein the generating operation further comprises an exchange of information between the first party device and the second party device whereby at least a portion of the information is encrypted using an encryption technique having a homomorphic property.

12. The apparatus of claim 9, wherein the generating operation further comprises: (i) generating a share of a random secret; (ii) generating information representing encryptions of a form of the random secret, a share of a private key, and the ciphertext; (iii) transmitting at least the encrypted information to the second party device; and (iv) computing the plaintext based at least on the share of the random secret, the share of the private key, the ciphertext, and the data received from the second party device.

13. The apparatus of claim 9, wherein the first party device and the second party device additively share components of a private key.

14. The apparatus of claim 9, wherein the generating operation further comprises generation and exchange of proofs between the first party device and the second party device that serve to verify operations performed by each party.

15. The apparatus of claim 14, wherein the proofs are consistency proofs based on three-move Σ-protocols.

16. An apparatus for use in a device associated with a first party for assisting in decrypting a ciphertext according to a Cramer-Shoup based encryption scheme, the apparatus comprising:
a memory; and
at least one processor coupled to the memory and operative to: (i) receive a request generated in and transmitted by a second party device for the partial assistance of the first party device in decrypting the ciphertext according to the Cramer-Shoup based encryption scheme; and (ii) generate results in the first party device based on the partial assistance provided thereby for use in the second party device to complete decryption of the ciphertext, wherein the assistance comprises an exchange of information between the first party device and the second party device separate from the sending of the ciphertext from the first party device to the second party device, such that the first party device and the second party device jointly perform a Cramer-Shoup based decryption operation of the ciphertext by each respectively performing one or more Cramer-Shoup based subcomputations of the joint Cramer-Shoup based decryption operation based at least in part on respective partial shares of a Cramer-Shoup based key that each party holds, but such that neither can decrypt the ciphertext alone.