Abstract:
The method for generic-point parallel elliptic curve scalar multiplication replaces the pre-computation overhead of conventional elliptic curve scalar multiplication by post-computations that can be parallelized. This greatly increases the speed and efficiency of scalar multiplication performed in elliptic curve cryptography. According to the method, when scalar multiplication is required, the scalar integer is partitioned into a plurality of partitions, and calculations in each partition are performed simultaneously or in parallel on separate processors using conventional binary protocols. The bit size of each partition is adjusted to balance the load between the processors, i.e., so that each processor performs substantially the same number of point operations. The resulting calculations from each partition are accumulated or summed to produce the point that is the product of the scalar multiplication.

Description:
BACKGROUND OF THE INVENTION 
       [0001]    1. Field of the Invention 
         [0002]    The present invention relates to cryptography systems and methods, and particularly to a method for generic-point parallel elliptic curve scalar multiplication that replaces the pre-computation overhead found in conventional elliptic curve scalar multiplication with post-computations that can be parallelized. 
         [0003]    2. Description of the Related Art 
         [0004]    Elliptic Curve Cryptosystems (ECC), originally proposed by Niel Koblitz and Victor Miller in 1985, offer a serious alternative to earlier public key cryptosystems, such as Rivest-Shamir-Adleman (RSA) and ElGamal, with much shorter key size. To date, no significant breakthroughs have been made in determining weaknesses in the ECC algorithm, which is based on the discrete logarithm problem over points on an elliptic curve. The fact that the problem appears so difficult to crack means that key sizes can be reduced considerably, even exponentially. This has caused ECC to become a serious challenger to RSA and ElGamal cryptosystems. Because of these advantages, ECC have been recently incorporated in many standards. ECC have gained popularity for cryptographic applications because of the short key, and are considered to be particularly suitable for implementation on smart cards or mobile devices. 
         [0005]    An elliptic curve over a finite field GF(q) defines a set of points (x, y) that satisfy the elliptic curve equation together with the point O, known as the “point at infinity”. The “point at infinity” does not satisfy the elliptic curve equation. The coordinates x and y of the elliptic curve points are elements of the field GF(q), where q=p m  and p is prime. 
         [0006]    Equations (1) and (2) define the elliptic curve equations for the fields GF(p) and GF(2 m ), respectively: 
         [0000]        y   2   =x   3   +ax+b   (1)
 
         [0000]    where a, bεGF(p) and 4a+27b 2 ≠0(mod p); and 
         [0000]        y   2   +xy=x   3   +ax   2   +b   (2)
 
         [0000]    where a,bεGF(2 m ) and b≠0. 
         [0007]    The set of discrete points on an elliptic curve form an abelian group (commutative group), whose group operation is known as point addition. Bounds for the number of discrete points n on an elliptic curve over a finite field GF(q) are defined by Hasse&#39;s theorem, given in Equation (3), where the symbol n represents the number of points on the elliptic curve and where q=p m  represents the number of elements in the underlying finite field: 
         [0000]        q+ 1−2√ {square root over (q)}≦n≦q+ 1+2√{square root over (q)}  (3)
 
         [0000]    Elliptic curve “point addition” is defined according to the “chord-tangent process”. Point addition over GF(p) is described as follows: Let P and Q be two distinct points on an elliptic curve E defined over the real numbers with Q≠−P (Q is not the additive inverse of P). The addition of P and Q is the point R=P+Q, where R is the additive inverse of S, and S is a third point on the elliptic curve intercepted by the straight line through points P and Q. For the curve under consideration, R is the reflection of the point S with respect to the x-axis, that is, if R is the point (x, y), then S is the point (x,−y). 
         [0008]    When P=Q and P≠−P, the addition of P and Q is the point R, where R=2P and R is the additive inverse of S, and S is the third point on the elliptic curve intercepted by the straight line tangent to the curve at point P. This operation is referred to as “point doubling”. 
         [0009]    The “point at infinity”, O, is the additive identity of the group. The most relevant operations involving O are the following: the addition of a point P and O is equal to P (i.e., P+O=P); and the addition of a point P and its additive inverse, −P, is equal to O (i.e., P−P=O). If P is a point on the curve, then −P is also a point on the curve. 
         [0010]    The point operation used by elliptic curve cryptosystems is referred to as point multiplication. This operation is also referred to as scalar point multiplication. The point multiplication operation is denoted as kP, where k is an integer number and P is point on the elliptic curve. The operation kP represents the addition of k copies of point P, as shown in Equation (4) below: 
         [0000]    
       
         
           
             
               
                 
                   kP 
                   = 
                   
                     
                       
                         P 
                         + 
                         P 
                         + 
                         … 
                         + 
                         P 
                       
                       
                          
                         
                           k 
                            
                           
                               
                           
                            
                           times 
                            
                           
                               
                           
                            
                           P 
                         
                       
                     
                     . 
                   
                 
               
               
                 
                   ( 
                   4 
                   ) 
                 
               
             
           
         
       
     
         [0011]    Elliptic curve cryptosystems are built over cyclic groups. Each group contains a finite number of points, n, that can be represented as scalar multiples of a generator point: iP for i=0, 1, . . . , n−1, where P is a generator of the group. The order of point P is n, which implies that nP=O and iP≠O for 1&lt;i&lt;n−1. The order of each point on the group must divide n. Consequently, a point multiplication kQ for k&gt;n can be computed as (k mod n)Q. 
         [0012]    Scalar multiplication is the basic operation for ECC. Scalar multiplication in the group of points of an elliptic curve is the analogue of exponentiation in the multiplicative group of integers modulo a fixed integer m. Computing kP can be performed using a straightforward double-and-add approach based on the binary representation of k=k l-1 , . . . , k 0  where k l-1  is the most significant bit of k. Other scalar multiplication methods have been proposed in the literature. 
         [0013]    One of the simplest scalar multiplication algorithms is the double-and-add point multiplication algorithm, which is the so-called binary algorithm. Algorithm 1 and 2 show the most-to-least and the least-to-most versions of the double-and-add scalar multiplication algorithms, respectively. The algorithms inspect the multiplier k. For each inspected bit, the algorithms perform a point double, and if the inspected bit is one, the algorithms also perform a point add: 
         [0000]    
       
         
               
               
             
           
               
                   
               
             
             
               
                   
                 Algorithm 1: Double-and-Add (most-to-least) 
               
               
                   
               
               
                   
                 Inputs: P,k 
               
               
                   
                 Output: kP 
               
               
                   
                 Initialization: 
               
               
                   
                  Q = P 
               
               
                   
                 Scalar Multiplication: 
               
               
                   
                  for i = l −2 down to 0 do 
               
               
                   
                   Q = 2Q 
               
               
                   
                   if k i  = 1 then Q = Q + P 
               
               
                   
                  end for 
               
               
                   
                 return(Q) 
               
               
                   
               
               
                   
                 Algorithm 2: Double-and-Add (least-to-most) 
               
               
                   
               
               
                   
                 Inputs: P,k 
               
               
                   
                 Output: kP 
               
               
                   
                 Initialization: 
               
               
                   
                  Q = O, R = P 
               
               
                   
                 Scalar Multiplication: 
               
               
                   
                  for i = 0 to l −1 do 
               
               
                   
                   if k i  = 1 then Q = Q + R 
               
               
                   
                   R = 2R 
               
               
                   
                  end for 
               
               
                   
                 return(Q) 
               
               
                   
               
             
          
         
       
     
         [0014]    The double-and-add scalar multiplication algorithms require, on average, l point doubles and l/2 point additions, where l≠|log 2 k|. These algorithms also require storing two points, P and Q. 
         [0015]    As noted above, kP can be computed using a straightforward binary method based on the binary expression of multiplier k. A conventional prior art scalar multiplication method for elliptic cryptosystems is shown in the U.S. Patent Application Publication US 2009/0214023 A1, which is herein incorporated by reference in its entirety. 
         [0016]    It is important to note that sequential scalar multiplication methods are too slow for high-performance end servers due to the demand resulting from increasing numbers of customers. Efficient scalar multiplication methods are now crucial for such servers. Scalar multiplication methods that can be parallelized are now being used to provide high-speed implementations. 
         [0017]    Pre-computations have been used to speed up scalar multiplications, but they require sequential steps that cannot be parallelized, and they are primarily advantageous when the elliptic curve point is fixed. However, during secure communication sessions that use public keys, the elliptic curve point changes, as it depends on the public key of the communicating entity; i.e., it is session dependent. This is also the case when digital signatures are used. 
         [0018]    Thus, the computation of scalar multiplications is generally performed with a generic elliptic curve point. Because of the likelihood that the elliptic curve point will be different for each session, the overhead resulting from the necessary pre-computations must be considered when estimating the total computational time required. Thus, a method for generic-point parallel elliptic curve scalar multiplication solving the aforementioned problems is desired. 
       SUMMARY OF THE INVENTION 
       [0019]    The method for generic-point parallel elliptic curve scalar multiplication replaces the pre-computation overhead of conventional elliptic curve scalar multiplication by post-computations, which can be parallelized. This greatly increases the speed and efficiency of the scalar multiplication. The method is particularly useful for high-performance end servers that service demands from an increasing numbers of customers, since it speeds up scalar multiplications in any cryptographic system that utilizes elliptic curve cryptography. 
         [0020]    According to the method, when scalar multiplication is required, the scalar integer is partitioned into a plurality of partitions, and calculations in each partition are performed simultaneously or in parallel on separate processors using conventional binary protocols. The bit size of each partition is adjusted to balance the load between the processors, i.e., so that each processor performs substantially the same number of point operations. The resulting calculations from each partition are accumulated or summed to produce the point that is the product of the scalar multiplication. 
         [0021]    The method is of general application, and may be used wherever it is necessary to perform scalar multiplication, including public-key exchange, digital signatures, message encryption and decryption, etc. 
         [0022]    These and other features of the present invention will become readily apparent upon further review of the following specification and drawings. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0023]      FIG. 1  is a block diagram illustrating system components of a system for implementing the method for generic-point parallel elliptic curve scalar multiplication according to the present invention. 
           [0024]      FIG. 2  diagrammatically illustrates dataflow of the method for generic-point parallel elliptic curve scalar multiplication for an exemplary case with m=16, u=4, and r=s/2. 
       
    
    
       [0025]    Similar reference characters denote corresponding features consistently throughout the attached drawings. 
       DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS 
       [0026]    The present invention is a method for generic-point parallel elliptic curve scalar multiplication. The method for generic-point parallel elliptic curve scalar multiplication replaces sequential pre-computations for conventional elliptic curve scalar multiplication with post-computations that may be performed in parallel in order to speed up computations, particularly for high-performance end servers that face demand from an increasing number of customers. The scalar integer k is partitioned into u partitions that can be processed in parallel by u processors using the binary method. Post-computations are then distributed on u−1 processors to be performed in parallel. The points that result from processing these key partitions with the post-computations are finally assimilated or summed (with adjustment to the appropriate power of base 2 according to the columnar position of the partition in the full binary representation of the scalar integer) to produce scalar multiplication kP, which is the product of the scalar k and the point P on the elliptic curve. Letting k=(k m−1 , . . . , k 0 ) be the binary representation of the scalar k where k m−1  is the most significant bit of k, then, after partitioning k into u partitions, the scalar k can be written as: 
         [0000]        k =( k   (u-1)   ∥k   (u-2)   ∥ . . . ∥k   (0) )  (5)
 
         [0027]    Scalar multiplication product kP can then be computed as: 
         [0000]    
       
         
           
             
               
                 
                   
                     kP 
                     = 
                     
                       
                         ∑ 
                         
                           0 
                           ≤ 
                           i 
                           ≤ 
                           u 
                         
                       
                        
                       
                         t 
                         i 
                       
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   6 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where t i  is defined as: 
         [0000]    
       
         
           
             
               
                 
                   
                     t 
                     i 
                   
                   = 
                   
                     
                       2 
                        
                       
                         ( 
                         
                             
                         
                          
                         
                           
                             … 
                              
                             
                                 
                             
                              
                             2 
                              
                             
                               ( 
                               
                                 
                                   2 
                                    
                                   
                                     
                                       k 
                                       
                                         iv 
                                         + 
                                         v 
                                         - 
                                         1 
                                       
                                     
                                      
                                     
                                       ( 
                                       
                                         
                                           2 
                                           iv 
                                         
                                          
                                         P 
                                       
                                       ) 
                                     
                                   
                                 
                                 + 
                                 
                                   
                                     k 
                                     
                                       iv 
                                       + 
                                       v 
                                       - 
                                       2 
                                     
                                   
                                    
                                   
                                     ( 
                                     
                                       
                                         2 
                                         iv 
                                       
                                        
                                       P 
                                     
                                     ) 
                                   
                                 
                               
                               ) 
                             
                           
                           + 
                           … 
                           + 
                           
                             
                               k 
                               
                                 iv 
                                 + 
                                 1 
                               
                             
                              
                             
                               ( 
                               
                                 
                                   2 
                                   iv 
                                 
                                  
                                 P 
                               
                               ) 
                             
                           
                         
                         ) 
                       
                     
                     + 
                     
                       
                         
                           k 
                           
                             iv 
                             + 
                             0 
                           
                         
                          
                         
                           ( 
                           
                             
                               2 
                               iv 
                             
                              
                             P 
                           
                           ) 
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   7 
                   ) 
                 
               
             
           
         
       
     
         [0028]    It is important to note that Eq. (7) can be rewritten as: 
         [0000]    
       
         
           
             
               
                 
                   
                     t 
                     i 
                   
                   = 
                   
                     
                       
                         ( 
                         
                           2 
                           iv 
                         
                         ) 
                       
                        
                       
                         [ 
                         
                           
                             2 
                              
                             
                               ( 
                               
                                   
                               
                                
                               
                                 
                                   … 
                                    
                                   
                                       
                                   
                                    
                                   2 
                                    
                                   
                                     ( 
                                     
                                       
                                         2 
                                          
                                         
                                           k 
                                           
                                             iv 
                                             + 
                                             v 
                                             - 
                                             1 
                                           
                                         
                                          
                                         P 
                                       
                                       + 
                                       
                                         
                                           k 
                                           
                                             iv 
                                             + 
                                             v 
                                             - 
                                             2 
                                           
                                         
                                          
                                         P 
                                       
                                     
                                     ) 
                                   
                                 
                                 + 
                                 … 
                                 + 
                                 
                                   
                                     k 
                                     
                                       iv 
                                       + 
                                       1 
                                     
                                   
                                    
                                   P 
                                 
                               
                               ) 
                             
                           
                           + 
                           
                             
                               k 
                               
                                 iv 
                                 + 
                                 0 
                               
                             
                              
                             P 
                           
                         
                         ] 
                       
                     
                     . 
                   
                 
               
               
                 
                   ( 
                   8 
                   ) 
                 
               
             
           
         
       
     
         [0000]    Eq. (8) implies that the required pre-computations of Eq. (7) can be replaced by post-computations, which are point doublings. Each partition requires iv point doublings to produce the correct partial product. To balance the number of point operations, we need to balance the total number of field multiplications, as field multiplication is the dominant type of operation in elliptic curve point operations in projective coordinates. This implies that the scalar k should be partitioned into u partitions of different sizes, as shown below in Eq. (9): 
         [0000]        m=m   (u-1)   +m   (u-2)   + . . . +m   (1)   +m   (0)   (9)
 
         [0000]    where m represents the number of bits in the scalar k in binary, and m (u-1) , m (u-2) , . . . , m (1) , m (0)  represent the number of bits in each partition. 
         [0029]    Accordingly, the number of bits in partition t (i)  must be greater than the number of those in t (i+1)  and fewer than the number of those in t (i−1) , as can be seen from Eq. (10) below: 
         [0000]        m   (u-1)   &lt;m   (u-2)   &lt; . . . &lt;&lt;m   (1)   &lt;m   (0) .  (10)
 
         [0030]    Assuming that the double and add point operations require r and s field multiplications, respectively, then we can let the total number of field multiplications in partition k (i)  equal M (i) . Because partition k (0)  is the only one to require no post-computations, a balanced number of point operations can be reached by solving Eqs. (9) and (10) together with the following equations (11-13): 
         [0000]    
       
         
           
             
               
                 
                   
                     M 
                     
                       ( 
                       0 
                       ) 
                     
                   
                   = 
                   
                     
                       
                         m 
                         
                           ( 
                           0 
                           ) 
                         
                       
                        
                       
                         ( 
                         r 
                         ) 
                       
                     
                     + 
                     
                       
                         
                           m 
                           
                             ( 
                             0 
                             ) 
                           
                         
                         2 
                       
                        
                       
                         ( 
                         s 
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   11 
                   ) 
                 
               
             
             
               
                 
                   
                     M 
                     
                       ( 
                       i 
                       ) 
                     
                   
                   = 
                   
                     
                       
                         m 
                         
                           ( 
                           i 
                           ) 
                         
                       
                        
                       
                         ( 
                         r 
                         ) 
                       
                     
                     + 
                     
                       
                         
                           m 
                           
                             ( 
                             i 
                             ) 
                           
                         
                         2 
                       
                        
                       
                         ( 
                         s 
                         ) 
                       
                     
                     + 
                     
                       
                         ( 
                         r 
                         ) 
                       
                        
                       
                         
                           ∑ 
                           
                             0 
                             ≤ 
                             j 
                             &lt; 
                             i 
                           
                         
                          
                         
                           m 
                           j 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   12 
                   ) 
                 
               
             
             
               
                 
                   
                     M 
                     
                       ( 
                       0 
                       ) 
                     
                   
                   = 
                   
                     
                       M 
                       
                         ( 
                         1 
                         ) 
                       
                     
                     = 
                     
                       … 
                       = 
                       
                         
                           M 
                           
                             ( 
                             
                               u 
                               - 
                               1 
                             
                             ) 
                           
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   13 
                   ) 
                 
               
             
           
         
       
     
         [0031]    The computation of kP in parallel without pre-computations can be performed efficiently using the following algorithm: 
         [0000]    
       
         
               
             
               
               
               
             
           
               
                   
               
               
                 Algorithm 3: Generic-Point Parallel Scalar Multiplication 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                   
                   
                 1) Inputs: P,k 
               
               
                   
                   
                 2) By padding k with zeros if necessary, solve Eqs. (9)- 
               
               
                   
                   
                 (13) together, and write k = (k (u−1)  ∥ k (u−2)  ∥ ... ∥ k (0) ), 
               
               
                   
                   
                 where k (i)  is a partition of length m (i)  bits 
               
               
                   
                   
                 3) Initialization: 
               
               
                   
                   
                  Q ← P, R ← O 
               
               
                   
                   
                 4) Parallel Scalar Multiplication: 
               
               
                   
                   
                  4.1) For i = 0 to u−1 do in parallel 
               
               
                   
                   
                   4.1.1) Q ← Binary method (k (i) ,P) 
               
               
                   
                   
                   4.1.2) If i &gt; 0 , then 
               
               
                   
                   
                     
             4.1      .2      .1     )                   for                 c     =     0                   to   (       (       ∑     0   ≤   j   &lt;   i            m   j       )     -   1     )           
 
               
               
                   
                   
                      4.1.2.1.1) Q ← 2Q 
               
               
                   
                   
                   4.1.3) R ← R + Q 
               
               
                   
                   
                 5) Output R 
               
               
                   
               
             
          
         
       
     
         [0032]    The pseudo code of the present method is given above in Algorithm 3. The partitioning of the multiplier k into u partitions with different sizes depends on solving equations (9)-(13) together to provide a balanced number of point operations for these different partitions. The partitioning step is performed at step 2. Parallel scalar multiplications start at step 4. Each partition is processed independently in parallel by an individual processor. Only partition k (0)  does not require any post-computations. The remaining partitions need post-computations after executing the binary algorithm (step 4.1.1). Finally, the resulting points of each partition are accumulated in the accumulation point R (step 4.1.3), which requires u−1 extra point additions. 
         [0033]      FIG. 2  illustrates an exemplary data path of the present method with m=16, u=4, and r=s/2. Each key partition k (i)  in  FIG. 2  has a different size and is processed in an individual column by an individual processor. The resulting points of processing these key partitions are assimilated at the end to produce kP. 
         [0034]    In the example of  FIG. 2 , we let k=(1000 0101 1100 0011) 2 =(34243) 10 , with m=16, u=4, and r=s/2. The sizes of the key partitions are m 0 =9, m 1 =4, m 2 =2, and m 3 =1. The key partitions are k (0) =111000011, k (1) =0010, k (2) =00, and k (3) =1. The scalar multiplication of these partitions is then computed in parallel according to the following: 
         [0000]    
       
         
           
             
               
                 t 
                 0 
               
               = 
               
                 
                   
                     2 
                      
                     
                       ( 
                       
                         
                           2 
                            
                           
                             ( 
                             
                               
                                 2 
                                  
                                 
                                   ( 
                                   
                                     
                                       2 
                                        
                                       
                                         ( 
                                         
                                           
                                             2 
                                              
                                             
                                               ( 
                                               
                                                 
                                                   2 
                                                    
                                                   
                                                     ( 
                                                     
                                                       
                                                         2 
                                                          
                                                         
                                                           ( 
                                                           
                                                             
                                                             2 
                                                              
                                                             
                                                             ( 
                                                             1 
                                                             ) 
                                                             
                                                              
                                                             P 
                                                             
                                                             + 
                                                             
                                                             
                                                             ( 
                                                             1 
                                                             ) 
                                                             
                                                              
                                                             P 
                                                             
                                                           
                                                           ) 
                                                         
                                                       
                                                       + 
                                                       
                                                         
                                                           ( 
                                                           1 
                                                           ) 
                                                         
                                                          
                                                         P 
                                                       
                                                     
                                                     ) 
                                                   
                                                 
                                                 + 
                                                 
                                                   
                                                     ( 
                                                     0 
                                                     ) 
                                                   
                                                    
                                                   P 
                                                 
                                               
                                               ) 
                                             
                                           
                                           + 
                                           
                                             
                                               ( 
                                               0 
                                               ) 
                                             
                                              
                                             P 
                                           
                                         
                                         ) 
                                       
                                     
                                     + 
                                     
                                       
                                         ( 
                                         0 
                                         ) 
                                       
                                        
                                       P 
                                     
                                   
                                   ) 
                                 
                               
                               + 
                               
                                 
                                   ( 
                                   0 
                                   ) 
                                 
                                  
                                 P 
                               
                             
                             ) 
                           
                         
                         + 
                         
                           
                             ( 
                             1 
                             ) 
                           
                            
                           
                               
                           
                            
                           P 
                         
                       
                       ) 
                     
                   
                   + 
                   
                     
                       ( 
                       1 
                       ) 
                     
                      
                     P 
                   
                 
                 = 
                 
                   451 
                    
                   P 
                 
               
             
             ; 
           
         
       
       
         
           
             
                 
             
              
             
               
                 
                   t 
                   1 
                 
                 = 
                 
                   
                     
                       ( 
                       
                         2 
                         9 
                       
                       ) 
                     
                      
                     
                       [ 
                       
                         
                           2 
                            
                           
                             ( 
                             
                               
                                 2 
                                  
                                 
                                   ( 
                                   
                                     
                                       2 
                                        
                                       
                                         ( 
                                         0 
                                         ) 
                                       
                                        
                                       P 
                                     
                                     + 
                                     
                                       
                                         ( 
                                         0 
                                         ) 
                                       
                                        
                                       P 
                                     
                                   
                                   ) 
                                 
                               
                               + 
                               
                                 
                                   ( 
                                   1 
                                   ) 
                                 
                                  
                                 P 
                               
                             
                             ) 
                           
                         
                         + 
                         
                           
                             ( 
                             0 
                             ) 
                           
                            
                           P 
                         
                       
                       ] 
                     
                   
                   = 
                   
                     1024 
                      
                     P 
                   
                 
               
               ; 
             
           
         
       
       
         
           
             
                 
             
              
             
               
                 
                   t 
                   2 
                 
                 = 
                 
                   
                     
                       ( 
                       
                         2 
                         13 
                       
                       ) 
                     
                      
                     
                       [ 
                       
                         
                           2 
                            
                           
                             ( 
                             0 
                             ) 
                           
                            
                           P 
                         
                         + 
                         
                           
                             ( 
                             0 
                             ) 
                           
                            
                           P 
                         
                       
                       ] 
                     
                   
                   = 
                   0 
                 
               
               ; 
             
           
         
       
       
         
           
             
                 
             
              
             
               
                 and 
                  
                 
                   
 
                 
                  
                 
                     
                 
                  
                 
                   t 
                   3 
                 
               
               = 
               
                 
                   
                     ( 
                     
                       2 
                       15 
                     
                     ) 
                   
                    
                   
                     [ 
                     
                       
                         ( 
                         1 
                         ) 
                       
                        
                       P 
                     
                     ] 
                   
                 
                 = 
                 
                   32768 
                    
                   
                     P 
                     . 
                   
                 
               
             
           
         
       
     
         [0035]    Finally, kP is computed as: 
         [0000]        kP=t   0   +t   1   +t   2   +t   3 =451 P+ 1024 P+ 0+32768 P= 34243 P.    
         [0036]    The time required to perform the scalar multiplication for partition k (0) , which requires no post-computations, is the same as that required for the remaining partitions. Thus, the time complexity of the proposed method is equal to m 0  point doublings and (m 0 /2+u−1) point additions. However, the accumulation process can be further enhanced if more than one processor is involved in the accumulation process, which reduces the accumulation time to log 2 (u) point additions. Non-Adjacent Form (NAF) encoding also reduces the average point additions of the binary method to m/3. Thus, when these enhancements are used, the time complexity becomes equal to m 0  point doublings plus (m (0) /3+log 2  u) point additions. 
         [0037]    The space complexity of the present method, in terms of number of stored points, depends on the number of partitions u that will be processed by the u processors using the binary method. Each processor requires storage of one point to perform scalar multiplications using the binary method. No pre-computations are required, and, accordingly, only the base point P will be also stored and shared between the parallel processors. Finally, the accumulation point will be required for the accumulation process at the end. Thus, the space complexity of the proposed method is equal to u+2 points. 
         [0038]    It should be understood that the calculations may be performed by any suitable computer system, such as that diagrammatically shown in  FIG. 1 . Data is entered into system  100  via any suitable type of user interface  116 , and may be stored in memory  112 , which may be any suitable type of computer readable and programmable memory. Calculations are performed by processor  114 , which may be any suitable type of computer processor and may be displayed to the user on display  118 , which may be any suitable type of computer display. 
         [0039]    Processor  114  may be associated with, or incorporated into, any suitable type of computing device, for example, a personal computer or a programmable logic controller. The display  118 , the processor  114 , the memory  112  and any associated computer readable recording media are in communication with one another by any suitable type of data bus, as is well known in the art. 
         [0040]    Examples of computer-readable recording media include a magnetic recording apparatus, an optical disk, a magneto-optical disk, and/or a semiconductor memory (for example, RAM, ROM, etc.). Examples of magnetic recording apparatus that may be used in addition to memory  112 , or in place of memory  112 , include a hard disk device (HDD), a flexible disk (FD), and a magnetic tape (MT). Examples of the optical disk include a DVD (Digital Versatile Disc), a DVD-RAM, a CD-ROM (Compact Disc-Read Only Memory), and a CD-R (Recordable)/RW. 
         [0041]    It will be understood that the multiple processors required for parallel processing may be microprocessors, digital signal processors, application specific integrated circuits, or other suitable processors, or may be soft processors depending upon the capability of the computer or other cryptographic device, and may be discrete processors or may be multiple processing units incorporated onto a single integrated circuit. The method may be performed on multiple computers linked through a network, or may be performed on any suitable cryptographic device. 
         [0042]    The method is of general application, and may be used wherever it is necessary to perform scalar multiplication, including public-key exchange, digital signatures, message encryption and decryption, etc. When used for public-key exchange, the method may further comprise keeping the scalar integer private and making the elliptic curve point and the scalar multiplication product public for establishing elliptic curve public-key agreement. When used for message encryption, the method may further comprise embedding a plaintext message onto a point on the elliptic curve to form a message point, and adding the message point to the scalar multiplication product in order to encrypt the plaintext message. 
         [0043]    It is to be understood that the present invention is not limited to the embodiments described above, but encompasses any and all embodiments within the scope of the following claims.  1 . A method for generic-point parallel elliptic curve scalar multiplication using a cryptographic device, comprising the steps of:
       partitioning a scalar integer, represented as a binary number, into a plurality of partitions;   adjusting the number of binary bits in each partition to distribute a number of point operations equally among the partitions by simultaneously solving the following set of equations:       
 
         [0000]    
       
         
           
             
               m 
               = 
               
                 
                   m 
                   
                     ( 
                     
                       u 
                       - 
                       1 
                     
                     ) 
                   
                 
                 + 
                 
                   m 
                   
                     ( 
                     
                       u 
                       - 
                       2 
                     
                     ) 
                   
                 
                 + 
                 … 
                 + 
                 
                   m 
                   
                     ( 
                     1 
                     ) 
                   
                 
                 + 
                 
                   m 
                   
                     ( 
                     0 
                     ) 
                   
                 
               
             
             , 
             
               
 
             
              
             where 
           
         
       
       
         
           
             
               
                 m 
                 
                   ( 
                   
                     u 
                     - 
                     1 
                   
                   ) 
                 
               
               &lt; 
               
                 m 
                 
                   ( 
                   
                     u 
                     - 
                     2 
                   
                   ) 
                 
               
               &lt; 
               … 
               &lt; 
               
                 m 
                 
                   ( 
                   1 
                   ) 
                 
               
               &lt; 
               
                 m 
                 
                   ( 
                   0 
                   ) 
                 
               
             
             ; 
           
         
       
       
         
           
             
               
                 M 
                 
                   ( 
                   0 
                   ) 
                 
               
               = 
               
                 
                   
                     m 
                     
                       ( 
                       0 
                       ) 
                     
                   
                    
                   
                     ( 
                     r 
                     ) 
                   
                 
                 + 
                 
                   
                     
                       m 
                       
                         ( 
                         0 
                         ) 
                       
                     
                     2 
                   
                    
                   
                     ( 
                     s 
                     ) 
                   
                 
               
             
             ; 
           
         
       
       
         
           
             
               
                 M 
                 
                   ( 
                   i 
                   ) 
                 
               
               = 
               
                 
                   
                     m 
                     
                       ( 
                       i 
                       ) 
                     
                   
                    
                   
                     ( 
                     r 
                     ) 
                   
                 
                 + 
                 
                   
                     
                       m 
                       
                         ( 
                         i 
                         ) 
                       
                     
                     2 
                   
                    
                   
                     ( 
                     s 
                     ) 
                   
                 
                 + 
                 
                   
                     ( 
                     r 
                     ) 
                   
                    
                   
                     
                       ∑ 
                       
                         0 
                         ≤ 
                         j 
                         &lt; 
                         i 
                       
                     
                      
                     
                       m 
                       j 
                     
                   
                 
               
             
             ; 
           
         
       
       
         
           and 
         
       
       
         
           
             
               
                 M 
                 
                   ( 
                   0 
                   ) 
                 
               
               = 
               
                 
                   M 
                   
                     ( 
                     1 
                     ) 
                   
                 
                 = 
                 
                   … 
                   = 
                   
                     M 
                     
                       ( 
                       
                         u 
                         - 
                         1 
                       
                       ) 
                     
                   
                 
               
             
             ; 
           
         
       
     
         [0000]    wherein m represents the number of bits in the binary representation of the scalar integer, m i  represents the number of bits in the i th partition, r represents the number of field multiplications of a point doubling operation, and s represents the number of field multiplications of a point addition operation;
       in each partition, computing a partial product of the partitioned scalar integer and a point on an elliptic curve, the partial products being computed simultaneously in parallel by a plurality of separate processors; and   accumulating the partial products from the plurality of partitions to obtain the scalar multiplication product of the scalar integer and the point on the elliptic curve.