Abstract:
A processor of a device generates a cryptographic commitment by receiving a vector {right arrow over (m)}, a public verification key of a homomorphic signature scheme, and a tag; choosing a signature σ in the signature space; generating a commitment c by running the verification algorithm of the homomorphic signature scheme; and outputting the commitment c as intermediate values resulting from the verification algorithm.

Description:
TECHNICAL FIELD 
       [0001]    The present invention relates generally to cryptography, and in particular to non-malleable commitments from linearly homomorphic signatures. 
       BACKGROUND 
       [0002]    This section is intended to introduce the reader to various aspects of art, which may be related to various aspects of the present invention that are described and/or claimed below. This discussion is believed to be helpful in providing the reader with background information to facilitate a better understanding of the various aspects of the present invention. Accordingly, it should be understood that these statements are to be read in this light, and not as admissions of prior art. 
         [0003]    A so-called commitment scheme can be said to be the digital equivalent of a sealed envelope: whatever is in the envelope remains secret until the envelope is opened. At the same time, the sender cannot change his mind about the content once the envelope has been closed. The goal of the commitment scheme is thus to force a sender to define a message that cannot be changed until it is revealed at some time in the future. 
         [0004]    Commitment schemes can be non-interactive, which means that the so-called commitment phase and the opening phase both consist of a single message from the sender to the receiver. Put another way, the receiver does not have to interact with the sender in any way other than to receive messages. 
         [0005]    A trapdoor commitment is a perfectly hiding commitment (i.e. where the hiding property holds even against an unbounded adversary) for which a trapdoor tk makes it possible to break the binding property and open a commitment to an arbitrary value. However, this should remain infeasible without the trapdoor. As will be seen during the description of the invention, a trapdoor commitment uses two additional algorithms called FakeCom and FakeOpen. 
         [0006]    In a simulation-sound trapdoor commitment (SSTC), each commitment is labeled with a tag. A definition is given in P. MacKenzie, K. Yang. On Simulation-Sound Trapdoor Commitments. In  Eurocrypt&#39; 04 , Lecture Notes in Computer Science , vol. 3027, pages 382-400, 2004. This definition requires that even if the adversary is allowed to see equivocations of commitments to possibly distinct messages for several tags tag 1 , . . . , tag q , it will not be able to break the binding property for a new tag ∉ {tag 1 , . . . , tag q }. 
         [0007]    Another desirable property of a commitment scheme is that an adversary cannot commit to messages that are correlated to those of honest players. The notion of independence with respect to opening captures that the messages to which the adversary can open its commitment should be independent of the way honest senders&#39; commitments are opened. See G. Di Crescenzo, Y. Ishai, R. Ostrovsky. Non-Interactive and Non-Malleable Commitment. In  STOC&#39; 98, pages 141-150, 1998. and R. Gennaro and S. Micali. Independent Zero-Knowledge Sets. In  ICALP&#39; 06 , Lecture Notes in Computer Science, vol.  4052, pages 34-45, 2006. 
         [0008]    For the commitments, groups (         ,            T ) of prime order p&gt;2 λ  are considered, where λ is a security parameter, over which the discrete logarithm problem is presumed hard. Moreover an efficiently computable bilinear map (a.k.a. pairing) is assumed; e:          ×         →           T . Namely, for any g, h∈          and any a, b∈         , e(g a ,h b )=e(g,h) ab . Moreover, e(g,h)≠         , if and only if g≠          and h≠         . 
         [0009]    In these groups, it is possible to rely on the following hardness assumptions:
       the Computational Diffie-Hellman Problem (CDH);   the Decision Linear Problem (DLIN)—see D. Boneh, X. Boyen, H. Shacham. Short Group Signatures. In  Crypto&#39; 04 , Lecture Notes in Computer Science , vol. 3152, pages 41-55, Springer, 2004; and   the Simultaneous Double Pairing problem (SDP). This assumption is implied by the DLIN assumption in the group          —see M. Abe, K. Haralambiev, M. Ohkubo. Signing on Elements in Bilinear Groups for Modular Protocol Design. Cryptology ePrint Archive: Report 2010/133, 2010.       
 
         [0013]    The prior art comprises several constructions of non-interactive non-malleable commitments that are not re-usable in that the adversary is only given one honestly generated commitment before outputting a commitment of its own. See for example:
       G. Di Crescenzo, Y. Ishai, R. Ostrovsky. Non-Interactive and Non-Malleable Commitment. In  STOC&#39; 98, pp. 141-150, 1998.   U.S. Pat. No. 6,301,664 (G. Di Crescenzo, Y. Ishai, R. Ostrovsky. Method and System for Non-Malleable and Non-Interactive Cryptographic Commitment in a Network. 2001.)   G. Di Crescenzo, J. Katz, R. Ostrovsky, A. Smith. Efficient and Non-interactive Non-malleable Commitment. In  Eurocrypt&#39; 01 , Lecture Notes in Computer Science , vol. 2045, pp. 40-59, 2001.       
 
         [0017]    The notion of re-usable non-malleable commitments was proposed by Damgård and Groth [I. Damgård, J. Groth. Non-interactive and reusable non-malleable commitment schemes. In  STOC&#39; 03, pages 426-437, 2003.]. Re-usable non-malleable commitments can be constructed from simulation-sound trapdoor commitments [see J. Garay, P. MacKenzie, K. Yang. Strengthening Zero-Knowledge Protocols Using Signatures. In  Eurocrypt&#39; 03 , Lecture Notes in Computer Science , vol. 2656, pp. 177-194, 2003. and P. MacKenzie, K. Yang. On Simulation-Sound Trapdoor Commitments. In  Eurocrypt&#39; 04 , Lecture Notes in Computer Science , vol. 3027, pp. 382-400, 2004.] and multi-trapdoor commitments [R. Gennaro. Multi-Trapdoor Commitments and Their Applications to Proofs of Knowledge Secure Under Concurrent Man-in-the-Middle Attacks. In  Crypto&#39; 04 , Lecture Notes in Computer Science , vol. 3152, pp. 220-236, 2004]. 
         [0018]    In their paper, MacKenzie and Yang gave constructions of SSTCs from signature schemes admitting efficient Σ protocols. As is known in the art, a Σ protocol is a three move interactive protocol between a prover and a verifier. In fact, as noted by Fujisaki [E. Fujisaki. New Constructions of Efficient Simulation-Sound Commitments Using Encryption and Their Applications. In  CT - RSA&#39; 12 , Lecture Notes in Computer Science , vol. 7178, pp. 136-155, 2012.], all known constructions of noninteractive simulation-sound or multi-trapdoor [see the paper by Gennaro] commitments build on signature schemes for which an efficient Σ protocol allows proving knowledge of a signature. 
         [0019]    The idea is to commit to a message m by using m as the challenge of a Σ protocol for proving knowledge of a signature σ=Sig(sk, tag) on the tag. The commitment is given by the first message a of the Σ protocol transcript (a, m, z), which is obtained by simulating a proof of knowledge of a valid signature σ on the message tag. The commitment is subsequently opened by revealing z. By the special soundness of the Σ protocol, unless the sender actually knows a valid signature on tag, it can only open a given commitment a to one message m. 
         [0020]    While simple, the above construction does not readily extend to commit to vectors if we want the sender to remain able to efficiently prove statements about individual coordinates of the committed vector. Moreover, the method based on Σ protocol does not make it possible to commit to vectors of group elements: to this end, we would need a Σ protocol where challenges are vectors of group elements. In the previously mentioned paper, Fujisaki gave an alternative construction of SSTC system based on encryption schemes. However, this construction is interactive as several rounds of interaction are needed between the sender and the receiver during the commitment phase. 
         [0021]    Non-interactive commitments to group elements were described in for example:
       J. Groth. Simulation-Sound NIZK Proofs for a Practical Language and Constant Size Group Signatures. In  Asiacrypt&#39; 06 , Lecture Notes in Computer Science , vol. 4284, pp. 444-459, Springer, 2006.   J. Groth, A. Sahai. Efficient non-interactive proof systems for bilinear groups. In  Eurocrypt&#39; 08 , Lecture Notes in Computer Science , vol. 4965, pp. 415-432, 2008.   J. Cathalo, B. Libert, M. Yung. Group Encryption: Non-Interactive Realization in the Standard Model. In  Asiacrypt&#39; 09 , Lecture Notes in Computer Science , vol. 5912, pp. 179-196, 2009.   J. Groth. Homomorphic trapdoor commitments to group elements. Cryptology ePrint Archive: Report 2009/007, 2009.       
 
         [0026]    However, these schemes are all homomorphic and thus malleable. To date, the only known non-interactive non-malleable commitment schemes whose messages and openings only consist of group elements were described by Fischlin et al. [see M. Fischlin, B. Libert, M. Manulis. Non-interactive and Re-usable Universally Composable String Commitments with Adaptive Security. In  Asiacrypt&#39; 11 , Lecture Notes in Computer Science , vol. 7073, pp. 468-485, 2011.]. However, these constructions cannot be length-reducing (i.e., the commitment cannot be shorter than the message) as they achieve universal composability [see R. Canetti. Universally Composable Security: A New Paradigm for Cryptographic Protocols. In  FOCS&#39; 01 pp. 136-145, 2001. and R. Canetti, M. Fischlin. Universally Composable Commitments. In  Crypto&#39; 01 , Lecture Notes in Computer Science , vol. 2139, pp. 19-40, 2001] and it is known that universally composable commitments must be extractable (namely, a trapdoor information should make it possible to recover the message contained in the commitment). 
         [0027]    It will thus be appreciated that it is desired to have a commitment scheme that provides a modular construction of non-interactive non-malleable trapdoor commitment to vectors {right arrow over (m)}=(m 1 , . . . , m n ) while retaining the ability of efficiently proving properties about individual vector coordinates {m i } i=1   n . This precludes the trivial solution consisting in committing to a hash value of the vector {right arrow over (m)}. It is also desired that the scheme enables to commit to group elements without knowing their discrete logarithms. In other words, the messages to be committed to should consist of vectors (M 1 , . . . , M n )∈           n  of group elements, where           is a group over which a bilinear map e:          ×         →           T  is efficiently computable. The commitment scheme should preferably also be designed so that the commitment string com has constant size, no matter how many group elements (M 1 , . . . , M n ) are committed to at once. Finally, openings should preferably also consist of elements in          , which will make it possible to generate efficient non-interactive proofs (using the techniques of [J. Groth, A. Sahai. Efficient non-interactive proof systems for bilinear groups. In  Eurocrypt&#39; 08 , Lecture Notes in Computer Science , vol. 4965, pp. 415-432, 2008.]) that committed group elements satisfy certain properties. The present invention provides such a commitment scheme. 
       SUMMARY OF INVENTION 
       [0028]    In a first aspect, the invention is directed to a method of generating a non-malleable cryptographic commitment. A processor of a device receives a vector, a public verification key of a homomorphic signature scheme associated with a space where signatures live, and a tag; chooses an element in the space where signatures live; generates a commitment using the vector, the public verification key, the tag and the element; and outputs the commitment. The commitment is generated by evaluating a linear function F used in a verification algorithm of the homomorphic signature scheme on the vector {right arrow over (m)}, the public verification key, the tag and the element σ. 
         [0029]    In a first embodiment, the size of the commitment is independent of the size of the vector. 
         [0030]    In a second embodiment, wherein the vector comprises elements of a group           over which a bilinear map          ×         →           T  is efficiently computable. 
         [0031]    In a third embodiment, the dimension of the vector is greater than or equal to 2. 
         [0032]    In a fourth embodiment, the commitment allows to prove knowledge of an opening using zero-knowledge proof. 
         [0033]    In a fifth embodiment, the commitment is generated as intermediate values resulting from the verification algorithm. 
         [0034]    In a second aspect, the invention is directed to a device for generating a non-malleable cryptographic commitment. The device comprises at least one interface configured to: receive a vector, a public verification key of a homomorphic signature scheme associated with a space where signatures live, and a tag; and output a commitment. The device further comprises a processor configured to: choose an element in the space where signatures live; an generate the commitment using the vector, the public verification key, the tag and the element. The processor is configured to generate the commitment by evaluating a linear function F used in a verification algorithm of the homomorphic signature scheme on the vector {right arrow over (m)}, the public verification key, the tag and the element σ. 
         [0035]    In a first embodiment, the size of the commitment is independent of the size of the vector. 
         [0036]    In a second embodiment, wherein the vector comprises elements of a group           over which a bilinear map          ×         →           T  is efficiently computable. 
         [0037]    In a second embodiment, the dimension of the vector is greater than or equal to 2. 
         [0038]    In a third embodiment, the commitment allows to prove knowledge of an opening using zero-knowledge proof. 
         [0039]    In a fourth embodiment, the commitment is generated as intermediate values resulting from the verification algorithm. 
         [0040]    In a third aspect, the invention is directed to a non-transitory computer program product storing instructions that, when executed by a processor, perform the method of any embodiment of the first aspect. 
     
    
     
       BRIEF DESCRIPTION OF DRAWINGS 
         [0041]    Preferred features of the present invention will now be described, by way of non-limiting example, with reference to the accompanying drawings, in which: 
           [0042]      FIG. 1  illustrates a cryptographic device for generating commitments and a cryptographic device for verification of commitments according to a preferred embodiment of the invention; and 
           [0043]      FIG. 2  illustrates a method for generating a commitment and for verifying the opening of a commitment according to a preferred embodiment of the invention. 
       
    
    
     DESCRIPTION OF EMBODIMENTS 
       [0044]    A main idea of the present invention is based on that, under a certain mild condition, linearly homomorphic structure-preserving signatures imply length-reducing non-malleable structure-preserving commitments to vectors of group elements. As a result, the invention provides a length-reducing non-malleable structure-preserving trapdoor commitment. It will be noted that the scheme is not strictly structure-preserving (which is to say that the commitment string does not live in the same group as the message, according to the terminology of M. Abe, K. Haralambiev, M. Ohkubo. Group to Group Commitments Do Not Shrink. In  Eurocrypt&#39; 12 , Lecture Notes in Computer Science , vol. 7237, pp. 301-317, 2012.). Rather, the scheme is structure-preserving in the non-strict sense as the commitment string lives in            T  rather than           (but, as shown in the paper, strictly structure-preserving commitments cannot be length-reducing). Still, openings only consist of elements in          , which makes it possible to generate efficient non-interactive proofs that committed group elements satisfy certain properties. 
         [0045]    The schemes of the present invention are obtained by first constructing simulation-sound trapdoor commitments (SSTC) to group elements (see J. Garay, P. MacKenzie, K. Yang Strengthening Zero-Knowledge Protocols Using Signatures. In  Eurocrypt&#39; 03 , Lecture Notes in Computer Science , vol. 2656, pp. 177-194, 2003 and P. MacKenzie, K. Yang. On Simulation-Sound Trapdoor Commitments. In  Eurocrypt&#39; 04 , Lecture Notes in Computer Science , vol. 3027, pp. 382-400, 2004). 
         [0046]    SSTC schemes were first suggested in the paper by Garay, MacKenzie and Yang as a tool for constructing universally composable zero-knowledge proofs (see R. Canetti. Universally Composable Security: A New Paradigm for Cryptographic Protocols. In  FOCS&#39; 01, pp. 136-145, 2001.) MacKenzie and Yang subsequently gave a simplified security definition that suffices to provide non-malleability with respect to opening in the sense of the definition of re-usable non-malleable commitments (see I. Damgård, J. Groth. Non-interactive and reusable non-malleable commitment schemes. In  STOC&#39; 03, pages 426-437, 2003.). 
         [0047]    It is first noted that any constant-size linearly homomorphic structure-preserving signature necessarily complies with the following template. 
         [0000]    Keygen(pp, n): given public parameters pp, which contain the description of groups (         ,            T ) with a bilinear map, and the dimension n∈          of the subspace to be signed, choose constants n z , n v , m∈         . Of these, n z  and n v  determine the signature length while m is the number of equations in the verification algorithm. Then choose elements {F j,μ } j∈{1, . . . , m}, μ∈{1, . . . , n     z     } , {G ji } i∈{1, . . . , n}, j∈{1, . . . , m}  the group          . The public key is 
         [0000]        pk =({ F   j,μ } j∈{1, . . . ,m},μ∈{1, . . . ,n   z   },{G   ji } i∈{1, . . . ,n},j∈{1, . . . ,m} ) 
         [0000]    and the private key comprises information related to the representation of public key elements with regard to specific bases.
 
Sign(sk, τ, (M 1 , . . . , M n )): outputs a tuple
 
         [0000]      σ=( Z   1   , . . . ,Z   n     z     ,V   1   , . . . ,V   n     v   )∈           n     z     +n     v   .
 
         [0000]    SignDerive(pk, τ, {(ω i , σ (i) )} i=1   l ): parses each signature σ (i)  as (Z 1   (i) , . . . , Z n     z     (i) , V 1   (i) , . . . , V n     v     (i) ) for i=1 to l and then computes 
         [0000]    
       
         
           
             
               Z 
               μ 
             
             = 
             
               
                 ∏ 
                 
                   i 
                   = 
                   1 
                 
                  
               
                
               
                 Z 
                 μ 
                 
                   
                     ( 
                     i 
                     ) 
                   
                   
                     ω 
                     i 
                   
                 
               
             
           
         
       
       
         
           
             
               V 
               v 
             
             = 
             
               
                 ∏ 
                 
                   i 
                   = 
                   1 
                 
                  
               
                
               
                 V 
                 v 
                 
                   
                     ( 
                     i 
                     ) 
                   
                   
                     ω 
                     i 
                   
                 
               
             
           
         
       
       
         
           
             
               μ 
               ∈ 
               
                 { 
                 
                   1 
                   , 
                   … 
                    
                   
                       
                   
                   , 
                   
                     n 
                     z 
                   
                 
                 } 
               
             
             , 
             
               
 
             
              
             
               v 
               ∈ 
               
                 { 
                 
                   1 
                   , 
                   … 
                    
                   
                       
                   
                   , 
                   
                     n 
                     v 
                   
                 
                 } 
               
             
           
         
       
     
         [0000]    and outputs, possibly after a re-randomization step, σ=(Z 1 , . . . , Z n     z   , V 1 , . . . , V n     v   ).
 
Verify(pk, σ, τ, (M 1 , . . . , M n )): given a signature σ=(Z 1 , . . . , Z n     z   , V 1 , . . . , V n     v   )∈           n     z     +n     v   , a vector (M 1 , . . . , M n ) and a tag τ, return 0 if (M 1 , . . . , M n )=(         , . . . ,          ).
 
       Otherwise: 
       [0000]    
       
         
           
             1. For each j∈{1, . . . , m} and v∈{1, . . . , n v }, compute one-to-one encodings T j,v ∈          of the tag τ as a group element. (It is possible to relax this condition to have collision-resistant deterministic encodings. Here, injectivity is assumed for simplicity.) 
             1. For j=1 to m, compute 
           
         
       
     
         [0000]    
       
         
           
             
               
                 c 
                 j 
               
               = 
               
                 
                   ∏ 
                   
                     μ 
                     = 
                     1 
                   
                   
                     n 
                     z 
                   
                 
                  
                 
                     
                 
                  
                 
                   
                     e 
                      
                     
                       ( 
                       
                         
                           F 
                           
                             j 
                             , 
                             μ 
                           
                         
                         , 
                         
                           Z 
                           μ 
                         
                       
                       ) 
                     
                   
                   · 
                   
                     
                       ∏ 
                       
                         v 
                         = 
                         1 
                       
                       
                         n 
                         v 
                       
                     
                      
                     
                         
                     
                      
                     
                       
                         e 
                          
                         
                           ( 
                           
                             
                               T 
                               
                                 j 
                                 , 
                                 v 
                               
                             
                             , 
                             
                               V 
                               v 
                             
                           
                           ) 
                         
                       
                       · 
                     
                   
                 
               
             
              
             
               
                 ∏ 
                 
                   i 
                   = 
                   1 
                 
                 n 
               
                
               
                   
               
                
               
                 e 
                  
                 
                   ( 
                   
                     
                       G 
                       
                         j 
                         , 
                         i 
                       
                     
                     , 
                     
                       M 
                       i 
                     
                   
                   ) 
                 
               
             
           
         
       
       
         
           
             2. Return 1 if and only if c j =          for each j∈{1, . . . , m}. 
           
         
       
     
         [0051]    In the following description, a linearly homomorphic structure-preserving signature is ‘regular’ if, for each file identifier (i.e. ‘tag’), any non-trivial vector (M 1 , . . . , M n )≠(         , . . . ,          ) has a valid signature. 
         [0052]      FIG. 1  illustrates a cryptographic device  100  for generating commitments and a cryptographic device  200  for verification of commitments according to a preferred embodiment of the invention. The devices  100 ,  200  each comprise at least one interface unit  110 ,  210  configured for communication, at least one processor (“processor”)  120 ,  220  and at least one memory  130 ,  230  configured for storing data, such as accumulators and intermediary calculation results.  FIG. 1  also shows a first and a second computer program product (non-transitory storage medium)  140 ,  240  such as a CD-ROM or a DVD comprises stored instructions that, when executed by the processor  120 ,  220 , respectively generate and verify a commitment according to the present invention. 
       Construction of Structure-Preserving Simulation-Sound Trapdoor Commitments 
       [0053]    If Π SPS =(Keygen, Sign, SignDerive, Verify) is a linearly homomorphic structure-preserving signature (SPS), then a structure-preserving simulation-sound trapdoor commitment (SSTC) may be constructed as follows: 
         [0000]    SSTC.Setup(λ, n): given the desired dimension n∈          of committed vectors, choose public parameters pp for the linearly homomorphic SPS scheme. Then run Π SPS ·Keygen(pp, n) to obtain pk=({F j,μ } j∈{1, . . . , m}, μ∈{1, . . . , n     z     } , {G ji } i∈{1, . . . , n}, j∈{1, . . . , m} ) for some constants n z , n v , m and a secret key sk. The commitment key is pk=pk and the trapdoor tk consists of sk. It is to be noted that the public key defines a signature space            n     z     +n     v    for constants n z  and n v .
 
SSTC.Com(pk, tag, (M 1 , . . . , M n )): to commit to a vector (M 1 , . . . , M n )∈           n  with respect to the tag tag=τ, choose
 
         [0000]    
       
         
           
             
               ( 
               
                 
                   Z 
                   1 
                 
                 , 
                 … 
                  
                 
                     
                 
                 , 
                 
                   Z 
                   
                     n 
                     z 
                   
                 
                 , 
                 
                   V 
                   1 
                 
                 , 
                 … 
                  
                 
                     
                 
                 , 
                 
                   V 
                   
                     n 
                     v 
                   
                 
               
               ) 
             
              
             
                
               R 
             
              
             
                
               
                 
                   n 
                   z 
                 
                 + 
                 
                   n 
                   v 
                 
               
             
           
         
       
     
         [0000]    in the signature space. Then run steps 1 and 2 of Verify(pk, σ, τ, (M 1 , . . . , M n )), i.e. compute 
         [0000]    
       
         
           
             
               
                 c 
                 j 
               
               = 
               
                 
                   ∏ 
                   
                     μ 
                     = 
                     1 
                   
                   
                     n 
                     z 
                   
                 
                  
                 
                     
                 
                  
                 
                   
                     e 
                      
                     
                       ( 
                       
                         
                           F 
                           
                             j 
                             , 
                             μ 
                           
                         
                         , 
                         
                           Z 
                           μ 
                         
                       
                       ) 
                     
                   
                   · 
                   
                     
                       ∏ 
                       
                         v 
                         = 
                         1 
                       
                       
                         n 
                         v 
                       
                     
                      
                     
                         
                     
                      
                     
                       
                         e 
                          
                         
                           ( 
                           
                             
                               T 
                               
                                 j 
                                 , 
                                 v 
                               
                             
                             , 
                             
                               V 
                               v 
                             
                           
                           ) 
                         
                       
                       · 
                     
                   
                 
               
             
              
             
               
                 ∏ 
                 
                   i 
                   = 
                   1 
                 
                 n 
               
                
               
                   
               
                
               
                 e 
                  
                 
                   ( 
                   
                     
                       G 
                       
                         j 
                         , 
                         i 
                       
                     
                     , 
                     
                       M 
                       i 
                     
                   
                   ) 
                 
               
             
           
         
       
       
         
           
             j 
             ∈ 
             
               { 
               
                 1 
                 , 
                 … 
                  
                 
                     
                 
                 , 
                 m 
               
               } 
             
           
         
       
     
         [0000]    where {T j,v } j,v  form an injective encoding of tag=τ as a set of group elements. The commitment string is given by com=(c 1 , . . . , c m ) whereas the de-commitment consists of dec=(Z 1 , . . . , Z n     z   , V 1 , . . . , V n     v   ).
 
SSTC.FakeCom(pk, tk, tag): proceeds like SSTC.Com with
 
         [0000]    
       
         
           
             
               
                 ( 
                 
                   
                     
                       M 
                       ^ 
                     
                     1 
                   
                   , 
                   … 
                    
                   
                       
                   
                   , 
                   
                     
                       M 
                       ^ 
                     
                     n 
                   
                 
                 ) 
               
                
               
                  
                 R 
               
                
               
                  
                 n 
               
             
             . 
           
         
       
     
         [0000]    If (         ,          ) denotes the resulting pair, the algorithm ouputs          =          and aux, which consists of the pair aux=(({circumflex over (M)} 1 , . . . , {circumflex over (M)} n ),          ) for tag=τ.
 
SSTC.FakeOpen(aux, tk, tag,          , (M 1 , . . . , M n )): parses           as ({tilde over (c)} 1 , . . . , {tilde over (c)} m ) and aux as (({circumflex over (M)} 1 , . . . , {circumflex over (M)} n ), ({circumflex over (Z)} 1 , . . . , {circumflex over (Z)} n     z   , {circumflex over (V)} 1 , . . . , {circumflex over (V)} n     v   )). It first generates a linearly homomorphic signature on (M 1 /{circumflex over (M)} 1 , . . . , M n /{circumflex over (M)} n ) for the tag=τ. Namely, using the trapdoor tk=sk, compute
 
         [0000]      σ′=( Z′   1   , . . . ,Z′   n     z     ,V′   1   , . . . ,V′   n     z   )←Π SPS ·Sign( sk ,τ,( M   1   /{circumflex over (M)}   1   , . . . ,M   n   /{circumflex over (M)}   n )).
 
         [0054]    Since σ′ is a valid signature and aux=(({circumflex over (M)} 1 , . . . , {circumflex over (M)} n ),({circumflex over (Z)} 1 , . . . , {circumflex over (Z)} n     z   , {circumflex over (V)} 1 , . . . , {circumflex over (V)} n     v   )) satisfies 
         [0000]    
       
         
           
             
               
                 c 
                 ~ 
               
               j 
             
             = 
             
               
                 ∏ 
                 
                   μ 
                   = 
                   1 
                 
                 
                   n 
                   z 
                 
               
                
               
                 
                   e 
                    
                   
                     ( 
                     
                       
                         F 
                         
                           j 
                           , 
                           μ 
                         
                       
                       , 
                       
                         
                           Z 
                           ^ 
                         
                         μ 
                       
                     
                     ) 
                   
                 
                 · 
                 
                   
                     ∏ 
                     
                       v 
                       = 
                       1 
                     
                     
                       n 
                       v 
                     
                   
                    
                   
                     
                       e 
                        
                       
                         ( 
                         
                           
                             T 
                             
                               j 
                               , 
                               v 
                             
                           
                           , 
                           
                             
                               V 
                               ^ 
                             
                             v 
                           
                         
                         ) 
                       
                     
                     · 
                     
                       
                         ∏ 
                         
                           i 
                           = 
                           1 
                         
                         n 
                       
                        
                       
                         e 
                          
                         
                           ( 
                           
                             
                               G 
                               
                                 j 
                                 , 
                                 i 
                               
                             
                             , 
                             
                               
                                 M 
                                 ^ 
                               
                               i 
                             
                           
                           ) 
                         
                       
                     
                   
                 
               
             
           
         
       
       
         
           
             j 
             ∈ 
             
               { 
               
                 1 
                 , 
                 … 
                  
                 
                     
                 
                 , 
                 m 
               
               } 
             
           
         
       
     
         [0000]    the fake opening algorithm can run 
         [0000]      ( {tilde over (Z)}   1   , . . . ,{tilde over (Z)}   n     z     ,{tilde over (V)}   1   , . . . ,{tilde over (V)}   n     v   )←Sign·Derive( pk ,τ,{(1,σ′),(1,{circumflex over (σ)})}),
 
         [0000]    where {circumflex over (σ)}=({circumflex over (Z)} 1 , . . . , {circumflex over (Z)} n     z   , {circumflex over (V)} 1 , . . . , {circumflex over (V)} n     v   ). By construction,          =({tilde over (Z)} 1 , . . . , {tilde over (Z)} n     z   , {tilde over (V)} 1 , . . . , {tilde over (V)} n     v   ) is a valid de-commitment to the vector (M 1 , . . . , M n ) with respect to tag=τ.
 
SSTC.Verify(pk, tag, (M 1 , . . . , M n ), com, dec): parses the commitment as (c 1 , . . . , c m )∈           T   m  and the opening dec as (Z 1 , . . . , Z n     z   , V 1 , . . . , V n     v   )∈           n     z     +n     v   . If these do not parse properly, it returns 0. Then it computes a one-to-one encoding {T j,v } j,v  of tag=τ. Return 1 if
 
         [0000]    
       
         
           
             
               c 
               j 
             
             = 
             
               
                 ∏ 
                 
                   μ 
                   = 
                   1 
                 
                 
                   n 
                   z 
                 
               
                
               
                 
                   e 
                    
                   
                     ( 
                     
                       
                         F 
                         
                           j 
                           , 
                           μ 
                         
                       
                       , 
                       
                         Z 
                         μ 
                       
                     
                     ) 
                   
                 
                 · 
                 
                   
                     ∏ 
                     
                       v 
                       = 
                       1 
                     
                     
                       n 
                       v 
                     
                   
                    
                   
                     
                       e 
                        
                       
                         ( 
                         
                           
                             T 
                             
                               j 
                               , 
                               v 
                             
                           
                           , 
                           
                             V 
                             v 
                           
                         
                         ) 
                       
                     
                     · 
                     
                       
                         ∏ 
                         
                           i 
                           = 
                           1 
                         
                         n 
                       
                        
                       
                         e 
                          
                         
                           ( 
                           
                             
                               G 
                               
                                 j 
                                 , 
                                 i 
                               
                             
                             , 
                             
                               M 
                               i 
                             
                           
                           ) 
                         
                       
                     
                   
                 
               
             
           
         
       
       
         
           
             j 
             ∈ 
             
               { 
               
                 1 
                 , 
                 … 
                  
                 
                     
                 
                 , 
                 m 
               
               } 
             
           
         
       
     
         [0000]    holds and 0 otherwise.
 
SSTC from Linearly Homomorphic Signatures
 
         [0055]    This section provides a generalization of the previous structure-preserving construction. The goal is to construct simulation-sound (thus non-malleable) commitments to vectors from linearly homomorphic signatures. It is to be noted that the prior art schemes for constructing SSTCs do not directly allow committing to vectors while preserving the feasibility of efficiently proving knowledge of the committed vector. The method is illustrated in  FIG. 2 . 
         [0056]    Let Π=(Keygen, Sign, SignDerive, Verify) is a linearly homomorphic signature over            p   n  for some large prime p&gt;2 λ . It is assumed that Π uses groups            1  and            2  of public orders p k  and p, respectively, for some k∈         . It is also assumed that each signature σ lives in            1 . The verification algorithm takes as input a purported signature σ∈           1 , a file identifier τ and a vector {right arrow over (m)}. It returns 1 if and only if F(σ,{right arrow over (m)},pk,τ)=         , where F is a function ranging over the group            2  and satisfying certain linearity properties. Namely, for each pk produced by Keygen and each τ, it is required that F(σ 1 ·σ 2 ,{right arrow over (m)} 1 +{right arrow over (m)} 2 ,pk,τ)=F(σ 1 ,{right arrow over (m)} 1 ,pk,τ)·F(σ 2 ,{right arrow over (m)} 2 ,pk,τ) for any vectors {right arrow over (m)} 1 ,{right arrow over (m)} 2 ∈           p   n  and any σ 1 ,σ 2 ∈           1 . As a consequence F(σ,{right arrow over (m)},pk,τ) ω =F(σ ω ,ω·{right arrow over (m)},pk,τ) for any ω∈           p  and any σ∈           1 . 
         [0057]    It is to be noted that this template only captures schemes in groups of public order, so that constructions based on the Strong RSA assumption are not covered. The reason is that, when working over the integers, messages and signature components may increase at each homomorphic operation, which makes it harder to render fake openings indistinguishable from original de-commitments. 
         [0000]    SSTC.Setup(λ, n): given the desired dimension n∈          of committed vectors, choose public parameters pp for the linearly homomorphic signature. Then run key generation algorithm Π SPS ·Keygen(pp,n) to obtain a public key pk and a private key sk. The commitment key is pk=pk and the trapdoor tk consists of sk.
 
SSTC.Com(pk, tag, {right arrow over (m)}): to commit to a vector {right arrow over (m)}∈           p   n  with respect to the tag, choose S1 an element
 
         [0000]    
       
         
           
             σ 
              
             
                
               R 
             
              
             
               1 
             
           
         
       
     
         [0000]    in the signature space. Compute S2 and output S3 c=F (σ, {right arrow over (m)}, pk, tag) by evaluating F as the left-hand member of the verification equation F(σ, {right arrow over (m)}, pk, z)=         . The commitment string is com=c whereas the de-commitment is dec=σ.
 
SSTC.FakeCom(pk, tk, tag): proceeds like SSTC.Com but using a randomly chosen vector
 
         [0000]    
       
         
           
             
               
                 
                   m 
                    
                 
                 fake 
               
                
               
                  
                 R 
               
                
               
                 p 
                 n 
               
             
             . 
           
         
       
     
         [0000]    If (         ,          ) denotes the resulting commitment/decommitment pair, the algorithm sets          =          and aux=({right arrow over (m)} fake ,          ).
 
SSTC.FakeOpen(aux, tk, tag,          , {right arrow over (m)}): parses           as {tilde over (c)}∈           2  and aux as ({right arrow over (m)} fake ,          ), where          ={circumflex over (σ)}∈           1 . It first generates a linearly homomorphic signature on the coordinate-wise difference {right arrow over (m)}−{right arrow over (m)} fake ∈           p   n  for the tag=τ. Namely, using the trapdoor tk=sk, it computes σ′←Π·Sign(sk, τ, {right arrow over (m)}−{right arrow over (m)} fake ). Finally, it computes {tilde over (σ)}={circumflex over (σ)}·σ′∈           1  and returns          ={tilde over (σ)}.
 
SSTC.Verify(pk, tag, {right arrow over (m)}, com, dec): parses S4 the commitment com as c∈           2  and the opening dec as σ∈           1 . If these do not parse properly, it returns S5 0. Otherwise, it returns S6 1 if c=F(σ,{right arrow over (m)},pk,tag) and 0 otherwise.
 
         [0058]    The linearly homomorphic scheme of Attrapadung et al. (see N. Attrapadung, B. Libert, T. Peters. Computing on Authenticated Data: New Privacy Definitions and Constructions. In  Asiacrypt&#39; 12, in  Lecture Notes in Computer Science  vol. 7658, pp. 367-385, 2012.) can be seen as a specific instantiation of the template where the group            1  is a product            1 =           2 ×           p , which is a group for the operation (·, ·, +), and            2 =           T . In the scheme,            1  and            2  thus have order p 3  and p, respectively. As for the linear function F, it can be instantiated as 
         [0000]        F ((σ 1 ,σ 2   ,s ), {right arrow over (m)},pk ,τ):= e (σ 1   ,g   −1 )· e (         (τ),σ 2 )· e ( g   1   m     1      . . . g   n   m     n     ·v   s   ,g   a )
 
         [0059]    As a result, a new non-interactive simulation-sound trapdoor commitment to vectors based on the Computational Diffie-Hellman (CDH) assumption is obtained. 
         [0060]    It is noted that this scheme can be optimized by removing the terms v s  and s so as to have (σ 1 ,σ 2 )=((Π i=1   n g i   m     i   ) α ·         (τ) r ,g r ) and 
         [0000]        F ((σ 1 ,σ 2 ), {right arrow over (m)},pk ,τ):= e (σ 1   ,g   −1 )· e (         (τ),σ 2 )· e ( g   n   m     1      . . . g   n   m     n     ,g   α )
 
         [0061]    Indeed, although the terms (v s ,s)∈         ×           p  are necessary in the underlying signature scheme, they can be eliminated in the resulting commitment. 
         [0062]    The optimization gives rise to the following SSTC scheme which relies on the CDH assumption and which allows committing to vectors. It is to be noted that the prior art non-malleable commitments based on the CDH assumption were—implicitly or explicitly—described in two papers but it was not clear how to extend them to commit to vectors in a modular way (see Y. Dodis, V. Shoup, S. Walfish. Efficient Constructions of Composable Commitments and Zero-Knowledge Proofs. In  Crypto&#39; 08 , Lecture Notes in Computer Science , vol. 5157, pp. 21-38, 2008. and R. Nishimaki, E. Fujisaki, K. Tanaka. A Multi-trapdoor Commitment Scheme from the RSA Assumption. In  ACISP  2010 , Lecture Notes in Computer Science , vol. 6168, pp. 182-199, 2010.) 
         [0000]    SSTC.Setup(λ, n): given the desired dimension n∈          of committed vectors, choose bilinear groups (         ,            T ) of prime order p&gt;2 λ . Choose 
         [0000]    
       
         
           
             
               α 
                
               
                  
                 R 
               
                
               
                 p 
               
             
             , 
             
               g 
                
               
                  
                 R 
               
                
             
           
         
       
     
         [0000]    and u 0 , . . . , 
         [0000]    
       
         
           
             
               u 
               L 
             
              
             
                
               R 
             
              
           
         
       
     
         [0000]    for some L∈poly(λ). These elements u 0 , . . . , u L ∈           L+1  are used to implement a number-theoretic hash function          :{0,1} L &gt;          such that any L-bit string τ=τ[1] . . . τ[L]∈{0,1} L  is mapped to the hash value          (τ)=u 0 ·Π i=1   L u i   τ[i] . Then 
         [0000]    
       
         
           
             
               g 
               i 
             
              
             
                
               R 
             
              
           
         
       
     
         [0000]    are chosen for i=1 to n and the identifier space          :={0,1} L  is defined. The trapdoor is tk=α and the public key consists of pk=((         ,           T ),g,g α ,{g i } i=1   n ,{u i } i=0   L ).
 
SSTC.Com(pk, tag, {right arrow over (m)}): to commit to a vector {right arrow over (m)}=(m 1 , . . . m n )∈           p   n  with respect to the tag, choose elements σ 1 ,
 
         [0000]    
       
         
           
             
               σ 
               2 
             
              
             
                
               R 
             
              
           
         
       
     
         [0000]    in the signature space and compute 
         [0000]        c=e ( g   1   m     1      . . . g   n   m     n     ,g   α )· e ( g   −1 ,σ 1 )· e (         (tag),σ 2 ).
 
         [0063]    Return the commitment string com=c∈           T  and the de-commitment dec=(σ 1 ,σ 2 )∈           2 . 
         [0000]    SSTC.FakeCom(pk, tk, tag): proceeds like SSTC.Com but using a randomly chosen vector 
         [0000]    
       
         
           
             
               
                 
                   m 
                    
                 
                 fake 
               
                
               
                  
                 R 
               
                
               
                 p 
                 n 
               
             
             . 
           
         
       
     
         [0000]    If (         ,          ) denotes the resulting commitment/decommitment pair, the algorithm sets          =          and aux=({right arrow over (m)} fake ,          ).
 
SSTC.FakeOpen(aux, tk, tag,          , {right arrow over (m)}): parses           as {tilde over (c)}∈           T  and aux as ({right arrow over (m)} fake ,          ), where          =(σ 1 , σ 2 )∈           2 . It first generates a linearly homomorphic signature (σ′ l , σ′ 2 )∈           2  on the difference (m 1 ′, . . . , m n ′)={right arrow over (m)}−{right arrow over (m)} fake ∈           p   n  for the tag tag. Namely, using tk=α, it computes σ′ 1 =(g 1   m′     1    . . . g n   m′     n   ) α ·         (tag) r  and σ′ 2 =g r  which satisfies
 
         [0000]                =e( g   1   m′     1      . . . g   n   m′     n     ,g   α )· e ( g   −1 ,σ′ 1 )· e (         (tag),σ′ 2 ).
 
         [0000]    Finally, it computes ({tilde over (σ)} 1 ,{tilde over (σ)} 2 )=({circumflex over (σ)} 1 ·σ′ 1 ,{circumflex over (σ)} 2 ·σ′ 2 )∈           2  and returns          =({tilde over (σ)} 1 ,{tilde over (σ)} 2 ).
 
SSTC.Verify(pk, tag, {right arrow over (m)}, com, dec): parses the commitment com as c∈           T  and the opening dec as (σ 1 , σ 2 )∈           2 . If these do not parse properly, it returns 0. Otherwise, it returns 1 if (σ 1 , σ 2 ) satisfies c=e(g 1   m     1    . . . g n   m     n   ,g α )·e(g −1 ,σ 1 )·e(H         (tag),σ 2 ) and 0 otherwise.
 
Before the presentation of a further SSTC scheme, there follows a description of its underlying linearly homomorphic structure-preserving signature scheme.
 
Keygen(pp, n): given a security parameter and the dimension n∈          of the subspace to be signed, choose bilinear groups (         ,            T ) of prime order p&gt;2 λ  perform the following steps:
       1. Choose       
 
         [0000]    
       
         
           
             h 
              
             
                
               R 
             
              
           
         
       
     
         [0000]    and α z , α r , 
         [0000]    
       
         
           
             
               
                 β 
                 z 
               
                
               
                  
                 R 
               
                
               
                 p 
               
             
             . 
           
         
       
     
         [0000]    Define g z =h α     z   , g r =h α     r    and h z =h β     z   .
       2. For each i∈{1, . . . , n}, pick χ i , γ i ,       
 
         [0000]    
       
         
           
             
               δ 
               i 
             
              
             
                
               R 
             
              
             
               p 
             
           
         
       
     
         [0000]    and compute g i =g z   χi g r   γi , h i =h z   χi h δ     i   .
       3. Choose a random vector       
 
         [0000]    
       
         
           
             
               w 
               _ 
             
             = 
             
               
                 ( 
                 
                   
                     w 
                     0 
                   
                   , 
                   
                     w 
                     1 
                   
                   , 
                   … 
                    
                   
                       
                   
                   , 
                   
                     w 
                     L 
                   
                 
                 ) 
               
                
               
                 ← 
                 R 
               
                
               
                 
                   L 
                   + 
                   1 
                 
               
             
           
         
       
     
         [0000]    that defines a hash function          : {0,1} L →          which maps τ=τ[1] . . . τ[L]∈{0,1} L  to          (τ)=w 0 ·Π k=1   L w k   τ[k] .
        The public key consists of       
 
         [0000]        pk =( g   z   ,g   r   ,h   z   ,h,{g   i   ,h   i } i=1   n   ,  w   )∈           2n+4 ×           L+1  
 
         [0000]    while the private key is sk=(h z   α     r   ,{χ i ,γ i ,δ i } i=1   n ).
 
Sign(sk, τ, (M 1 , . . . , M n )): to sign a vector (M 1 , . . . , M n )∈           n  with regard to the file identifier τ using sk=(h z   α     r   ,{χ i ,γ i ,δ i } i=1   n ), choose θ,
 
         [0000]    
       
         
           
             ρ 
              
             
               ← 
               R 
             
              
             
               p 
             
           
         
       
     
         [0000]    and compute 
         [0000]    
       
         
           
             
               z 
               = 
               
                 
                   g 
                   r 
                   θ 
                 
                 · 
                 
                   
                     ∏ 
                     
                       i 
                       = 
                       1 
                     
                     n 
                   
                    
                   
                     M 
                     i 
                     
                       - 
                       
                         χ 
                         i 
                       
                     
                   
                 
               
             
             , 
             
               r 
               = 
               
                 
                   g 
                   z 
                   
                     - 
                     θ 
                   
                 
                 · 
                 
                   
                     ∏ 
                     
                       i 
                       = 
                       1 
                     
                     n 
                   
                    
                   
                     M 
                     i 
                     
                       - 
                       
                         γ 
                         i 
                       
                     
                   
                 
               
             
             , 
             
               
 
             
              
             
               u 
               = 
               
                 
                   
                     ( 
                     
                       h 
                       z 
                       
                         α 
                         r 
                       
                     
                     ) 
                   
                   
                     - 
                     θ 
                   
                 
                 · 
                 
                   
                     ∏ 
                     
                       i 
                       = 
                       1 
                     
                     n 
                   
                    
                   
                     
                       
                         M 
                         i 
                         
                           - 
                           
                             δ 
                             i 
                           
                         
                       
                       · 
                     
                      
                     
                       
                         ( 
                         τ 
                         ) 
                       
                       
                         - 
                         ρ 
                       
                     
                   
                 
               
             
             , 
             
               v 
               = 
               
                 h 
                 ρ 
               
             
           
         
       
     
         [0067]    The signature comprises σ=(z, r, u, v)∈           4 . 
         [0000]    SignDerive(pk, τ, {(ω i σ (i) )} i=1   l ): given pk, a file identifier τ and l tuples (ω i , σ (i) ), parse each signature σ (i)  as σ (i) =(z i ,r i ,u i ,v i )∈           4  for i=1 to l. Then choose 
         [0000]    
       
         
           
             
               ρ 
               ′ 
             
              
             
               ← 
               R 
             
              
             
               p 
             
           
         
       
     
         [0000]    and compute 
         [0000]    
       
         
           
             z 
             = 
             
               
                 ∏ 
                 
                   i 
                   = 
                   1 
                 
                 l 
               
                
               
                 z 
                 i 
                 
                   ω 
                   i 
                 
               
             
           
         
       
       
         
           
             r 
             = 
             
               
                 ∏ 
                 
                   i 
                   = 
                   1 
                 
                 l 
               
                
               
                 r 
                 i 
                 
                   ω 
                   i 
                 
               
             
           
         
       
       
         
           
             u 
             = 
             
               
                 ∏ 
                 
                   i 
                   = 
                   1 
                 
                 l 
               
                
               
                 
                   u 
                   i 
                   
                     ω 
                     i 
                   
                 
                 · 
                 
                   
                     
                       H 
                        
                     
                      
                     
                       ( 
                       τ 
                       ) 
                     
                   
                   
                     - 
                     
                       ρ 
                       ′ 
                     
                   
                 
               
             
           
         
       
       
         
           
             v 
             = 
             
               
                 ∏ 
                 
                   i 
                   = 
                   1 
                 
                 l 
               
                
               
                 
                   
                     v 
                     i 
                     
                       ω 
                       i 
                     
                   
                   · 
                   h 
                 
                  
                 
                     
                 
                  
                 
                   ρ 
                   ′ 
                 
               
             
           
         
       
     
         [0000]    and return σ=(z, r, u, v).
 
Verify(pk, σ, τ, (M 1 , . . . , M n )): given a signature σ=(z,r,u,v)∈           4 , a file identifier τ and a vector (M 1 , . . . , M n ), return 1 if and only if (M 1 , . . . , M n )≠(         , . . . ,          ) and (z, r, u, v) satisfy the equalities
 
         [0000]    
       
         
           
             
               = 
               
                 
                   e 
                    
                   
                     ( 
                     
                       
                         g 
                         z 
                       
                       , 
                       z 
                     
                     ) 
                   
                 
                 · 
                 
                   e 
                    
                   
                     ( 
                     
                       
                         g 
                         r 
                       
                       , 
                       r 
                     
                     ) 
                   
                 
                 · 
                 
                   
                     ∏ 
                     
                       i 
                       = 
                       1 
                     
                     n 
                   
                    
                   
                     e 
                      
                     
                       ( 
                       
                         
                           g 
                           i 
                         
                         , 
                         
                           M 
                           i 
                         
                       
                       ) 
                     
                   
                 
               
             
             , 
             
               
 
             
              
             
               = 
               
                 
                   e 
                    
                   
                     ( 
                     
                       
                         h 
                         z 
                       
                       , 
                       z 
                     
                     ) 
                   
                 
                 · 
                 
                   e 
                    
                   
                     ( 
                     
                       h 
                       , 
                       u 
                     
                     ) 
                   
                 
                 · 
                 
                   e 
                    
                   
                     ( 
                     
                       
                          
                         
                           ( 
                           τ 
                           ) 
                         
                       
                       , 
                       v 
                     
                     ) 
                   
                 
                 · 
                 
                   
                     ∏ 
                     
                       i 
                       = 
                       1 
                     
                     n 
                   
                    
                   
                     
                       e 
                        
                       
                         ( 
                         
                           
                             h 
                             i 
                           
                           , 
                           
                             M 
                             i 
                           
                         
                         ) 
                       
                     
                     . 
                   
                 
               
             
           
         
       
     
         [0000]    SSTC from Linearly Homomorphic Structure-Preserving Signatures 
         [0068]    A particularly advantageous embodiment is obtained by applying the Construction of Structure-Preserving Simulation-Sound Trapdoor Commitments to the linearly homomorphic signature described hereinafter. 
         [0069]    Like the underlying homomorphic signature, the security of the resulting SSTC (which is structure-preserving) relies on the hardness of the Simultaneous Double Pairing (SDP) problem. 
         [0000]    SSTC.Setup(λ, n): given the desired dimension n∈          of committed vectors, choose bilinear groups (         ,            T ) of prime order p&gt;2 λ . Then:
       1. Choose       
 
         [0000]    
       
         
           
             h 
              
             
               ← 
               R 
             
              
           
         
       
     
         [0000]    and α z , α r   
         [0000]    
       
         
           
             
               β 
               z 
             
              
             
               ← 
               R 
             
              
             
               
                 p 
               
               . 
             
           
         
       
       
         
           
             2. Define g z =h α     z   , g r =h α     r    and h z =h β     z   . 
             3. For each i∈{1, . . . , n}, pick χ i , γ i   
           
         
       
     
         [0000]    
       
         
           
             
               δ 
               i 
             
              
             
               ← 
               R 
             
              
             
               p 
             
           
         
       
     
         [0000]    and compute g i =g z   χi &#39;g r   γi , h i =h z   χi h δi .
       4. Choose a random vector       
 
         [0000]    
       
         
           
             
               w 
               _ 
             
             = 
             
               
                 ( 
                 
                   
                     w 
                     0 
                   
                   , 
                   … 
                    
                   
                       
                   
                   , 
                   
                     w 
                     L 
                   
                 
                 ) 
               
                
               
                 ← 
                 R 
               
                
               
                 
                   L 
                   + 
                   1 
                 
               
             
           
         
       
     
         [0000]    that defines a hash function          : {0,1} L →          which maps τ=τ[1] . . . τ[L]∈{0,1} L  to          (τ)=w 0 ·Π k=1   L w k   τ[k] .
 
The public key consists of
 
         [0000]        pk =( g   z   ,g   r   ,h   z   ,h,{g   i   ,h   i } i=1   n   ,  w   )∈           2n+4 ×           L+1  
 
         [0000]    while the trapdoor is tk=(h z   α     r   ,{χ i ,γ i ,δ i } i=1   n ).
 
SSTC.Com(pk, tag, (M 1 , . . . , M n )): to commit to a vector (M 1 , . . . , M n )∈           n , choose z, r, u,
 
         [0000]    
       
         
           
             v 
              
             
               ← 
               R 
             
              
             
                
               
                   
               
                
               and 
                
               
                   
               
                
               compute 
             
           
         
       
       
         
           
             
               
                 c 
                 1 
               
               = 
               
                 
                   e 
                    
                   
                     ( 
                     
                       
                         g 
                         z 
                       
                       , 
                       z 
                     
                     ) 
                   
                 
                 · 
                 
                   e 
                    
                   
                     ( 
                     
                       
                         g 
                         r 
                       
                       , 
                       r 
                     
                     ) 
                   
                 
                 · 
                 
                   
                     ∏ 
                     
                       i 
                       = 
                       1 
                     
                     n 
                   
                    
                   
                     e 
                      
                     
                       ( 
                       
                         
                           g 
                           i 
                         
                         , 
                         
                           M 
                           i 
                         
                       
                       ) 
                     
                   
                 
               
             
             , 
             
               
 
             
              
             
               
                 c 
                 2 
               
               = 
               
                 
                   
                     e 
                      
                     
                       ( 
                       
                         
                           h 
                           z 
                         
                         , 
                         z 
                       
                       ) 
                     
                   
                   · 
                   
                     e 
                      
                     
                       ( 
                       
                         h 
                         , 
                         u 
                       
                       ) 
                     
                   
                   · 
                   
                     e 
                      
                     
                       ( 
                       
                         
                            
                           
                             ( 
                             tag 
                             ) 
                           
                         
                         , 
                         v 
                       
                       ) 
                     
                   
                   · 
                   
                     
                       ∏ 
                       
                         i 
                         = 
                         1 
                       
                       n 
                     
                      
                     
                       
                         
                           e 
                            
                           
                             ( 
                             
                               
                                 h 
                                 i 
                               
                               , 
                               
                                 M 
                                 i 
                               
                             
                             ) 
                           
                         
                         . 
                         
                           
 
                         
                          
                         Then 
                       
                        
                       
                           
                       
                        
                       return 
                        
                       
                           
                       
                        
                       com 
                     
                   
                 
                 = 
                 
                   
                     
                       ( 
                       
                         
                           c 
                           1 
                         
                         , 
                         
                           c 
                           2 
                         
                       
                       ) 
                     
                     ∈ 
                     
                       
                         T 
                         2 
                       
                        
                       
                           
                       
                        
                       and 
                        
                       
                           
                       
                        
                       dec 
                     
                   
                   = 
                   
                     
                       ( 
                       
                         z 
                         , 
                         r 
                         , 
                         u 
                         , 
                         v 
                       
                       ) 
                     
                     ∈ 
                     
                       
                         4 
                       
                       . 
                     
                   
                 
               
             
           
         
       
     
         [0000]    SSTC.FakeCom(pk, tk, tag): choose {circumflex over (M)} 1 , . . . , 
         [0000]    
       
         
           
             
               
                 M 
                 ^ 
               
               n 
             
              
             
               ← 
               R 
             
              
           
         
       
     
         [0000]    and z, r, u, 
         [0000]    
       
         
           
             v 
              
             
               ← 
               R 
             
              
           
         
       
     
         [0000]    and compute 
         [0000]    
       
         
           
             
               
                 c 
                 1 
               
               = 
               
                 
                   e 
                    
                   
                     ( 
                     
                       
                         g 
                         z 
                       
                       , 
                       z 
                     
                     ) 
                   
                 
                 · 
                 
                   e 
                    
                   
                     ( 
                     
                       
                         g 
                         
                           r 
                            
                           
                               
                           
                         
                       
                       , 
                       r 
                     
                     ) 
                   
                 
                 · 
                 
                   
                     ∏ 
                     
                       i 
                       = 
                       1 
                     
                     n 
                   
                    
                   
                     e 
                      
                     
                       ( 
                       
                         
                           g 
                           i 
                         
                         , 
                         
                           
                             M 
                             ^ 
                           
                           i 
                         
                       
                       ) 
                     
                   
                 
               
             
             , 
             
               
 
             
              
             
               
                 c 
                 2 
               
               = 
               
                 
                   
                     e 
                      
                     
                       ( 
                       
                         
                           h 
                           z 
                         
                         , 
                         z 
                       
                       ) 
                     
                   
                   · 
                   
                     e 
                      
                     
                       ( 
                       
                         h 
                         , 
                         u 
                       
                       ) 
                     
                   
                   · 
                   
                     e 
                      
                     
                       ( 
                       
                         
                            
                           
                             ( 
                             tag 
                             ) 
                           
                         
                         , 
                         v 
                       
                       ) 
                     
                   
                   · 
                   
                     
                       ∏ 
                       
                         i 
                         = 
                         1 
                       
                       n 
                     
                      
                     
                       
                         
                           e 
                            
                           
                             ( 
                             
                               
                                 h 
                                 i 
                               
                               , 
                               
                                 
                                   M 
                                   ^ 
                                 
                                 i 
                               
                             
                             ) 
                           
                         
                         . 
                         
                           
 
                         
                          
                         Then 
                       
                        
                       
                           
                       
                        
                       return 
                        
                       
                           
                       
                        
                       com 
                     
                   
                 
                 = 
                 
                   
                     ( 
                     
                       
                         c 
                         1 
                       
                       , 
                       
                         c 
                         2 
                       
                     
                     ) 
                   
                   ∈ 
                   
                     
                       T 
                       2 
                     
                      
                     
                         
                     
                      
                     and 
                   
                 
               
             
           
         
       
       
         
           
             aux 
             = 
             
               
                 ( 
                 
                   
                     ( 
                     
                       
                         
                           M 
                           ^ 
                         
                         1 
                       
                       , 
                       … 
                        
                       
                           
                       
                       , 
                       
                         
                           M 
                           ^ 
                         
                         n 
                       
                     
                     ) 
                   
                   , 
                   z 
                   , 
                   r 
                   , 
                   u 
                   , 
                   v 
                 
                 ) 
               
               . 
             
           
         
       
     
         [0000]    SSTC.FakeOpen (aux, tk, tag,          , (M 1 , . . . , M n )): generate a linearly homomorphic signature (z′, r′, u′, v′) on the vector (M 1 /{circumflex over (M)} 1 , . . . , M n /{circumflex over (M)} n ) using the underlying linearly homomorphic SPS described hereinafter. Then compute ({tilde over (z)}, {tilde over (r)}, ũ, {tilde over (v)})=(z·z′, r·r′, u·u′, v·v′). Return dec=({tilde over (z)}, {tilde over (r)}, ũ, {tilde over (v)}), which satisfies 
         [0000]    
       
         
           
             
               
                 c 
                 1 
               
               = 
               
                 
                   e 
                    
                   
                     ( 
                     
                       
                         g 
                         z 
                       
                       , 
                       
                         z 
                         ~ 
                       
                     
                     ) 
                   
                 
                 · 
                 
                   e 
                    
                   
                     ( 
                     
                       
                         g 
                         r 
                       
                       , 
                       
                         r 
                         ~ 
                       
                     
                     ) 
                   
                 
                 · 
                 
                   
                     ∏ 
                     
                       i 
                       = 
                       1 
                     
                     n 
                   
                    
                   
                     e 
                      
                     
                       ( 
                       
                         
                           g 
                           i 
                         
                         , 
                         
                           M 
                           i 
                         
                       
                       ) 
                     
                   
                 
               
             
             , 
             
               
 
             
              
             
               
                 c 
                 2 
               
               = 
               
                 
                   e 
                    
                   
                     ( 
                     
                       
                         h 
                         z 
                       
                       , 
                       
                         z 
                         ~ 
                       
                     
                     ) 
                   
                 
                 · 
                 
                   e 
                    
                   
                     ( 
                     
                       h 
                       , 
                       
                         u 
                         ~ 
                       
                     
                     ) 
                   
                 
                 · 
                 
                   e 
                    
                   
                     ( 
                     
                       
                          
                         
                           ( 
                           tag 
                           ) 
                         
                       
                       , 
                       
                         v 
                         ~ 
                       
                     
                     ) 
                   
                 
                 · 
                 
                   
                     ∏ 
                     
                       i 
                       = 
                       1 
                     
                     n 
                   
                    
                   
                     
                       e 
                        
                       
                         ( 
                         
                           
                             h 
                             i 
                           
                           , 
                           
                             M 
                             i 
                           
                         
                         ) 
                       
                     
                     . 
                   
                 
               
             
           
         
       
     
         [0000]    SSTC.Verify(pk, tag, (M 1 , . . . , M n ), com, dec): parses the commitment com as (c 1 , c 2 )∈           T   2  and the opening dec as (z,r,u,v)∈           4 . If these do not parse properly, it returns 0. Otherwise, it returns 1 if (z, r, u, v) 
         [0000]    
       
         
           
             
               
                 c 
                 1 
               
               = 
               
                 
                   e 
                    
                   
                     ( 
                     
                       
                         g 
                         z 
                       
                       , 
                       z 
                     
                     ) 
                   
                 
                 · 
                 
                   e 
                    
                   
                     ( 
                     
                       
                         g 
                         r 
                       
                       , 
                       r 
                     
                     ) 
                   
                 
                 · 
                 
                   
                     ∏ 
                     
                       
                           
                       
                        
                       
                         i 
                         = 
                         1 
                       
                     
                     n 
                   
                    
                   
                     e 
                      
                     
                       ( 
                       
                         
                           g 
                           i 
                         
                         , 
                         
                           M 
                           i 
                         
                       
                       ) 
                     
                   
                 
               
             
             , 
             
               
 
             
              
             
               
                 c 
                 2 
               
               = 
               
                 
                   e 
                    
                   
                     ( 
                     
                       
                         h 
                         z 
                       
                       , 
                       z 
                     
                     ) 
                   
                 
                 · 
                 
                   e 
                    
                   
                     ( 
                     
                       h 
                       , 
                       u 
                     
                     ) 
                   
                 
                 · 
                 
                   e 
                    
                   
                     ( 
                     
                       
                          
                         
                           ( 
                           tag 
                           ) 
                         
                       
                       , 
                       v 
                     
                     ) 
                   
                 
                 · 
                 
                   
                     ∏ 
                     
                       i 
                       = 
                       1 
                     
                     n 
                   
                    
                   
                     
                       e 
                        
                       
                         ( 
                         
                           
                             h 
                             i 
                           
                           , 
                           
                             M 
                             i 
                           
                         
                         ) 
                       
                     
                     . 
                   
                 
               
             
           
         
       
     
         [0000]    and 0 otherwise. 
         [0074]    The skilled person will appreciate that the schemes of the present invention, which works on vectors, also works on scalars (for which the dimension n equals 1). Thus, the dimension n can be any positive integer: 1, 2, 3 . . . . 
         [0075]    It will be appreciated that the schemes of the present invention can provide a commitment scheme with the desired features. 
         [0076]    Each feature disclosed in the description and (where appropriate) the claims and drawings may be provided independently or in any appropriate combination. Features described as being implemented in hardware may also be implemented in software, and vice versa. Reference numerals appearing in the claims are by way of illustration only and shall have no limiting effect on the scope of the claims.