Testing probable prime numbers for cryptographic applications

0001The present invention relates to cryptography, including such basic cryptographic components as prime number generation, key generation and pseudo-random number generation. The invention relates in particular to computer software cryptography methods and corresponding programmed hardware apparatus performing prime number generation and testing of generated candidates for probable primality, with particular emphasis on speed.

0002Large prime or probable prime numbers are useful for a variety of cryptographic applications. For example, prime numbers are used in generating key pairs in a public key cryptography system (such as RSA).

0003An example of a public key cryptographic algorithm (RSA) is described in the article by <nplcit id="ncit0001" npl-type="s"><text>Chenghuai Lu et al., "Implementation of Fast RSA Key Generation on Smart Cards", Proceedings of the ACM Symposium on Applied Computing, March 14, 2002</text></nplcit>. The method described therein first determines a candidate that is relatively prime to all primes contained in a list of small primes, employing a variation of the sieve of Eratosthenes. Subsequently the candidate is subjected to at least one known rigorous probable primality test. A plurality of different primality tests is discussed.

0004Further, a pseudo-random number sequence can be generated using primes, as in <patcit id="pcit0001" dnum="US4780840A"><text>U.S. Patent No. 4,780,840 to Van Den Ende</text></patcit>. Such sequences could in turn be used in stream ciphers for secret communications.

0005As the required size of the probable primes in these types of applications increases, an efficient way for the programmed computer system or chip involved in a cryptography method to quickly generate such primes becomes extremely important. In many applications it would be desirable, for added security and flexibility, that the large random prime numbers be generated immediately before use, rather than relying on a set of stored pre-computed prime values. Unfortunately, a difficulty in large prime number generation resides in the fact that probable prime candidates have to be tested through algorithms (such as Miller-Rabin or Fermat) that are time consuming or need a large amount of computing power or both. Techniques that quickly eliminate unlikely candidates would minimize the number of times that such rigorous tests need to be carried out before a probable prime is identified.

0006In <patcit id="pcit0002" dnum="US4351982A"><text>U.S. Patent No. 4,351,982, Miller et al.</text></patcit> disclose generating a sequence of prime numbers, beginning with a known prime, by incrementing from a preceding prime P in the sequence to a new value hP + 1 (h being random) and then testing the new value for primality. Any time a value is found to be composite, h is incremented by 2 and a new hP + 1 is tested. Once a value hP + 1 is found to be prime, it is used as the new prime P for the next search.

0007<nplcit id="ncit0002" npl-type="s"><text>P. Mihailescu, in an article entitled "Technique for Generating Probable Primes", IEEE P1963 submission (1994</text></nplcit>), describes a sieving method for generating prime numbers that are of the form N = 2*(t + k)* Q + 1, where the incremental search for prime candidates is done by increasing k in some manner.

0008<nplcit id="ncit0003" npl-type="b"><text>J. Brandt et al., in the article "On Generation of Probable Primes by Incremental Search", Advances in Cryptology - Crypto '92, Springer-Verlag (1993), pp. 358-370</text></nplcit>, describes an incremental search for candidates for primality testing. Here the increment for generating new candidates from the previous test candidate is always 2.

0009An object of the invention is to provide a computer software (or firmware) method by which a computer system or chip programmed with such software can efficiently eliminate unlikely candidates for probable primality testing so that probable primes useful for cryptographic applications such as key generation can be quickly generated and tested.

0010Another object of the invention is to provide a cryptographic apparatus in the form of a programmed computer system or configured processing chip that executes the aforementioned probable prime generation and testing method.

0011This is achieved by the features of claim 1. In particular, the invention implements a smart incrementation and small primes testing technique wherein successive candidates, beginning with a randomly generated first large candidate, which are relatively prime to very small primes (e.g., 2, 3, 5 and 7) are modularly reduced and tested against a specified set of small primes (e.g, primes from 11 through 241) until a likely candidate is identified for more rigorous probable primality testing.

0012The smart increment program function finds successive integer candidates by identifying an increment (not necessarily 2) to the next candidate, using a table of congruent values that are relatively prime to the selected very small primes modulus the product of the selected very small primes (e.g., mod 210). The table keeps the form of the primes eventually found by the method unknown, which is strongly desired for cryptographic security. It immediately sieves out about three-fourths of the really obvious composites so that only the remaining candidates known to be relatively prime to the very small primes are subjected to trial division in the program's small primes testing function. Use of the table also allows an increment to be found without trial division by the large integer candidates themselves.

