Abstract:
The aim of the present invention is to propose an alternative scheme to the classical Boneh-Franklin scheme in order to simplify the generation and the use of the asymmetric keys. 
     According to the present invention, it is proposed a method to generate an i-th private key in a public key encryption scheme with traceable private keys formed by a public component γ (i)  and a secret component θ i , according to a maximal coalition factor k, with all arithmetic operations performed within a multiplicative group Z/qZ where q is a prime number, 
     said public component being defined as: 
       γ (i)pl =(   1   , i mod q, i   2  mod  q, . . . , i   k-1  mod  q)   
     and said secret component being defined as: 
     
       
         
           
             
               θ 
               i 
             
             = 
             
               
                 
                   ∑ 
                   
                     
                       r 
                       j 
                     
                      
                     
                       α 
                       j 
                     
                   
                 
                 
                   ∑ 
                   
                     
                       r 
                       j 
                     
                      
                     
                       γ 
                       j 
                       
                         ( 
                         i 
                         ) 
                       
                     
                   
                 
               
                
               mod 
                
               
                   
               
                
               q 
             
           
         
       
     
     where r j  and α j  are random values in the group Z/Z.

Description:
FIELD OF THE INVENTION 
       [0001]    The aim of the present invention is to propose an alternative scheme to the classical Boneh-Franklin scheme in order to simplify the generation and the use of the asymmetric keys. 
       PRIOR ART 
       [0002]    Consider the following scenario: a center would like to broadcast some data to l receivers, where only authorized users (typically, those who have paid a fee) can have access to the data. A possible solution, widely deployed in commercial Pay-TV systems or in secured media distribution systems, for instance, consists in encrypting the data using a symmetric key and to securely transmit to each authorized receiver this key which will be stored in a tamper-proof piece of hardware, like a smartcard. 
         [0003]    Unfortunately, tamper-resistant hardware is very difficult and/or costly to design, since it is vulnerable to a wide variety of attacks. Therefore, a malicious user (hereafter called a traitor) can try to retrieve the decryption key from his receiver and distribute it (sell or give away) to unauthorized users (the pirates). Depending on the nature of the encryption schemes in use, we can even imagine situations where a dishonest user will try to mix several legitimate keys in order to build a new one and embed it in a pirate receiver device. 
         [0004]    The problem of identifying which receivers were compromised and/or which secret keys were leaked is called traitor tracing. Usually, two modes of traitor tracing are considered: in the black-box mode, the tracing algorithm sends crafty ciphertexts to the rogue receiver and aims at determining which keys it uses while observing its behavior; in the non-black-box model, we assume that the keys (or their combination) can be extracted from the pirate receiver and are known to the tracing algorithm. 
         [0005]    Fiat and Naor [1] introduced the concept of broadcast encryption. In their model, there exists a set of l authorized users and the broadcasting center can dynamically specify a privileged subset of authorized users that can decrypt selected ciphertexts (like high-value content, for instance). Later on, Chor, Fiat, and Naor [2] introduced the concept of traitor-tracing to thwart the problem of decryption keys piracy in broadcast encryption schemes; their scheme is k-collusion resistant (or k-resilient) in the sense that at least one traitor is identified with very high probability if there are at most k of them. Later on, Naor, Naor and Lotspiech [3, 4] presented more efficient broadcast encryption schemes with tracing capabilities; it was however shown by Kiayias and Pehlivanoglu [5] that the iterative nature of the tracing procedure allows a pirate to leverage significantly the compromise of a few keys. 
         [0006]    Boneh and Franklin [6] proposed a new public-key traitor-tracing scheme based on error-correcting codes, more precisely on Reed-Solomon codes. The Boneh-Franklin non-black-box traitor tracing scheme is k-collusion resistant and deterministic in the sense that all of the traitors are identified with probability 1 as long as at most k of them collude to derive new pirate keys. 
       Problem to be Solved 
       [0007]    The aim of the present application is an improved key generation and encryption mechanism for Boneh-Franklin and related schemes. 
         [0008]    An immediate benefit of the present application is the possibility to use Reed-Solomon codes that are especially optimized to allow faster decryption and key generation. In practice, for large systems and coalitions of medium size, one obtains a decryption speed improvement by almost an order of magnitude. 
         [0009]    The present application also addresses the beyond-threshold security of the Boneh-Franklin scheme: if an adversary is able to recover 2k or more secret keys, where k is the maximal collusion size defined prior to the system deployment, then he is able to compute any other secret key (even if they were not compromised) and thus, the security of the system completely collapses. This is mainly due to the fact that the linear tracing code is public. In the present application we propose a way to protect against this issue. 
       Boneh-Franklin Scheme 
     Original Boneh-Franklin 
       [0010]    We now describe the original Boneh-Franklin algorithm in details as advertised and published in [6]. This description will be the basis for the description of the invention for the fast and secure traceable keys and encryption/decryption mechanisms. 
       Group Parameters Generation 
       [0011]    We need a group G q  (i.e., a set of elements equipped with a mathematical operation) of prime order q in which the Decision Diffie-Hellman problem is hard. Three main choices are thinkable, but other exist: 
         [0012]    Scenario 1. We can work in a subgroup of order q of the group Z/pZ, where p and q are large prime numbers and where q|p−1. Typically, q is a 160-bit prime number and p is a 1024-bit prime number. Group elements are 1024-bit numbers requiring 1024 bits of storage/bandwidth; implementing Boneh-Franklin scheme on a prime-order subgroup of Z/pZ requires to be able to perform modular additions, modular subtractions, modular multiplications and modular inversions both on 160-bit and on 1024-bit numbers. 
         [0013]    Scenario 2. We can work over a group of points of an elliptic curve [3] over a finite field with characteristic 2 having in the order of 2 160  elements. Group elements require typically 320 bits, but point compression techniques allow decreasing this number down to 160 bits of storage/bandwidth. Implementing Boneh-Franklin scheme on such a group requires that the receiver be able to perform additions, subtractions, multiplications and inversions on 160-bit field elements. 
         [0014]    Scenario 3. We can work over a group of points of an elliptic curve over a finite field with a large prime characteristic and having in the order of 2 160  elements. 
         [0015]    Group elements require typically 320 bits, but point compression techniques allow decreasing this number down to 160 bits of storage/bandwidth. Implementing Boneh-Franklin scheme on such a group requires performing modular additions, modular subtractions, modular multiplications and modular inversions on 160-bit numbers. 
       Key Generation 
       [0016]    We now describe the traceable key public component γ (i)  generation process as done in [6]. For ease of understanding, we assume from now on that we work in a multiplicative group as described in scenario 1. Basically, the approach of Boneh and Franklin is based on the use of Reed-Solomon codes. 
       Given the Following Matrix 
       [0017]    
       
         
           
             
               
                 
                   A 
                   = 
                   
                     
                       ( 
                       
                         
                           
                             1 
                           
                           
                             1 
                           
                           
                             1 
                           
                           
                             … 
                           
                           
                             1 
                           
                           
                             
                                 
                             
                           
                         
                         
                           
                             1 
                           
                           
                             2 
                           
                           
                             3 
                           
                           
                             … 
                           
                           
                             l 
                           
                           
                             15 
                           
                         
                         
                           
                             
                               1 
                               2 
                             
                           
                           
                             
                               2 
                               2 
                             
                           
                           
                             
                               3 
                               2 
                             
                           
                           
                             … 
                           
                           
                             
                               l 
                               3 
                             
                           
                           
                             
                                 
                             
                           
                         
                         
                           
                             ⋮ 
                           
                           
                             ⋮ 
                           
                           
                             ⋮ 
                           
                           
                             
                                 
                             
                           
                           
                             ⋮ 
                           
                           
                             
                                 
                             
                           
                         
                         
                           
                             
                               1 
                               
                                 l 
                                 - 
                                 
                                   2 
                                    
                                   k 
                                 
                                 - 
                                 1 
                               
                             
                           
                           
                             
                               2 
                               
                                 l 
                                 - 
                                 
                                   2 
                                    
                                   k 
                                 
                                 - 
                                 1 
                               
                             
                           
                           
                             
                               3 
                               
                                 l 
                                 - 
                                 
                                   2 
                                    
                                   k 
                                 
                                 - 
                                 1 
                               
                             
                           
                           
                             … 
                           
                           
                             
                               l 
                               
                                 l 
                                 - 
                                 
                                   2 
                                    
                                   k 
                                 
                                 - 
                                 1 
                               
                             
                           
                           
                             
                                 
                             
                           
                         
                       
                       ) 
                     
                      
                     
                       ( 
                       
                         mod 
                          
                         
                             
                         
                          
                         q 
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   20 
                   ) 
                 
               
             
           
         
       
     
         [0000]    and considering a basis b 1 , . . . , b 2k  of the nullspace of A, a new matrix is built 
         [0000]    
       
         
           
             
               
                 
                   B 
                   = 
                   
                     ( 
                     
                       
                         
                            
                         
                         
                            
                         
                         
                            
                         
                         
                           
                               
                           
                         
                         
                            
                         
                       
                       
                         
                           
                             b 
                             1 
                           
                         
                         
                           
                             b 
                             2 
                           
                         
                         
                           
                             b 
                             3 
                           
                         
                         
                           … 
                         
                         
                           
                             b 
                             
                               2 
                                
                               k 
                             
                           
                         
                       
                       
                         
                            
                         
                         
                            
                         
                         
                            
                         
                         
                           
                               
                           
                         
                         
                            
                         
                       
                     
                     ) 
                   
                 
               
               
                 
                   ( 
                   21 
                   ) 
                 
               
             
           
         
       
     
         [0018]    Consider / −  as being the rows of B. Thus, / −  contains l codewords each of length 2k. By observing that any vector in the span of the rows of A corresponds to a polynomial of degree at most l−2k−1 evaluated at the points 1, . . . , l one can construct the rows of B using Lagrange interpolation. 
         [0019]    Let k denote the maximal allowed coalition size (i.e., the maximum number of keys that could potentially be mixed by a pirate while keeping the tracing properties). Let g denote a generator of the group G q  of prime order q in which we implement the Boneh-Franklin scheme. Let l denote the maximum number of receivers in the Boneh-Franklin system. Let 1≦i≦l denote the identity of the i-th receiver. The following values are computed: 
         [0020]    1. The i-th Boneh-Franklin traceable key public component is computed as being the following 2k-valued vector over Z/qZ: 
         [0000]    
       
         
           
             
               
                 
                   
                     γ 
                     
                       ( 
                       i 
                       ) 
                     
                   
                   = 
                   
                     ( 
                     
                       
                         
                           u 
                           i 
                         
                          
                         mod 
                          
                         
                             
                         
                          
                         q 
                       
                       , 
                       
                         
                           iu 
                           i 
                         
                          
                         mod 
                          
                         
                             
                         
                          
                         q 
                       
                       , 
                       
                         
                           i 
                           2 
                         
                          
                         
                           u 
                           i 
                         
                          
                         mod 
                          
                         
                             
                         
                          
                         q 
                       
                       , 
                       … 
                        
                       
                           
                       
                       , 
                       
                         
                           i 
                           
                             
                               2 
                                
                               k 
                             
                             - 
                             1 
                           
                         
                          
                         
                           u 
                           i 
                         
                          
                         mod 
                          
                         
                             
                         
                          
                         q 
                       
                     
                     ) 
                   
                 
               
               
                 
                   ( 
                   1 
                   ) 
                 
               
             
             
               
                 where 
               
               
                 
                     
                 
               
             
             
               
                 
                   
                     u 
                     1 
                   
                   = 
                   
                     
                       
                         ( 
                         
                           
                             ∏ 
                             
                               j 
                               = 
                               1 
                             
                             
                               l 
                               - 
                               1 
                             
                           
                            
                           
                             - 
                             j 
                           
                         
                         ) 
                       
                       
                         - 
                         1 
                       
                     
                      
                     mod 
                      
                     
                         
                     
                      
                     q 
                   
                 
               
               
                 
                   ( 
                   2 
                   ) 
                 
               
             
             
               
                 and 
               
               
                 
                     
                 
               
             
             
               
                 
                   
                     u 
                     
                       i 
                       + 
                       1 
                     
                   
                   = 
                   
                     
                       
                         
                           i 
                           - 
                           1 
                         
                         
                           
                             u 
                             i 
                           
                            
                           
                             ( 
                             
                               i 
                               - 
                               l 
                             
                             ) 
                           
                         
                       
                        
                       mod 
                        
                       
                           
                       
                        
                       q 
                        
                       
                           
                       
                        
                       for 
                        
                       
                           
                       
                        
                       2 
                     
                     ≤ 
                     i 
                     ≤ 
                     
                       l 
                       - 
                       1. 
                     
                   
                 
               
               
                 
                   ( 
                   3 
                   ) 
                 
               
             
           
         
       
     
         [0021]    2. The public key is computed by generating 2k secret values r j : 
         [0000]        r∈   R   Z/qZ  for 1 ≦j≦ 2 k   (4) 
         [0000]    and computing 
         [0000]        h   j   =g   r     j    for 1 ≦j≦ 2 k.   (5) 
         [0022]    Then 2k secret values α j  are generated: 
         [0000]      α j ∈ R   Z/qZ  for 1 ≦j≦ 2 k   (6) 
         [0000]    and finally the value y is computed as 
         [0000]    
       
         
           
             
               
                 
                   y 
                   = 
                   
                     
                       ∏ 
                       
                         j 
                         = 
                         1 
                       
                       
                         2 
                          
                         k 
                       
                     
                      
                     
                       h 
                       j 
                       
                         a 
                         j 
                       
                     
                   
                 
               
               
                 
                   ( 
                   7 
                   ) 
                 
               
             
           
         
       
     
         [0023]    The public key is then defined as being the (2k+1)-valued vector 
         [0000]      (y, h 1 , . . . , h 2k )  (8) 
         [0024]    3. The i-th private key secret component θ i  put in the i-th receiver, is derived from the i-th traceable key public component 
         [0000]      γ (i) =(γ 1   (i) , . . . , γ 2k   (i) ) as 
         [0000]    
       
         
           
             
               
                 
                   
                     θ 
                     i 
                   
                   = 
                   
                     
                       
                         ∑ 
                         
                           
                             r 
                             j 
                           
                            
                           
                             α 
                             j 
                           
                         
                       
                       
                         ∑ 
                         
                           
                             r 
                             j 
                           
                            
                           
                             γ 
                             j 
                             
                               ( 
                               i 
                               ) 
                             
                           
                         
                       
                     
                      
                     mod 
                      
                     
                         
                     
                      
                     q 
                   
                 
               
               
                 
                   ( 
                   9 
                   ) 
                 
               
             
           
         
       
     
       Encryption 
       [0025]    To encrypt a message m∈G q , we first generate a random value a ∈ R Z/qZ and the ciphertext is defined as being the (2k+1)-valued vector 
         [0000]      ( m·y   a   , h   1   a   , . . . , h   2k   a )  (10) 
       Decryption 
       [0026]    Given a ciphertext c=(s,ρ 1 , . . . , ρ 2k ), it is easy to see that one can recover m by computing using i-th private key secret component θ i   
         [0000]    
       
         
           
             
               
                 
                   m 
                   = 
                   
                     s 
                     
                       
                         ( 
                         
                           
                             ∏ 
                             
                               j 
                               = 
                               1 
                             
                             
                               2 
                                
                               k 
                             
                           
                            
                           
                             p 
                             j 
                             
                               γ 
                               j 
                               
                                 ( 
                                 i 
                                 ) 
                               
                             
                           
                         
                         ) 
                       
                       
                         θ 
                         i 
                       
                     
                   
                 
               
               
                 
                   ( 
                   11 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where γ j   (i)  are the public components of the traceable private key which are used to derive θ i . 
       BRIEF DESCRIPTION OF THE INVENTION 
       [0027]    In order to simplify the generation and the use of the asymmetric keys, in particular private keys in a public key encryption scheme with traceable private keys formed by a public component and a secret component, we propose a method to generate an i-th private key in a public key encryption scheme with traceable private keys formed by a public component γ (i)  and a secret component θ I , according to a maximal coalition factor k, with all arithmetic operations performed within the multiplicative group Z/qZ where q is a prime number, 
         [0028]    said public component being defined as: 
         [0000]      γ (I) =(1,  b  mod  q, b   2  mod  q, . . . , b   2k−1  mod  q ) 
         [0000]    and said secret component being defined as: 
         [0000]    
       
         
           
             
               θ 
               i 
             
             = 
             
               
                 
                   ∑ 
                   
                     
                       r 
                       j 
                     
                      
                     
                       α 
                       j 
                     
                   
                 
                 
                   ∑ 
                   
                     
                       r 
                       j 
                     
                      
                     
                       γ 
                       j 
                       
                         ( 
                         i 
                         ) 
                       
                     
                   
                 
               
                
               mod 
                
               
                   
               
                
               q 
             
           
         
       
     
         [0000]    where r j  and α j  are uniformly distributed random values in the group Z/qZ, 1≦j≦2k and where the value b may be either public and easily computable or secret and statistically decorrelated. 
         [0029]    Furthermore, we propose two possible variants to encrypt any type of message faster than the original Boneh-Franklin scheme with the same tracing and security properties. 
     
    
     DETAILED DESCRIPTION OF THE INVENTION  
     Traceable Keys for Fast Decryption 
       [0030]    We now present a traceable private key public component generation process which allows deriving public components which offer a significantly improved decryption speed. 
         [0031]    Previously, we noted that the components γ (i)  can be computed using the recursive formula Eq. (3); this operation is typically feasible in the broadcasting center, but not in a receiver. We can furthermore note that, working in a usual security configuration of 2 80  operations, the elements of a public component γ (i)  have all a length of 160 bits. 
         [0032]    This new method works as follows: in the key generation process described previously, the step 1 is replaced by 
         [0033]    1′ We compute the i-th fast Boneh-Franklin traceable private key public component as being the following 2k-valued vector over Z/qZ: 
         [0000]      γ (i) =(1,  i  mod  q, i   2  mod  q, . . . , i   2k−1  mod  q ).  (12) 
         [0034]    The method presented below results in rather small exponent sizes which can drastically speed up the ciphertext decryption in the receiver: re-writing (11) as 
         [0000]    
       
         
           
             
               
                 
                   m 
                   = 
                   
                     
                       s 
                       
                         
                           
                             ( 
                             
                               ∏ 
                               
                                 p 
                                 j 
                                 
                                   i 
                                   
                                     j 
                                     - 
                                     1 
                                   
                                 
                               
                             
                             ) 
                           
                           
                             θ 
                             i 
                           
                         
                          
                         
                             
                         
                       
                     
                     = 
                     
                       s 
                       
                         
                           ( 
                           
                             
                               
                                 ( 
                                 
                                   
                                     
                                       ( 
                                       
                                         
                                           p 
                                           
                                             2 
                                              
                                             k 
                                           
                                           i 
                                         
                                          
                                         
                                           p 
                                           
                                             
                                               2 
                                                
                                               k 
                                             
                                             - 
                                             1 
                                           
                                         
                                       
                                       ) 
                                     
                                     i 
                                   
                                    
                                   
                                     p 
                                     2 
                                   
                                 
                                 ) 
                               
                               i 
                             
                              
                             
                               p 
                               1 
                             
                           
                           ) 
                         
                         
                           θ 
                           i 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   13 
                   ) 
                 
               
             
           
         
       
     
         [0000]    we can transform, for instance for l=2 20 , 2k+1 modular exponentiations with 160-bit exponents by 2k modular exponentiations with 20-bit exponents and one 160-bit exponentiation. This is more than a 7-times speedup. 
         [0035]    According a particular embodiment of the invention, q is higher than 2 127  in order to avoid generic attacks against the discrete logarithm problem. 
         [0036]    A further advantage of this method is that a receiver can compute the public component of the decryption key without the need to evaluate the recursive formula of Eq. (3). 
       Traceable Keys for Added Security 
       [0037]    In practical scenarios, there might be a situation where an attacker might have 2k secret components θ i  at his disposal. This part of the invention describes specifically how to the system can be protected in such a case. We start by describing an attack that might occur in practice and allow the attacker to derive every private key in the system. 
         [0038]    Let us suppose than an adversary has managed to get 2k private elements θ i , for 1≦s≦2k. The vectors in r/ − ={γ (1) , γ (2) , . . . , γ (l) } are assumed to be public. Then, we can rewrite Eq. (9) over Z/qZ as 
         [0000]    
       
         
           
             
               
                 
                   
                     θ 
                     
                       ( 
                       
                         i 
                         a 
                       
                       ) 
                     
                     
                       - 
                       1 
                     
                   
                   = 
                   
                     
                       
                         
                           ∑ 
                           
                             j 
                             = 
                             1 
                           
                           
                             2 
                              
                             k 
                           
                         
                          
                         
                           
                             r 
                             j 
                           
                            
                           
                             γ 
                             j 
                             
                               ( 
                               
                                 i 
                                 a 
                               
                               ) 
                             
                           
                         
                       
                       
                         
                           ∑ 
                           
                             j 
                             = 
                             1 
                           
                           
                             2 
                              
                             k 
                           
                         
                          
                         
                           
                             r 
                             j 
                           
                            
                           
                             α 
                             j 
                           
                         
                       
                     
                     = 
                     
                       
                         ∑ 
                         
                           j 
                           = 
                           1 
                         
                         
                           2 
                            
                           k 
                         
                       
                        
                       
                         
                           ω 
                           j 
                         
                          
                         
                           γ 
                           j 
                           
                             ( 
                             
                               i 
                               a 
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   22 
                   ) 
                 
               
             
           
         
       
     
         [0000]    with ω j =r j /Σr j α j ; note that the ω j  are unknown coefficients to an adversary. However, with 2k private elements, we have a system of 2k linear equations with 2k variables with a single solution revealing the values of ω j  to the adversary using a simple Gaussian reduction. From those coefficients, the adversary can compute any other private key θ i,  in the system 
         [0000]    
       
         
           
             
               
                 
                   
                     θ 
                     
                       i 
                       υ 
                     
                   
                   = 
                   
                     
                       ( 
                       
                         
                           ∑ 
                           
                             j 
                             = 
                             1 
                           
                           
                             2 
                              
                             k 
                           
                         
                          
                         
                           
                             ω 
                             j 
                           
                            
                           
                             γ 
                             j 
                             
                               ( 
                               
                                 i 
                                 υ 
                               
                               ) 
                             
                           
                         
                       
                       ) 
                     
                     
                       - 
                       1 
                     
                   
                 
               
               
                 
                   ( 
                   23 
                   ) 
                 
               
             
           
         
       
     
         [0039]    Not only the adversary will be able to create many untraceable combinations of keys, but he will be also able to distribute newly derived keys so that innocent users (whose keys were a priori never compromised) will be accused of treachery. 
         [0040]    We now present a traceable key generation process which allows deriving traceable keys resistant to pirates able to gather 2k keys or more. This new method works as follows: 
         [0041]    1″ We compute the i-th fast Boneh-Franklin public component of the traceable private key as being the following 2k-valued vector over Z/qZ: 
         [0000]      γ (i) =(1, ζ 2  mod  q , . . . , ζ 2k− mod  q ).  (14) 
         [0000]    where ζ ∈ R  Z/qZ is drawn independently and uniformly at random for each γ (i) . 
         [0042]    We note that the receivers have to store the entire representation 
         [0000]        d   (i) =(θ iγ1   (i) , . . . , θ 2kγ2k   (i) )  (15) 
         [0000]    in tamper-proof memory and hence the abovementioned public component becomes secret. 
         [0043]    A possible variant would consist in deriving ζ from i by processing i and/or additional information with a cryptographically secure pseudo-random function (or permutation) parametered by a secret key. 
       Hybrid Encryption 
       [0044]    To encrypt a message m∈G q , the standard Boneh-Franklin encryption procedure requires to generate a random value a ER Z/qZ and the ciphertext is defined as being the (2k+1)-valued vector 
         [0000]      ( m·y   a   , h   1   a   , . . . , h   2k   a )  (16) 
         [0045]    In most practical situations, the message m consists in a symmetric session key k, which is then used to encrypt some content, since m is of limited length (no more than 20 bytes, usually). Furthermore, one possibly needs a hash function mapping a group element to a symmetric key. 
         [0046]    We propose to bypass these intermediate steps and to use one of the two following possible variants to encrypt any type of message faster than the standard Boneh-Franklin scheme, but keeping the same tracing and security properties. 
         [0047]    1. To encrypt a message m∈{0, 1}* (i.e., a bitstring of arbitrary length), we first generate a random value a ∈ R  Z/qZ and the ciphertext is defined as being the (2k+1)-valued vector 
         [0000]      ( m⊕ PRF( n, y   a ),  h   1   a   , . . . , h   2k   a )  (17) 
         [0000]    where PRF(., .) denotes a cryptographically secure pseudo-random function. For instance, it can be HMAC-SHA1, HMAC-SHA256 or a block cipher evaluated on a counter and where y a  is considered as being the symmetric key and n is a nonce value (e.g., a counter incremented sufficiently many times to generate enough key stream). Here, the XOR operation ⊕ could be replaced by any group law. 
         [0048]    2. To encrypt a message m∈{0, 1}*, we first generate a random value a ∈ R  Z/qZ and the ciphertext is defined as being the (2k+1)-valued vector 
         [0000]      ( E ( m, y   a ),  h   1   a   , . . . , h   2k   a )  (18) 
         [0000]    where E(., .) is a block cipher or any symmetric encryption scheme based on a block cipher, and where y a  is considered as being the key. A possible variant would consist in mapping the y a  value to a key using a hash function. Another possible variant is an encryption scheme E(.,.) requiring additional information, like an initial vector. 
       Field of Application 
       [0049]    In Pay-TV systems, the use of traceable asymmetric keys is an advantage in terms of fighting against piracy. The Pay-TV receiver (or the security module thereof) is loaded with a private key i.e., the public component γ (i)  and the secret component θ i. Each Pay-TV receiver, such as a set top-box, multimedia device or wireless portable device (DVB-H), comprises at least one private key. The secret component is preferably stored in a secure container such as a SIM card, smartcard of any type of tamper-proof memory. 
         [0050]    In a practical example, a video/audio data packet PSpacket will be encrypted in the following way, assuming we are working with a multiplicative group and HMAC-SHA256 as the function PRF (see formula (17)): 
         [0051]    generate uniformly distributed random value a 
         [0052]    compute h 1   a , h 2   a , . . . h 2k   a  using 2k last elements of the public key (see formula (8)), 
         [0053]    compute y a  using the first element of the public key, 
         [0054]    divide the PSpacket into chunk packets of 256 bits possibly remaining a residual packet of less than 256 bits, 
         [0055]    initialize an index to an arbitrary constant (usually 0), 
         [0056]    for each chunk, computing the HMAC-SHA256 of the index with y a  as key, the index being updated for each chunk, and applying an XOR function (or any group operation) with the respective chunk 
         [0057]    in case that a residual chunk exists, adjusting the HMAC-SHA256 value by extracting the number of bit corresponding to the number of bits of the residual chunk before applying the XOR function. 
         [0058]    transmitting to the receiver, the result values after the XOR function and the h 1   a , h 2   a , . . . , h 2k   a    
         [0059]    In the receiver side, the received values h 1   a , h 2   a , . . . , h 2k   a  are considered as 2k values i.e. ρ 1 , ρ 2 , . . . ρ 2k . 
         [0060]    In order to extract the audio/video data PSpacket, the following steps will be executed: 
         [0061]    computing 
         [0000]    
       
         
           
             
               y 
               a 
             
             = 
             
               
                 ( 
                 
                   
                     ∏ 
                     
                       j 
                       = 
                       1 
                     
                     
                       2 
                        
                       k 
                     
                   
                    
                   
                     p 
                     j 
                     
                       γ 
                       j 
                       
                         ( 
                         i 
                         ) 
                       
                     
                   
                 
                 ) 
               
               
                 θ 
                 i 
               
             
           
         
       
     
         [0000]    using the γ (i)  public component of the private key, and θ i  is the secret component of the private key, 
         [0062]    executing the same HMAC-SHA256 operation as made on the sender side, by defining an index in the same way as defined during the encryption operation. 
         [0063]    In this way, the broadcasting center can send a global, encrypted version of audio/video packet to all receivers; those receivers decrypt the packets using their own private key. A pirate willing to implement an unofficial (unlawful) receiver will necessarily have to embed a unique private key (or a mix of several private keys) in order to decrypt the packets. Having such a rogue receiver in hands, the Pay-TV operator can then recover the pirate private key(s) and possibly revoke it (them) using another mechanism and/or possibly take legal or any other action against the person having purchased the original (broken) receiver(s), provided such a link exists. 
         [0064]    Instead of mixing the packets with HMAC result, the packets are encrypted with a standard symmetric encryption scheme using a key K, this key being used at the mixing step with the HMAC result. 
         [0065]    According to another embodiment, the encrypted packet is obtained by encrypting the said packet with a symmetric encryption scheme using the y a  value as a key (e.g. TDES in CBC mode). According to an alternative embodiment, a hashing function is first applied to the y a  value before being used as a key. This is preferably the case when the size of the y a  value is different than the size of the symmetric encryption scheme key. 
         [0066]    Another possible field of application concerns the protection of software against piracy. We may assume that a software is sold together with a hardware dongle containing a different private key for every package. This dongle is able to decrypt a global ciphertext contained in the software and getting a piece of information which is necessary to the use of the software. If a pirate is willing to clone dongles and sell them, he must embed at least a private key. Getting such a pirate dongle in hands, the software seller can then recover the involved private key(s) and take legal or any other action against the person having purchased the original (broken) dongle(s), provided such a link exists. 
       REFERENCES 
       [0000]    
       
         [1] A. Fiat and M. Naor, “Broadcast encryption”, CRYPTO&#39;93, Lecture Notes in Computer Science 773, pp.480-491, Springer-Verlag, 1994. 
         [2] B. Chor, A. Fiat and M. Naor, “Tracing Traitors”, CRYPTO&#39;94, Lecture Notes in Computer Science 839, pp. 257-270, Springer-Verlag, 1994. 
         [3] J. Lotspiech, D. Naor and M. Naor, “Method for broadcast encryption and key revocation of stateless receivers”, U.S. Pat. No. 7,039,803. 
         [4] J. Lotspiech, D. Naor and M. Naor, “Method for tracing traitor receivers in a broadcast encryption system”, U.S. Pat. No. 7,010,125. 
         [5] A. Kiayias and S. Pehlivanoglu, “Pirate evolution: how to make the most of your traitor keys”, CRYPTO&#39;07, Lecture Notes in Computer Sciences 4622, pp. 448-465, Springer-Verlag, 2007. 
         [5] D. Boneh and M. Franklin, “An efficient public-key traitor tracing scheme”, CRYPTO∝99, Lecture Notes in Computer Sciences 1666, pp. 338-353, Springer-Verlag, 1999.