0013The small primes test program function carries out trial division against a list of small primes. However, the speed of this program is increased by doing the trial division on a set of modular reduced values rather than on the very large candidates themselves (e.g, of 32 bit size instead of 1024 bits). The reduction moduli are size-limited products (e.g., at most 32 bits) of groups of the same small primes against which the candidate will be tested.

0014Only candidates that pass the small primes test (about ten percent of the total number of integers in any given range) will be subjected to the more rigorous probable primality test(s) like Miller-Rabin or Fermat.

0015The present invention is a computer-implemented method for generating and testing of large (typically 256, 324, 512, 1024 bits or larger) probable prime numbers for cryptographic use. The method is preferably implemented as software code stored on and read from a computer-readable medium and executed by a general-purpose programmable computer system. It might also be implemented as firmware in a special-purpose cryptographic computer chip (e.g., on a smart card), or even as configurable hardware (e.g., an FPGA chip) or application-specific circuitry (i.e., an ASIC chip) specifically programmed or designed to execute the steps of the method in its circuitry. Cryptographic uses for probable prime numbers include generating of keys, as in asymmetric (public-private key pair) encryption programs. Another cryptographic use for probable primes is for pseudo-random number generation, e.g. for stream cipher communications. The method of the present invention will typically be one part of a larger cryptographic computer program in which the large probable primes generated by the method are used. The computer system or special-purpose chip, when programmed to execute the method of the present invention can be considered, at that time, to be a prime number generating circuit or device.

0016The present method increases the speed of finding a probable prime by using a smart increment technique to avoid having to test unlikely candidates. A random number of the desired bit size (e.g., 1024 bits) is chosen and immediately incremented to a value that is relatively prime to the very small primes 2, 3, 5 and 7 to produce the initial candidate. Each candidate is tested by the programmed computer system or chip, beginning with trial integer division using a list of small primes, and if found to be composite is incremented by a selected even number (not necessarily two), to obtain the next candidate that is relatively prime to the very small primes 2, 3, 5 and 7. The present method uses this smart increment technique to minimize the number of composite numbers that are tested by integer division. The trial divisions are not conducted directly upon the large candidate number, but upon 32-bit modular reductions of the candidate, further speeding up the method. When a candidate is found that passes the small primes trial division test, the likely candidate is then tested using one or more known rigorous probable prime testing algorithms, such as the Miller-Rabin test or the Fermat test. As these latter tests are more time consuming (e.g., both of the above-named tests employ modular exponentiation), only those likely candidates found to be relatively prime against the small primes in the integer division test are subjected to the more rigorous tests.

0017The main part of the computer program may include the following: <pre listing-type="program-listing"> MainIncrement := SmartIncrement(true); AleaIsComposite := SmallPrimesTest(true); Label Generate_Candidate While (AleaIsComposite = true) do Begin LocalIncrement := SmartIncrement(false); MainIncrement := MainIncrement + LocalIncrement; For Counter := 0 to MAX_MODULI - 1 do Begin Table_Mod[Counter] := (Table_Mod[Counter] + LocalIncrement) % Table_Reductions[Counter]; End; AleaIsComposite := SmallPrimesTest(false); End; Alea := Alea + Mainlncrement; If (not Number_Is_Probably_Prime(Alea)) then Begin AleaIsComposite := true; Goto Generate_Candidate; End;</pre>

0018In this program, "Alea" is the name of the randomly selected candidate integer to be tested. Any random or pseudo-random number generating routine capable of rapidly producing a very large odd-number candidate of the requisite size could be used. "SmallPrimesTest" and "SmartIncrement" are functions, described in more detail below, that carry out the integer division test against a list of small prime numbers and the smart incrementation technique of the present invention, respectively. At the end, we obtain a number, which is relatively prime to the small prime numbers tested (AleaIsComposite = false). Then, any one or more of the rigorous classical primality testing methods, which are available can be employed on that number (represented by the function call "Number_Is_Probably_Prime"). However, such rigorous tests are only carried out on those candidates that first pass the "SmallPrimesTest". (About 90% of the possible candidates are eliminated as proven composites by means of the SmartIncrement and SmallPrimesTest functions, so that the more rigorous testing is only performed on the remaining 10% of candidate values.) If the candidate fails the chosen rigorous primality test(s) then a new candidate is generated where the main program left off.

0019The SmartIncrement function uses the following table: <tables id="tabl0001" num="0001"><table frame="none"><tgroup cols="1" colsep="0" rowsep="0"><colspec colnum="1" colname="col1" colwidth="165mm" colsep="1" /><tbody><row rowsep="1"><entry>Table_210[210] = {0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 13, 0, 0, 0, 17, 0, 19, 0, 0, 0, 23, 0, 0, 0, 0, 0, 29, 0, 31, 0, 0, 0, 0, 0, 37, 0, 0, 0, 41, 0, 43, 0, 0, 0, 47, 0, 0, 0, 0, 0, 53, 0, 0, 0, 0, 0, 59, 0, 61, 0, 0, 0, 0, 0, 67, 0, 0, 0, 71, 0, 73, 0, 0, 0, 0, 0, 79, 0, 0, 0, 83, 0, 0, 0, 0, 0, 89, 0, 0, 0, 0, 0, 0, 0, 97, 0, 0, 0, 101, 0, 103, 0, 0, 0, 107, 0, 109, 0, 0, 0, 113, 0, 0, 0, 0, 0, 119, 0, 121, 0, 0, 0, 0, 0, 127, 0, 0, 0, 131, 0, 0, 0, 0, 0, 137, 0, 139, 0, 0, 0, 143, 0, 0, 0, 0, 0, 149, 0, 151, 0, 0, 0, 0, 0, 157, 0, 0, 0, 0, 0, 163, 0, 0, 0, 167, 0, 169, 0, 0, 0, 173, 0, 0, 0, 0, 0, 179, 0, 181, 0, 0, 0, 0, 0, 187, 0, 0, 0, 191, 0, 193, 0, 0, 0, 0, 0, 199, 0, 0, 0, 0, 0, 0, 0, 0, 0, 209}</entry></row></tbody></tgroup></table></tables>

0020Table_210 consists of zeros for all entries that divisible by 2, 3, 5 or 7. But for entries that are relatively prime to 2, 3, 5 and 7, the table has non-zero values, e.g. the integers themselves. Other ways of distinguishing between elements representing divisible and relatively prime values in the table could also be used. The table helps SmartIncrement choose a candidate that is relatively prime to 2, 3, 5, and 7, for further integer division testing using the SmallPrimesTest function.

0021The SmartIncrement function may comprise the following program steps: <pre listing-type="program-listing"> Function SmartIncrement (FirstCall: boolean) : integer Var Increment : integer; Begin If (FirstCall = true) then Begin Mold_210 := Alea % 210; Increment := 0; End Else Begin Mod_210 := (Mod_210 + 2) % 210; Increment := 2; End; While (Table_210[Mod_210] = 0) do Begin Mold_210 := (Mod_210 + 2) % 210; Increment := Increment + 2; End; Return (Increment); End;</pre>

0022This embodiment of SmartIncrement ensures that each subsequent candidate is indivisible by 2, 3, 5 and 7. Alea is not used directly. Rather, calculations of Increment are made based on Alea % 210 (i.e., the modular remainder). The function steps through Table_210 until it finds the next value for Mod_210 (congruent to the corresponding value Alea + Increment) that is non-zero, i.e. relatively prime to 2, 3, 5, and 7. For cryptographic uses it is important that we do not use primes with a known particular form. Thus, for example, we do not limit the choice of candidates to those that are congruent to 1 mod 210, even though they would be easier to compute. A larger table of 2310 values identifying integers relatively prime to 2, 3, 5, 7 and 11 might be used with suitable modifications, but there are diminishing returns as the number of very small primes in the table increases. (Table_210 eliminates all but 48/210 or 22.86% of the candidates, while a larger Table_2310 would eliminate all but 480/2310 or 20.78% of the candidates.) Larger small primes (e.g., 11 through 241) are better tested using trial division rather than table-based smart incrementing.

0023The small primes test makes use of several tables: <maths id="math0001"><math display="block"><mi>Table_SmallPrimes</mi><mo>⁢</mo><mfenced open="[" close="]"><mn>0.</mn><mspace width="1em" /><mn>.</mn><mi>MAX_SMALL_PRIMES</mi><mo>-</mo><mn>1</mn></mfenced><mo>=</mo><mfenced open="{" close="}"><mn>11</mn><mn>13</mn><mn>17</mn><mn>19</mn><mn>23</mn><mn>29</mn><mn>31</mn><mn>37</mn><mn>41</mn><mn>43</mn><mn>47</mn><mn>53</mn><mn>59</mn><mn>59</mn><mn>61</mn><mn>67</mn><mn>71</mn><mn>73</mn><mn>79</mn><mn>83</mn><mn>89</mn><mn>97</mn><mn>101</mn><mn>103</mn><mn>107</mn><mn>109</mn><mn>113</mn><mn>127</mn><mn>131</mn><mn>137</mn><mn>139</mn><mn>149</mn><mn>151</mn><mn>157</mn><mn>163</mn><mn>167</mn><mn>173</mn><mn>179</mn><mn>181</mn><mn>191</mn><mn>193</mn><mn>197</mn><mn>199</mn><mn>211</mn><mn>223</mn><mn>227</mn><mn>229</mn><mn>233</mn><mn>239</mn><mn>241</mn></mfenced><mo>;</mo></math><img file="EP1518172B1_D0001.tif" /></maths><maths id="math0002"><math display="block"><mi>Table_Reductions</mi><mo>⁢</mo><mfenced open="[" close="]"><mn>0.</mn><mspace width="1em" /><mn>.</mn><mi>MAX_MODULI</mi><mo>-</mo><mn>1</mn></mfenced><mo>=</mo><mfenced open="{" close="}"><mn>11</mn><mo>*</mo><mn>13</mn><mo>*</mo><mn>17</mn><mo>*</mo><mn>19</mn><mo>*</mo><mn>23</mn><mo>*</mo><mn>29</mn><mo>*</mo><mn>31</mn><mo>,</mo><mn>37</mn><mo>*</mo><mn>41</mn><mo>*</mo><mn>43</mn><mo>*</mo><mn>47</mn><mo>*</mo><mn>53</mn><mo>,</mo><mn>59</mn><mo>*</mo><mn>59</mn><mo>*</mo><mn>61</mn><mo>*</mo><mn>67</mn><mo>*</mo><mn>71</mn><mo>*</mo><mn>73</mn><mo>,</mo><mn>79</mn><mo>*</mo><mn>83</mn><mo>*</mo><mn>89</mn><mo>*</mo><mn>97</mn><mo>,</mo><mn>101</mn><mo>*</mo><mn>103</mn><mo>*</mo><mn>107</mn><mo>*</mo><mn>109</mn><mo>,</mo><mn>113</mn><mo>*</mo><mn>127</mn><mo>*</mo><mn>131</mn><mo>*</mo><mn>137</mn><mo>,</mo><mn>139</mn><mo>*</mo><mn>149</mn><mo>*</mo><mn>151</mn><mo>*</mo><mn>157</mn><mo>,</mo><mn>163</mn><mo>*</mo><mn>167</mn><mo>*</mo><mn>173</mn><mo>*</mo><mn>179</mn><mo>,</mo><mn>181</mn><mo>*</mo><mn>191</mn><mo>*</mo><mn>193</mn><mo>*</mo><mn>197</mn><mo>,</mo><mn>199</mn><mo>*</mo><mn>211</mn><mo>*</mo><mn>223</mn><mo>*</mo><mn>227</mn><mo>,</mo><mn>229</mn><mo>*</mo><mn>233</mn><mo>*</mo><mn>239</mn><mo>*</mo><mn>241</mn></mfenced><mo>;</mo></math><img file="EP1518172B1_D0002.tif" /></maths><maths id="math0003"><math display="block"><mi>Table_SmallPrimesIndexes</mi><mo>⁢</mo><mfenced open="[" close="]"><mn mathvariant="normal">0.</mn><mspace width="1em" /><mn mathvariant="normal">.</mn><mi>MAX_MODULI</mi><mo mathvariant="normal">-</mo><mn mathvariant="normal">1</mn></mfenced><mo mathvariant="normal">=</mo><mfenced open="{" close="}"><mn mathvariant="normal">0</mn><mn mathvariant="normal">7</mn><mn mathvariant="normal">12</mn><mn mathvariant="normal">17</mn><mn mathvariant="normal">21</mn><mn mathvariant="normal">25</mn><mn mathvariant="normal">29</mn><mn mathvariant="normal">33</mn><mn mathvariant="normal">37</mn><mn mathvariant="normal">41</mn><mn mathvariant="normal">45</mn></mfenced><mn mathvariant="normal">.</mn></math><img file="EP1518172B1_D0003.tif" /></maths>

0024The first and second tables are, respectively, a list of the first known prime numbers less than 250 and products of groups of primes from that list. The primes 2, 3, 5 and 7 are left out of the tables, because we assure that the random number "Alea" will not only be odd, but also chosen to be relatively prime to 3, 5, and 7 by using the "SmartIncrement" procedure detailed above. The products in the second list are limited to 32 bits for easier division. (64 bits or even greater products could be used instead, depending on available hardware.) The third "index" table serves to index the list of small primes into consecutive subsets corresponding to the products in the second list.

0025The table sizes can be extended or reduced, depending on the desired number of tests. The number of tests deemed to be needed is typically based on the bit size of the prime numbers that have to be generated. For larger tables than those given here, it may be more convenient to derive the tables from all numbers relatively prime to 2, 3, 5 and 7, rather than the prime numbers themselves. While a small number of composite numbers would be included in addition to the primes (e.g., 121, 143, 169, 187, 209, 221, and 247 would be added to the above tables), the ease of generating the values for the test may outweigh making the tests slightly longer than absolutely necessary. Again, however, there is a diminishing return on eliminating proven composites by small prime trial division as the list of primes gets longer. The point at which it becomes desired to switch over from trial division to the more rigorous Miller-Rabin, Fermat or some other probable prime testing is a matter of judgment that mainly depends on the bit size of the candidate and the desired security level.

0026The computer program for the small primes test function may comprise the following: <pre listing-type="program-listing"> Function SmallPrimesTest(FirstCall : boolean) : Boolean; Var Composite : Boolean; Begin If (FirstCall = True) then Begin For Counter := 0 to MAX_MODULI - 1 do Begin Table_Mod[Counter] := Alea % Table_Reductions[Counter]; End; End; Composite := false; While (Composite = false) do Begin Counter := 0; While ((Composite = false) and (Counter &lt; MAX_MODULI)) do Begin CounterPrimes := Table_SmallPrimes[Table_SmallPrimesIndexes[Counter]]; While ((Composite = false) and (CounterPrimes &lt; Table_SmallPrimesIndexes[Counter + 1])) do Begin If (((Table_Mod[Counter] + MainIncrement) % Table_SmallPrimes[CounterPrimes]) = 0) Then Composite := true; Else CounterPrimes := CounterPrimes + 1; End; Counter := Counter + 1; End; End; Return Composite; End;</pre>

0027During the first execution of the small primes test, the original large candidate integer Alea is first reduced to a table of much smaller 32 bit integers "Table_Mod" by performing modular division by each one of the prime products in Table_Reductions to obtain a set of 32 bit remainders. These "Table_Mod" entries should be retained by the program for each subsequent call of "SmallPrimesTest", so that the large integer divisions do not need to be recalculated. Trial division is then conducted with the "Table_Mod" entries, after first incrementing by the current trial increment "MainIncrement", using the index table to test the candidate against the same primes that were in the product used for the corresponding reduction, and the remainders are checked. If trial division by any small prime from "Table_SmallPrimes" is zero, then the current candidate is found to be composite, and the value (Composite = true) is returned, without any further trial divisions on that candidate being needed. If the remainder is nonzero for all tested small primes, then the value (Composite = false) is returned, and the main program proceeds to the more rigorous probable primality tests.

0028Once a candidate has passed all of the tests, it is demonstrated to be probably prime. It is then used by other parts of a cryptographic program for such applications as key generation for asymmetric (public key) block ciphers or for pseudo-random number generation (as in <patcit id="pcit0003" dnum="US4780840A"><text>U.S. Patent No. 4,780,840</text></patcit>) for stream cipher communications. Use in generating session keys in smart card transactions is especially relevant, since the faster generation and testing speed allows the present method to be carried out by the single-chip processors placed on smart cards without undue delays.