ECM at Work

8 downloads 26 Views 541KB Size Report
The performance of the elliptic curve method (ECM) for integer factorization plays an important role in the security assessment of RSA-based protocols as a ...

ECM at Work Joppe W. Bos1? and Thorsten Kleinjung2 1 2

Microsoft Research, One Microsoft Way, Redmond, WA 98052, USA Laboratory for Cryptologic Algorithms, EPFL, Lausanne, Switzerland

Abstract. The performance of the elliptic curve method (ECM) for integer factorization plays an important role in the security assessment of RSA-based protocols as a cofactorization tool inside the number field sieve. The efficient arithmetic for Edwards curves found an application by speeding up ECM. We propose techniques based on generating and combining additionsubtracting chains to optimize Edwards ECM in terms of both performance and memory requirements. This makes our approach very suitable for memory-constrained devices such as graphics processing units (GPU). For commonly used ECM parameters we are able to lower the required memory up to a factor 55 compared to the state-of-the-art Edwards ECM approach. Our ECM implementation on a GTX 580 GPU sets a new throughput record, outperforming the best GPU, CPU and FPGA results reported in literature. Keywords: Elliptic curve factorization, cofactorization, addition-subtraction chains, twisted Edwards curves, parallel architectures.



Today, more than 25 years after its invention by Hendrik Lenstra Jr., the elliptic curve method [24] (ECM) remains the asymptotically fastest integer factorization method for finding relatively small prime factors of large integers. Although it is not the fastest general purpose √ integer factorization method, when factoring a composite integer n = pq with p ≈ q ≈ n the number field sieve [32, 23] (NFS) is asymptotically faster, it has recently received a renewed research interest due to the discovery of an interesting normal form for elliptic curves introduced by Edwards [13]. From a cryptologic point of view the practical performance of ECM is important since it is used to rapidly factor many small (up to one or two hundred bits) integers inside NFS. This is illustrated by the fact that it is estimated that five to twenty percent (cf. Section 2.2 why this is hard to estimate) of the total wall-clock time was spent in ECM in the current world-record factorization of a 768-bit RSA number [20] (and it is expected that this percentage will grow for larger factorizations). Using ECM as a tool to factor many small numbers inside NFS is an active research area by itself. Offloading this work to reconfigurable hardware such as field-programmable gate arrays is studied in [37, 16, 11, 17, 25, 40] while [5, 4] considers parallel architectures such as graphics processing units (GPUs) and the Cell broadband engine architecture. A comparison between software and hardware based solutions is presented in [21]. Traditionally, ECM is implemented using Montgomery curves [26] and uses the various techniques described in [39]. The most-widely used ECM implementation is GMP-ECM [41] and this implementation, or modifications to it, is responsible for setting all recent ECM record factorizations (see a description of some of these record factorizations in [8]). After the invention of Edwards curves Bernstein et al. explored the possibility to use these curves in the ECM setting [3]. Hisil et al. [19] published a coordinate system for Edwards curves which results in the fastest known realization of curve arithmetic. A follow-up paper ?

Part of this work was performed when the first author was working at the Laboratory for Cryptologic Algorithms, EPFL, Lausanne, Switzerland.


Joppe W. Bos and Thorsten Kleinjung

by Bernstein et al. discusses the usage of these “a = −1” twisted Edwards curves [1] for ECM. The speedup from switching to Edwards curves comes at a price, addition chains [35] (or addition-subtraction chains [28]) equipped with large windowing sizes [9] are used (cf. [6] for a summary of these techniques). The memory requirement for Edwards ECM grows roughly linearly with the input parameters of ECM while a small constant number of residues modulo n are sufficient when using Montgomery curves. In this paper we optimize ECM by exploiting the fact that the same scalar is often used when computing the elliptic curve scalar multiplication (ECSM), allowing one to prepare particularly good addition-subtraction chains for these fixed scalars. Our approach is inspired by the ideas used in the ECM implementation by Dixon and Lenstra [12] from 1992. In [12] the total cost to compute the ECSM, in terms of point doubling and point additions, is lowered by testing if the computation of the ECSM using batches of small prime products is cheaper (requires fewer point additions) than processing the primes one at a time (or all in one big batch). We generalize this idea: many billions of integers, which are constructed such that they can be computed using an addition-subtraction chain with a high doubling/addition ratio, are tested for smoothness and factored. By fixing different popular elliptic curve scalar values used in ECM inside NFS we are able to combine some of these integers using a greedy approach. This results in a more efficient ECSM algorithm with a smaller memory footprint. To illustrate, compared to the cofactorization setting considered by Bernstein et al. in [5, 4] (using the parameter B1 = 213 ) the techniques from this paper reduce the memory by a factor 55. This makes our approach particularly interesting for environments where the memory (per thread) is constrained; e.g. GPUs. We illustrate the practical benefits by implementing this approach for GPUs: setting a new throughput speed record compared to the current CPU, GPU and FPGA based results reported in literature. The best addition-subtraction chains found for the various popular B1 values can be found online [7]. This paper is organized as follows. After recalling the preliminaries in Section 2 the notation and basic idea behind elliptic curve constant scalar multiplication is discussed in Section 3. Section 4 explains how to combine these chains such that they might result in a faster and more memory efficient ECM. Section 5 explains a side-effect why certain chains require more modular multiplications and Section 6 presents the obtained results. Section 7 concludes the paper.

2 2.1

Preliminaries The Elliptic Curve Method

The elliptic curve method (ECM) for integer factorization [24] is analogous to the Pollard p − 1 integer factorization method [33] and attempts to factor a composite integer n. The general idea behind ECM is as follows (we follow the description from [24]). First, pick a random point P and construct an elliptic curve E over Z/nZ such that P ∈ E(Z/nZ) (cf. [22, Sec. 2.B]). Next, compute the elliptic curve scalar multiplication Q = kP ∈ E(Z/nZ). The positive integer k is selected such that it is divisible by many small prime powers: e.g. k = lcm(1, 2, . . . , B1 ) for some bound B1 ∈ Z. If for a prime p dividing n the order #E(Fp ) is B1 -powersmooth (an integer is defined to be B-powersmooth if none of the prime powers dividing this integer is greater than B) then #E(Fp ) | k. In other words, Q = kP and the neutral element of the curve become the same modulo p. In this event we have p | gcd(n, Qz ), where Qz is the z-coordinate of the point Q when using projective Weierstrass coordinates. If gcd(n, Qz ) 6= n then we have split n.

ECM at Work


Table 1. Performance comparison between GMP-ECM and EECM-MPFQ using the “a = −1” twisted Edwards curves in terms of modular multiplications (M) and squarings (S) together with the required number of residues modulo n (R) which needs to be kept in memory. GMP-ECM [41] B1 #S #M #S+#M #R 256 1 066 2 025 3 091 14 512 2 200 4 210 6 410 14 4 422 8 494 12 916 14 1024 8192 35 508 68 920 104 428 14

EECM-MPFQ [3] #S #M #S+#M #R 1 436 1 638 3 074 38 2 952 3 183 6 135 62 5 892 6 144 12 036 134 47 156 45 884 93 040 550

Hasse proved (see e.g. [36, Theorem 1.1]) that the order #E(Fp ) is in the interval [p + √ √ 1 − 2 p, p + 1 + 2 p]. The advantage of ECM is that one can randomize the group order by trying different curves. It has been shown in [24] that the (heuristic) run-time of ECM depends mainly on p, the smallest non-trivial prime divisor of n, and can be expressed as p √ O(exp(( 2 + o(1))( log p log log p))M (log n)) where M (log n) represents the complexity of multiplication modulo n and the o(1) is for p → ∞. The approach described here is often referred to as “stage 1”. There is a “stage 2” continuation for ECM which takes as input a bound B2 ∈ Z and succeeds (in factoring n) if Q = kP has prime order ` (for B1 < ` < B2 ) in E(Fp ). This means that #E(Fp ) is B1 powersmooth except for one prime factor which is below B2 . There are several techniques [10, 26, 27] how to perform stage 2 efficiently. In the following we will focus on stage 1 only. 2.2

Cofactorization using ECM

The relation collection phase, one of the two main phases of NFS, generates a lot of composite integers which need to be tested for powersmoothness. This is done using different factorization techniques and is denoted as the cofactorization phase. To illustrate, the total time spent in the cofactorization procedure was roughly one third of the sieving time when factoring the 768-bit RSA modulus in [20]. Note that this one third includes the time of pseudo primality tests and different factorization methods: quadratic sieve [34], Pollard p − 1 [33] and ECM. In this cofactorization phase only composites up to 140 bits were considered and ECM was used only for composites up to 109 bits. The parameters for ECM varied depending on the size of the composites and ranged from B1 = 150 to B1 = 500 where often only a single curve was tried with a maximum of around eight curves. Observing the trend of past record factorizations, it is conceivable that cofactorization becomes more important in bigger factorizations (cf. [5] for more detailed arguments about the significance of ECM in NFS). 2.3

Montgomery versus Edwards Curves

The main motivation to use Edwards (over Montgomery) curves is performance. There is one implementation of ECM using Edwards curves available: EECM-MPFQ. This implementation includes the “a = 1” Edwards curves approach from [3] and the “a = −1” Edwards curves approach from [1]. The a = −1 Edwards ECM approach is the fastest in practice and we use this as the base setting to compare to. Table 1 compares the required number of multiplications and squarings required in GMP-ECM and EECM-MPFQ for different typical B1 values used in ECM when used as a cofactorization method in NFS. These numbers show that using Edwards


Joppe W. Bos and Thorsten Kleinjung

curves results in fewer modular multiplications and squarings. However, the required storage for GMP-ECM (Montgomery curves) is independent of B1 while it grows almost linearly with the size of B1 and is significantly higher, due to the use of windowing based methods, for EECM-MPFQ (Edwards curves, see [3, Table 4.1]).


Elliptic Curve Constant Scalar Multiplication

Most of the addition-subtraction chains based algorithms in practice use a w-bit windowing technique, for some (optimal) width w, to reduce the number of required elliptic curve additions. The total number of additions may be significantly reduced by using this approach but one also needs to store more points: 2w−1 when using sliding windows [38]. In environments where the available memory per thread is low, these methods cannot be used or one is forced to settle for a suboptimal window size. A prime example of such a platform are graphics processing units (GPUs); one of the latest GPU architectures [29] (Fermi) shares 64 kilobyte fast shared memory per 32 processors and each processor typically time-shares multiple threads (e.g., 16 to 32 corresponding to 128 to 64 bytes per thread). We investigate two approaches to lower the number of elliptic curve additions and the storage required to compute the scalar product. Our approach is inspired by the results Q` reported by Dixon and Lenstra [12]. Suppose we have a scalar k = lcm(1, . . . , B1 ) = i=1 pi , where the pi are primes which can occur multiple times. Typically, the ECSM is implemented processing one such pi at a time [39]. In [12] it is suggested to process theQ pi in batches; i.e. multiply a batch of pi ’s at a time such that Q the weight of the product w( i pi ), the number of ones in the binary representation of i pi , is (much) lower than the sum of the individual P w(p ). If this is the case then the number of required EC-additions is reduced weights i i when using the straight forward double-and-add approach (which does not require to store any additional precomputed points). Such low-weight products can be constructed by greedily searching through b-tuples of the pi where b is small. In [12] b was at most 3 which reduced the total weight by approximately a factor three. As an example the following triple is given 1028107 · 1030639 · 1097101 = 1162496086223388673 w(1028107) = 10, w(1030639) = 16, w(1097101) = 11, w(1162496086223388673) = 8, where the product of primes of weights 10, 16, and 11 results in a integer of weight eight. The resulting composite integer can be computed using an addition chain requiring only seven additions and 60 doublings using the naive double-and-add algorithm. In this section we explore different methods to find numbers which can be constructed using even better (higher) doubling/addition ratios. These methods do not aim to construct sequences by combining the different pi (as in [12]) but we propose an opposite approach by factoring many integers which are the result of addition-subtraction chains with high doubling/addition ratios and subsequently combining these integers such that all pi ’s are used. These addition-subtraction chains are constructed such that they do not require any large lookup tables. Notice that the information encoding the sequence of arithmetic operations has to be stored (in all approaches). This does not pose a problem since this information is constant and can be shared among all the computational units (or streamed to the units or even hardcoded) and hence does not result in additional overhead in practice. In the remainder of the paper we denote addition-subtraction chains simply as chains.

ECM at Work



Chains With Restrictions

In order to generate integers which can be computed using a chain with a high doubling/addition ratio we need to construct and denote chains of a certain length m. A chain is a sequence of doublings, additions and subtractions denoted by D, A and S respectively. A doubling can always be assumed to apply to the previously generated element in the chain (instead of doubling any previous element), since one can reorder the symbols such that doubling always occurs on the last element without changing the result of the chain. In some cases this might result in a shorter (more efficient) sequence when the same element is doubled multiple times. Let us define the set of symbols O as O = {D} ∪ {Ai,j | i, j ∈ Z, i > j} ∪ {Si,j | i, j ∈ Z, i > j}, where the subscripts indicate on which element in the chain we compute (this is made more precise later). The set of all m-tuples, ordered lists of m elements, of symbols in O with the restriction that no elements can be used which have not yet been generated is Om = {(om−1 , . . . , o0 ) ∈ O m | ok ∈ {D} ∪ {Ai,j | i ≤ k} ∪ {Si,j | i ≤ k}, 0 ≤ k < m}. In order to construct a chain from such an m-tuple of symbols we define functions σm : O × Zm+1 → Zm+2 such that (o, (tm , . . . , t0 )) 7→ (tm+1 , tm , . . . , t0 ) where   2tm if o = D, tm+1 = ti + tj if o = Ai,j ,  ti − tj if o = Si,j . Given an m-tuple of symbols (om−1 , . . . , o0 ) ∈ Om the (m + 1)-tuple of integers associated to this chain is σm−1 (om−1 , σm−2 (om−2 , . . . , σ0 (o0 , 1) . . .)) and the resulting integer produced by this chain is tm . As an example consider the 7-tuple of symbols (S6,0 , D, D, A3,0 , D, D, D) ∈ O7 which corresponds to the 8-tuple of integers in the chain (35, 36, 18, 9, 8, 4, 2, 1) computed as σ6 (S6,0 , σ5 (D, σ4 (D, σ3 (A3,0 , σ2 (D, σ1 (D, σ0 (D, 1))))))). The function σm is the correspondence between a tuple of symbols and the actual chain. The example shows how to compute the resulting integer 35 using one subtraction, one addition and five doublings. The set of tuples Om consists of the most generic type of chains, a significant amount of tuples corresponds to chains which perform useless (unnecessary) computations. An example is computing the addition (or subtraction) of two previous values without using this result. To address this we define a more restricted set of tuples Pm ⊂ Om as Pm = {(om−1 , . . . , o0 ) ∈ Om | ok ∈ {D} ∪ {Ai,j | i = k} ∪ {Si,j | i = k}, 0 ≤ k < m}. These additional restrictions ensure that, just as for the doubling, we only add or subtract to the last integer in the sequence to obtain the next one. Such chains are known as Brauer chains or star addition chains [18, Section C6]. In this setting we write Aj and Sj for Ai,j and Si,j , respectively, and k > 0 subsequent instances of D are denoted by Dk . The previous example can now be written as S0 D2 A0 D3 ∈ P7 by abusing the notation: omitting the brackets and comma’s. In practice we would generate sequences of symbols such that a number of elliptic curve additions A and doublings D are




30000 25000

100000 20000 10000 15000 1000 10000 100

Number of unique integers

Joppe W. Bos and Thorsten Kleinjung

Number of addition/subtraction chains (logarithmic scale)




0 0


10 15 20 25 30 35 40 45 50 Number of duplications

Fig. 1. The two top lines on the left denote the number of generated addition-subtraction chains computing odd integers with Pm (upper (red) line) and Qm (lower (green) line) when fixing A=3 and varying the number of doublings from one to fifty. The lower two lines show the number of unique integers corresponding to these chains where the upper line corresponds to Pm .

fixed and look at sequences of symbols of length m = A + D which use A times Aj or Sj and D times D. Different tuples might compute the same integer result. Using our example, the number 35 can be obtained with D = 5 and A = 2 in different ways 35 = (23 + 1) · 22 − 1 S0 D2 A0 D3 ∈ P7 = (24 + 1) · 2 + 1 A0 DA0 D4 ∈ P7 .


Generating Chains

We discuss how to efficiently generate the resulting integers tm in a low-storage and no-storage setting. The Low-Storage Setting. Let A be the number of elliptic curve additions and D the number of elliptic curve doublings (with D ≥ A). The generation of all the tuples in Pm , with m = A + D results in many identical integers tm . Removing these duplicate integers can be achieved by first generating and storing all the resulting integers and subsequently sorting and keeping exactly one of consecutive equal integers. To avoid storing all the resulting integers for a given pair (A, D), which requires a significant amount of storage as we will see later, and to avoid sorting this huge data set we define a more restricted set of rules Qm ⊂ Pm ⊂ Om as follows  Qm = (om−1 , . . . , o0 ) ∈ Pm | o0 = D, om−1 ∈ {Ai , Si }, 0 < k < m − 1 : ok ∈ {D} ∪ {A i , Si }, ok ∈ {Ai , Si } ⇒ ok−1 = D ∧ (i = 0 ∨ oi−1 ∈ {A` , S` }) .

ECM at Work


The restrictions used in the definition of Qm ensure that the resulting integer is odd and only addition (or subtraction) of an odd number to the current (even) number is allowed. This approach significantly reduces the amount of chains which produce the same resulting integer at the cost of slightly reducing the number of unique integers produced. To illustrate, Figure 1 shows the number of tuples generated by Pm and Qm when using A = 3 additions and 3 ≤ D ≤ 50 doublings resulting in odd integers. For D = 50 the total number of tuples generated by P53 is more than 140 times higher compared to Q53 while the number of unique odd resulting integers is only 1.09 times higher. The list of m + 1 integers ui corresponding to the m-tuple of symbols from Qm can be efficiently generated recursively using  2ui ui+1 = ui ± uj for j < i and 2 | ui , 2 - uj with u0 = 1 and ensuring that the final operation is not a doubling (to make the resulting integer odd). Hence, the next integer in the sequence can always be obtained by doubling or adding a previous odd number uj to the current even integer ui . The required storage depends on which uj are used in subsequent additions and at which indices they are used. In practice we generate all sequences using a fixed number of doublings D and additions A making sure that the resulting storage requirement is never too large. A sequence of additions and doublings corresponding to the chains resulting from Qm looks like AiA−1 DdA−1 . . . Ai1 Dd1 Ai0 Dd0 = (AiA−1 D)DdA−1 −1 . . . (Ai1 D)Dd1 −1 (Ai0 D)Dd0 −1 (1) P d , d > 0, and indices ij that satisfy the restrictions of Qm , i.e., ij takes one with D = A−1 i=0 Ph i i of the values g=0 (dg + 1) for −1 ≤ h < j. Such a sequence starts with a doubling, ends with  an addition and an addition is always preceded by a doubling. Hence, there are D−1 A−1 choices for the order of the A − 1 pairs (Aij D) and the D − A doublings D. Since every addition can be substituted by a subtraction the number of possibilities is multiplied by a factor 2A . The indices ij can be chosen in A! ways, hence the total number of resulting integers produced by Qm is   A−1 Y D−1 · A! · 2A = 2A · A · (D − A + i). A−1 i=1

The No-Storage Setting. The second setting we consider is constructing chains which do not require any additional stored points, besides the in- and output (and possibly some auxiliary variables required to calculate the elliptic curve group operation). This means we are looking for integers which can be computed using chains which only use doublings and add or subtract the input point. We can define the set of tuples Rm ⊂ Qm as Rm = {(om−1 , . . . , o0 ) ∈ Qm | ok ∈ {A0 , S0 , D}, 0 ≤ k < m}. All resulting integers of no-storage chains which can be constructed using A elliptic curve additions and D elliptic curve doublings are of the form D

2 +

A−1 X

±2ni ,

with 0 = n0 < n1 < . . . < ni < . . . < nA−1 < D.


P This follows from (1) by setting ij = 0; we have ni = ig=1 dA−g . Using the same argument  A as in the low-storage setting the number of resulting integers generated by Rm is D−1 A−1 · 2 .


Joppe W. Bos and Thorsten Kleinjung

Compared to the low-storage setting the number is reduced by a factor of A!, reflecting the missing choice of the indices ij .


Combining Chains

Recall that, givenQa bound B1 , we want to perform an elliptic curve scalar multiplication with the integer k = `i=1 pi = lcm(1, . . . , B1 ) where the product ranges over ` (not necessarily distinct) primes. We can get rid of the problems posed by the primes 2 in this product by noticing that they can be handled by a sequence of doublings at the end of the ECSM and assuming in the following that all si are odd. The techniques from the previous section provide us with a lot of integers which can be constructed using a known number of additions (here we count subtractions as additions) and doublings. Since different chains can lead to the same integer we pick for each of these integers one chain (preferably the one with the lowest cost). In this way we get a list of distinct integers, each with an associated chain. We index this list by an index set I and call si the integer corresponding to i ∈ I. For i ∈ I denote by add(si ) resp. dbl(si ) the number of additions resp. doublings in the chain and by {si,1 , . . . , si,ti } the multiset of the primes in the prime decomposition of si . Furthermore, let cost(si ) be the cost of performing a scalar multiplication with si using the associated chain. A reasonable choice for Edwards curves is cost(si ) = 7dbl(si ) + 8add(si ) + 1 which will be discussed in the next section. Q P Ideally, we want to find a subset I 0 ⊂ I such that k | i∈I 0 si and i∈I 0 cost(si ) is minimal. To facilitate our task we will modify this in two ways. If the product in the first condition is bigger than k we do more work than necessary. Q This can lead to a lower cost, but we the minimum of assume that replacing the first condition by k = i∈I 0 si will not increase P P cost(s ) significantly. The second modification is the replacement of 0 i i∈I 0 cost(si ) by Pi∈I think that this does not increase the minimum too much i∈I 0 add(si ). To explain why weP we consider subsets I 0 for which i∈I 0 cost(si ) is close to the minimum. Then most si have Q dbl(si ) a high ratio add(s and therefore we have for most of them si ≈ 2dbl(si ) . Since i∈I 0 si = k ) i P the sum i∈I 0 dbl(si ) ≈ log2 (k) does not vary too much. Furthermore, the summand 1 in the cost function is the least significant term and the cardinality of I 0 does not vary much. We are aware that the second modification is more delicate than the first one, but, as explained below, we will generate many sets I 0 and will pick the best one amongst them using the more costly function cost(si ). Q The condition k = i∈I 0 si implies that every si in this product is B1 -powersmooth which suggests the following two stage approach: 1. Restrict to Iˆ = {i ∈ I | si is B1 -powersmooth}. 2. Find a subset I 0 ⊂ Iˆ such that the multisets [ {si,1 , . . . , si,ti } = {p1 , . . . , p` } i∈I 0

coincide and that


i∈I 0

add(si ) is minimal.

Testing a large list of numbers for B1 -powersmoothness can be done using the method from [15, Section 4]. The main idea is to build a product tree from the list, replace the root node R (the product of all numbers of the list) by k mod R (where k = lcm(1, . . . , B1 ) is precomputed) and then tree-wise replace each node by the residue of k modulo the node. The leaves resulting

ECM at Work


in 0 contained B1 -powersmooth numbers and their factorizations can be obtained by other means. Finding an optimal set I 0 is in general a difficult problem and has been studied in [31]. We choose to use a greedy approach which produces satisfactory results. We start with an empty set I 0 and the multiset M = {p1 , . . . , p` } of primes to be matched. As long as M is non-empty Qi dbl(si ) we select an integer si = tj=1 si,j with {si,1 , . . . si,ti } ⊂ M such that the ratio add(s is high i) and replace I 0 by I 0 ∪ {i} and M by M \ {si,1 , . . . si,ti }. This may fail because we might not be able to satisfy the condition {si,1 , . . . si,ti } ⊂ M at a given point. There are several ways to overcome this problem, e.g., we could increase our supply of si by generating more Q chains. Another way consists in aborting the greedy search at this point, getting k = c · i∈I 0 si for some integer c. Using the method of Dixon/Lenstra, we can search for a decomposition of c into several factors, each having a good chain. For the sizes of B1 considered in this paper, namely B1 ≤ 8192, c consisted of very few primes and was often 1. Therefore the usually lower doubling/addition ratio of the c-part does not pose a problem for small B1 . A refinement to this approach is to also take the size of the prime factors si,j into account. A strategy could be to prefer choosing integers si which have mostly large prime divisors, since the majority of the primes pi is large. The idea is to attach a score to a B1 -powersmooth integer given its prime factorization with respect to the currently unmatched prime factors in k. For a multiset N of primes bounded by B1 the ratio of j-bit primes is defined as aj (N ) :=

#{p ∈ N | dlog2 (p)e = j} , #M

where 1 ≤ j ≤ dlog2 (B1 )e. Given M , the multiset of currently unmatched primes, the score of si is defined as   dlog2 (B1 )e ti Y X ah ({si,1 , . . . , si,t }) i   score si = si,j , M = ah (M ) j=1

h=1: ah (M )6=0

The higher the score the more small prime divisors are likely to be present. In general, for a given ratio, we select the integers which have a low score. To illustrate, consider B1 = 1024 where the initial ai are a2 = 0.032, a3 = 0.037, a4 = 0.021, a5 = 0.053, a6 = 0.037, a7 = 0.069, a8 = 0.122, a9 = 0.229, a10 = 0.399 P (with 10 i=2 ai = 1). Almost 40 percent of all the primes fall in the largest (10-bit) category. An example of a low score-integer is 11529215054666795009 = 743 · 719 · 677 · 461 · 457 · 449 · 337 where the size of the smallest prime is 9-bit, the score is 3.57 and this integer can be computed using 63 doublings and five additions as A0 D11 A0 D12 A0 D10 A0 D28 A0 D2 ∈ R68 . On the other hand, an example of a high-score integer, consisting of mainly small primes, is 1048575 = 41 · 31 · 11 · 52 · 3, its score is significant higher (29.62) and it can be computed with 20 doublings and a single subtraction as S0 D20 ∈ R21 . This approach using scores is outlined in Algorithm 1. Note that the scores are recalculated each time an si is chosen. In practice one could reduce the amount of these costly recalculations by picking several si in lines 10-13 of the algorithm; in this case one has to check that the union of the prime factors of the chosen si is still a multisubset of M .


Joppe W. Bos and Thorsten Kleinjung

ˆ which can Algorithm 1 Given a bound B1 and a set of B1 -powersmooth integers {si | i ∈ I}, be computed with a chain using add(si ) resp. dbl(si ) elliptic Q curve additions resp. doublings, together with the prime factorization of these integers (si = j si,j )Qthe algorithm attempts to output triples (sj , add(sj ), dbl(sj )) such that lcm(1, . . . , B1 ) = c · j sj for a small integer dbl(si ) c. This algorithm considers scores ≤ T only and combines integers si for which ≥r add(si ) where r starts at rh and is decreased until rl .  Q Bound B1 ∈ Z, we have lcm(1, . . . , B1 ) = `i=1 pi with pi prime.   Q  ˆ with si = ˆ Set of integers {si | i ∈ I} j si,j for si,j prime and i ∈ I. Input:  Upper and lower bound on the doubling/addition ratio: r and r . h l   A threshold value for the score: T. Y Output: Triples (si , add(si ), dbl(si )) and c such that c · si = lcm(1, . . . , B1 ). 1. M ← {p1 , . . . , p` }, I 0 ← ∅ 2. for r = rh to rl do 3. found ← true 4. while found=true do 5. found ← false, j ← 0 6. for i ∈ Iˆ do 7. 8. 9. 10. 11. 12. 13. 14.


dbl(si ) ≥ r and score(si , M ) ≤ T then add(si ) j ← j + 1, scorej ← (score(si , M ), i) sort scorei for 1 ≤ i ≤ j with respect to score(si , M ) if j ≥ 1 then i ← index from score1 , output (si , add(si ), dbl(si )) I 0 ← I 0 ∪ {i}, M ← M \ {si,1 , . . . , si,ti } found ← true Q output {(si , add(si ), dbl(si )) | i ∈ I 0 } and c = p∈M p if {si,1 , . . . , si,ti } ⊂ M and

A Randomized Variant In the current state, Algorithm 1 returns a single solution given a set of input parameters. To increase the amount of different subsets I 0 , and thereby hopefully improving the results, we randomize the selection process of the index that is added in lines 10-13 of the algorithm. With probability x ∈ R (0 < x < 1) select the si corresponding to score1 or, with probability 1 − x, skip it and repeat this procedure for score2 and so on. If we have reached the end of the list (after j trials) one could apply a deterministic choice.


Additional Multiplications

The fastest arithmetic for Edwards curves is due to Hisil et al. [19]. They propose to use extended twisted Edwards coordinates, which are twisted Edwards coordinates plus an auxiliary coordinate. This allows faster addition but slower doubling. Using a mixing technique, by switching between extended twisted Edwards and regular twisted Edwards, the overall cost for scalar multiplication is reduced [19]. This is realized by performing the doublings using the cheaper regular twisted Edwards coordinates when a doubling is followed by a doubling. When an addition is required after a doubling one can use the doubling formula in the extended twisted Edwards coordinates (which does not need the auxiliary coordinate as input) at the cost of an extra multiplication to compute the auxiliary coordinate of the result. Next, the fast addition is performed in extended twisted Edwards coordinates; one multiplication (to compute the auxiliary coordinate of the output) can be saved, cancelling the extra

ECM at Work


Table 2. The left table shows the number of integers (#int) generated with an addition-subtraction chain using A and D elliptic curve additions and doublings respectively. All these integers were tested for 2.9 · 109 powersmoothness and, if smooth, the prime divisors are stored. The bold ranges indicate that 231 random integers per single A, D combination were tested for smoothness instead of the full range. The right table shows the number of unique B1 -powersmooth integers in the no-storage and low-storage setting for different values of B1 . A 1 2 3 4 5

No-storage setting D #int 5 − 200 3.920 · 102 10 − 200 7.946 · 104 15 − 200 1.050 · 107 20 − 200 1.035 · 109 25 − 200 8.114 · 1010

6 30 − 150 9.150 · 1011 7 35 − 66 9.900 · 1010 Total 1.096 · 1012

A 1 2 3 4 5 5 6

Low-storage setting D #int 5 − 250 4.920 · 102 10 − 250 2.487 · 105 15 − 250 1.235 · 108 20 − 250 6.101 · 1010 25 − 158 2.956 · 1012 159 − 220 1.331 · 1011 60 − 176 2.513 · 1011

B1 256 512 1 024 8 192 2.9 · 109

No-Storage 2.423 · 105 1.470 · 106 5.691 · 106 9.352 · 107 2.274 · 1010

Low-Storage 9.210 · 106 3.159 · 107 7.861 · 107 4.400 · 108 3.997 · 1010

3.403 · 1012

multiplication used when doubling, since a doubling is always performed after an addition in ECSM-algorithms. This approach assumes that both inputs of the elliptic curve addition are in extended twisted Edwards coordinates. This is the case for double-and-add algorithms and (signed) windowing algorithms where the computation of the auxiliary coordinates of the lookup table are a minor overhead. In both our settings, where we consider low- and no-storage, this does not hold. The computation of the large elliptic curve scalar product is done by processing batches of prime products (the si ) at a time. All the additions or subtractions required in the chain to compute si require that the points are in extended twisted Edwards coordinates. When required, the odd intermediate results are stored in extended twisted Edwards coordinates at a cost of a single additional multiplication. The cost of computing a low-storage chain (om−1 , . . . , o0 ) ∈ Qm resulting in si is increased by x(si ) multiplications, where x(si ) = #{j | ∃h : oh ∈ {Aj , Sj }, 0 ≤ h < m}; i.e. the unique number of indices used in the additions and subtractions. Therefore we get for the cost function from the previous section cost(si ) = 7dbl(si ) + 8add(si ) + x(si ). In the no-storage setting we always have x(si ) = 1 leading to the choice for cost(si ) given at the beginning of the previous section. In total we have #{chains used} additional multiplications in the no-storage setting and a potentially higher number in the low-storage setting. We can save one multiplication due to the sequence containing the power of 2 (which consists of doublings only) and another multiplication if we assume that the input point is already in extended twisted Edwards coordinates.



Using the rules given in Section 3.2 for both the no-storage and the low-storage setting, we generated more than 1012 integers for many choices of the number of additions A and doublings D. Table 2 summarizes the ranges we have covered where bold ranges (in the lowstorage setting) indicate that only 231 random integers were generated instead of the full range. All these integers were subjected to 2.9 · 109 -powersmoothness tests which reduced the number of integers by about two orders of magnitude. This large powersmoothness-bound was chosen to facilitate searching for efficient chains for much larger B1 parameters. From the reduced set of integers we extracted those that are B1 -powersmooth for the values of B1 used in this paper


Joppe W. Bos and Thorsten Kleinjung

Table 3. The table shows the number of modular multiplications (M) and squarings (S) required to calculate A elliptic curve additions and D doublings for various B1 parameters when factoring an integer n with ECM. The memory required is expressed as the number of residues (R), integers modulo n, which are kept in memory. The performance speedup (in terms of #M + #S) and memory reduction compared to the Edwards ECM approach from [1] is given. B1 256 [1] No-storage Low-storage 512 [1] No-storage Low-storage 1 024 [1] No-storage Low-storage 8 192 [1] No-storage Low-storage

#M 1 638 1 400 1 383 3 183 2 842 2 776 6 144 5 596 5 471 45 884 43 914 42 855

#S 1 436 1 444 1 448 2 952 2 964 2 964 5 892 5 912 5 904 47 156 47 160 47 136

#M + #S 3 074 2 844 2 831 6 135 5 806 5 740 12 036 11 508 11 375 93 040 91 074 89 991

speedup 1.08 1.09 1.06 1.07 1.05 1.06 1.02 1.03

A 69 38 35 120 75 65 215 141 123 1 314 1 043 878

D 359 361 362 738 741 741 1 473 1 478 1 476 11 789 11 790 11 784

#R 38 10 14 62 10 18 134 10 18 550 10 18

reduction 3.80 2.71 6.20 3.44 13.40 7.44 55.00 30.56

(see right part in Table 2). These computations were done on five 8-core Intel Xeon E5430 (2.66GHz) and took more than a year, i.e., in total over 40 core years. The smoothness testing required most of the run-time and up to 4.6GB of memory. Using the approach outlined in Algorithm 1 one of these nodes was occasionally used for the combining experiments which consisted of thousands of runs of the randomized greedy approach, each of them taking only a couple of seconds for these low values of B1 . Table 4 shows an example for B1 = 256 in the no-storage setting. All the prime powers pe ≤ 256 with p prime, e ∈ Z such that pe+1 > 256 are used (using exactly the same prime powers as in GMP-ECM and EECM-MPFQ). The total cost, in terms of modular multiplications and squarings, for these 15 chains is 361 × (3M + 4S) + 38 × 8M + 13M = 1 400M + 1 444S where the 13 additional multiplications are due to changing to extended twisted Edwards coordinates in all except the first and last chain (row) in Table 4. Only additions or subtractions with the input point are performed, hence no storage besides the in- and output is required. Table 3 shows the results obtained using Algorithm 1 on our dataset (see Table 2). The memory required is expressed in the number of residues (R), integers modulo n, which need to be kept in memory. Here we assume that extended twisted Edwards coordinates are used, i.e., every point is represented by four coordinates. In the setting of EECM-MPFQ [3, 1] we assume that an optimal window size is used and that besides the window table only the input point needs to be kept in memory while we assume that two points (the input point and the current active point) are required in the no- and low-storage setting. The implementation of the elliptic curve group operation is assumed to require at most two auxiliary variables (residues). Hence, the no-storage setting requires memory for 2 × 4 + 2 = 10 residues modulo n. The low-storage results presented in Table 3 require to store at most two additional points (8 more residues modulo n compared to the no-storage setting). This is still significantly less compared to the approach used in [3, 1]. 6.1

Application to GPUs

When running ECM on memory constrained devices, like GPUs, the large number of precomputed points required for the windowing methods cannot be stored in fast memory. Typically

ECM at Work


Table 4. Example of the best chain found for B1 = 256 in the no-storage setting. #D #A product chain 11 1 89 · 23 S0 D11 5 14 2 197 · 83 S0 D S0 D9 15 2 193 · 191 S0 D12 A0 D3 15 2 199 · 19 · 13 A0 D14 A0 D1 18 1 109 · 37 · 13 · 5 A0 D18 6 19 2 157 · 53 · 7 · 3 · 3 S0 D S0 D13 21 3 223 · 137 · 103 A0 D10 A0 D10 A0 D1 23 3 179 · 149 · 61 · 5 S0 D13 A0 D5 S0 D5 28 1 127 · 113 · 43 · 29 · 5 · 3 S0 D28 11 16 30 3 181 · 173 · 167 · 11 · 7 · 3 A0 D A0 D A0 D3 33 5 211 · 73 · 67 · 59 · 47 · 3 S0 D6 A0 D2 A0 D11 S0 D3 S0 D11 36 4 241 · 131 · 101 · 79 · 31 · 11 A0 D2 A0 D16 A0 D16 A0 D2 41 4 233 · 229 · 163 · 139 · 107 · 17 S0 D9 S0 D4 S0 D11 S0 D17 49 5 251 · 239 · 227 · 151 · 97 · 71 · 41 S0 D3 S0 D29 A0 D4 A0 D8 A0 D5 8 0 28 D8 361 38 Total

one is forced to settle for a (much) smaller window size reducing the advantage from using twisted Edwards curves. For example, in [5] no large window sizes are used at all, the authors remark: “Besides the base point, we cannot cache any other points”. Memory is also a problem in [4], the faster curve arithmetic from Hisil et al. [19] is not used since this requires storing a fourth coordinate per point. From the data given in Table 3 it becomes clear that our approach reduces the memory requirements significantly. For example, the memory required to run ECM in the cofactorization setting on GPUs using B1 = 8 192 can be reduced by a factor 55. This setting was already considered in [5, 4] where the authors were forced to reduce memory requirements by using suboptimal window sizes. Hence, when using the methods described in this paper less memory is required allowing the usage of the faster curve arithmetic and reducing the number of elliptic curve additions required in the computation of the elliptic curve scalar multiplication. 6.2

Performance Comparison

In order to measure the practical speedup of the methods described in this paper we implemented the no-storage approach on GPUs. This implementation uses the Compute Unified Device Architecture (CUDA) which facilitates the development of massively-parallel general purpose applications for GPUs [30]. Our implementation is targeted at the third generation CUDA GPUs called “Fermi” [29]. Table 5 compares the performance results of different hardware platforms for B1 = 960 and B1 = 8192, numbers chosen such that we can directly compare to results reported in the literature on other (hardware) platforms. For B1 = 960, which is used as the example B1 value in [40, 11] and not spending as much effort as for B1 = 1024, we were able to construct a no-storage chain requiring 1 371 doublings and 135 additions. The FPGA and GTX295 results are quadratically scaled to 192-bit arithmetic to compare the different performance results. The other GPU results are from [4] and this implementation is optimized for the second generation CUDA GPUs. The pricing for this card is omitted since it is no longer sold (this card was launched January 2009). The results on the Intel i7-2600K CPUs have been obtained with the ECM implementation (using Montgomery curves) from the NFS software suite [14] which is responsible for all recent record NFS fac-


Joppe W. Bos and Thorsten Kleinjung

Table 5. Performance comparison of ECM on different platforms (using the “a = −1” twisted Edwards curves if available). The first table lists the different hardware properties. The second and third table state results for B1 = 960 and B1 = 8192 respectively. The scaled number of curves are when using 192-bit moduli. The performance ratio is the ratio between the GTX 580 no-storage row and the current row for the scaled number of curves per 100 USD. properties

GPU CPU FPGA GTX 295 GTX 580 Intel i7-2600K V4SX35-10 V4SX25-10 #cores 480 512 4 24 1 clock (MHz) 1 242 1 544 3 400 200 220 price (USD) 400 300 468 298 #threads 46 080 8 192 4 24 1 #bits in moduli 210 192 192 202 135 performance (#curves), B1 = 960 performance (1/sec) (1/sec, scaled) (1/100 USD, scaled) ratio GTX 580, no-storage 171 486 171 486 42 872 1.00 79 170 19 793 2.17 GTX 580, windowing 79 170 Intel i7 [14] 13 661 13 661 4 554 9.41 Intel i7 [2] 8 677 8 677 2 892 14.82 V4SX35-10 [40] 3 240 3 586 766 55.97 V4SX25-10 [11] 16 000 7 910 2 654 16.15 performance (#curves), B1 = 8192 GTX 295 [4] 4 928 5 895 GTX 580, no-storage 19 869 19 869 GTX 580, windowing 9 106 9 106 Intel i7 [14] 1 629 1 629 1 092 1 092 Intel i7 [2]

4 967 2 277 543 364

1.00 2.18 9.15 13.65

torizations (e.g. [20]) and the EECM-MPFQ software package [2] which uses Edwards curves. The FPGA results are from [11, 40] and the FPGA prices are taken from [40]. Note that the prices are for the GPU, CPU or FPGA devices only; in order to get a fully operational system more hardware is required. Note also that for all of the considered devices newer versions with better price performance ratio exist, but we do not expect that these will change this comparison significantly. For the sake of comparison we also implemented Edwards ECM for GPUs using the same 192-bit arithmetic but using the windowing based approach. For B1 = 960 (B1 = 8192) we used a signed sliding window of size 26 (28 ), precomputing and storing 25 (27 ) extended twisted Edwards coordinates. These results are stated in Table 5 as well. On the GTX 580 the no-storage approach is more than twice as fast as the approach based on windowing techniques. This is significantly better than the theoretical numbers from Table 3. When running exactly the same experiment on 96-bit (three 32-bit limbs instead of six 32-bit limbs) moduli the number of curves per second for the no-storage and windowing approach is 76 665 and 75 584 for B1 = 8 192 and 649 904 and 618 111 for B1 = 960, respectively. We think that this behaviour can be partially explained by an increased memory usage for the windowing approach and a better handling of the no-storage approach by the compiler since this approach uses fewer variables. Another interesting observation is that the FPGA performance per 100 USD is lower than that of the CPU-based approaches. Furthermore, aided by the no-storage approach outlined in this paper, the GPU performance is almost an order of magnitude faster per 100 USD than the CPU and more than a order of magnitude faster compared to the fastest FPGA results.

ECM at Work


This suggests that GPUs are the best platform, i.e. give the best performance / price ratio, for integer cofactorization.



The relatively new Edwards curves combined with the fast arithmetic from extended twisted Edwards coordinates are faster compared to using Montgomery curves. This speed-up comes at a price, namely a larger memory requirement which, when optimizing for speed, grows roughly linearly in the size of B1 , whereas the memory requirement in the Montgomery curves setting is constant and small. Inspired by the approach from Dixon and Lenstra and using the fact that only a few popular B1 -values are used in practice in NFS, we have presented techniques to reduce the memory requirement significantly by doing precomputations for these B1 -values. In these precomputations we tested over 1012 integers coming from chains with a low addition/doubling ratio for smoothness and combined them using a greedy approach. Our results show that we require significantly less memory compared to the current state-of-theart Edwards ECM approach, and are even slightly faster. This makes our approach extremely suitable for memory-constrained parallel architectures like GPUs. This is demonstrated by our GPU implementation which sets a new ECM cofactorization throughput speed record. Acknowledgments Much appreciated incisive comments by the Asiacrypt’12 reviewers helped improve the quality of this paper. This work was supported by the Swiss National Science Foundation under grant numbers 200020-132160 and 200021-119776.

References 1. D. J. Bernstein, P. Birkner, and T. Lange. Starfish on strike. In M. Abdalla and P. S. L. M. Barreto, editors, Latincrypt, volume 6212 of Lecture Notes in Computer Science, pages 61–80. Springer, Heidelberg, 2010. 2. D. J. Bernstein, P. Birkner, T. Lange, and C. Peters. EECM: ECM using Edwards curves. Software:, 2010. 3. D. J. Bernstein, P. Birkner, T. Lange, and C. Peters. ECM using Edwards curves (to appear). Mathematics of Computation, 2012. 4. D. J. Bernstein, H.-C. Chen, M.-S. Chen, C.-M. Cheng, C.-H. Hsiao, T. Lange, Z.-C. Lin, and B.-Y. Yang. The billion-mulmod-per-second PC. In Special-purpose Hardware for Attacking Cryptographic Systems – SHARCS 2009, pages 131–144, 2009. 5. D. J. Bernstein, T.-R. Chen, C.-M. Cheng, T. Lange, and B.-Y. Yang. ECM on graphics cards. In A. Joux, editor, Eurocrypt 2009, volume 5479 of Lecture Notes in Computer Science, pages 483–501. Springer, Heidelberg, 2009. 6. D. J. Bernstein and T. Lange. Analysis and optimization of elliptic-curve single-scalar multiplication. In G. L. Mullen, D. Panario, and I. E. Shparlinski, editors, Finite Fields and Applications, volume 461 of Contemporary Mathematics Series, pages 1–19. American Mathematical Society, 2008. 7. J. W. Bos and T. Kleinjung. ECM at work, project page., 2012. 8. J. W. Bos, T. Kleinjung, A. K. Lenstra, and P. L. Montgomery. Efficient SIMD arithmetic modulo a Mersenne number. In IEEE Symposium on Computer Arithmetic – ARITH-20, pages 213–221. IEEE Computer Society, 2011. 9. A. Brauer. On addition chains. Bulletin of the American Mathematical Society, 45:736–739, 1939. 10. R. P. Brent. Some integer factorization algorithms using elliptic curves. Australian Computer Science Communications, 8:149–163, 1986. 11. G. de Meulenaer, F. Gosset, G. M. de Dormale, and J.-J. Quisquater. Integer factorization based on elliptic curve method: Towards better exploitation of reconfigurable hardware. In Field-Programmable Custom Computing Machines – FCCM 2007, pages 197–206. IEEE Computer Society, 2007.


Joppe W. Bos and Thorsten Kleinjung

12. B. Dixon and A. K. Lenstra. Massively parallel elliptic curve factoring. In R. A. Rueppel, editor, Eurocrypt 1992, volume 658 of Lecture Notes in Computer Science, pages 183–193. Springer, Heidelberg, 1993. 13. H. M. Edwards. A normal form for elliptic curves. Bulletin of the American Mathematical Society, 44:393– 422, July 2007. 14. J. Franke and T. Kleinjung. GNFS for linux. Software, 2012. 15. J. Franke, T. Kleinjung, F. Morain, and T. Wirth. Proving the primality of very large numbers with fastECPP. In D. A. Buell, editor, Algorithmic Number Theory – ANTS-VI, volume 3076 of Lecture Notes in Computer Science, pages 194–207. Springer, Heidelberg, 2004. 16. K. Gaj, S. Kwon, P. Baier, P. Kohlbrenner, H. Le, M. Khaleeluddin, and R. Bachimanchi. Implementing the elliptic curve method of factoring in reconfigurable hardware. In L. Goubin and M. Matsui, editors, Cryptographic Hardware and Embedded Systems – CHES 2006, volume 4249 of Lecture Notes in Computer Science, pages 119–133. Springer, Heidelberg, 2006. 17. T. Güneysu, T. Kasper, M. Novotny, C. Paar, and A. Rupp. Cryptanalysis with COPACOBANA. IEEE Transactions on Computers, 57:1498–1513, 2008. 18. R. Guy. Unsolved problems in number theory, volume 1. Springer Verlag, 3rd edition, 2004. 19. H. Hisil, K. K.-H. Wong, G. Carter, and E. Dawson. Twisted Edwards curves revisited. In J. Pieprzyk, editor, Asiacrypt 2008, volume 5350 of Lecture Notes in Computer Science, pages 326–343. Springer, Heidelberg, 2008. 20. T. Kleinjung, K. Aoki, J. Franke, A. K. Lenstra, E. Thomé, J. W. Bos, P. Gaudry, A. Kruppa, P. L. Montgomery, D. A. Osvik, H. te Riele, A. Timofeev, and P. Zimmermann. Factorization of a 768-bit RSA modulus. In T. Rabin, editor, Crypto 2010, volume 6223 of Lecture Notes in Computer Science, pages 333–350. Springer, Heidelberg, 2010. 21. A. Kruppa. A software implementation of ECM for NFS. Research Report RR-7041, INRIA, 2009. 22. A. K. Lenstra and H. W. Lenstra, Jr. Algorithms in number theory. In J. van Leeuwen, editor, Handbook of Theoretical Computer Science (Volume A: Algorithms and Complexity), pages 673–715. Elsevier and MIT Press, 1990. 23. A. K. Lenstra and H. W. Lenstra, Jr. The Development of the Number Field Sieve, volume 1554 of Lecture Notes in Mathematics. Springer-Verslag, 1993. 24. H. W. Lenstra Jr. Factoring integers with elliptic curves. Annals of Mathematics, 126(3):649–673, 1987. 25. D. Loebenberger and J. Putzka. Optimization strategies for hardware-based cofactorization. In M. J. Jacobson Jr., V. Rijmen, and R. Safavi-Naini, editors, Selected Areas in Cryptography, volume 5867 of Lecture Notes in Computer Science, pages 170–181. Springer, Heidelberg, 2009. 26. P. L. Montgomery. Speeding the Pollard and elliptic curve methods of factorization. Mathematics of Computation, 48(177):243–264, 1987. 27. P. L. Montgomery. An FFT extension of the elliptic curve method of factorization. PhD thesis, University of California, 1992. 28. F. Morain and J. Olivos. Speeding up the computations on an elliptic curve using addition-subtraction chains. Informatique Thèorique et Applications/Theoretical Informatics and Applications, 24:531–544, 1990. 29. NVIDIA. NVIDIA’s next generation CUDA compute architecture: Fermi, 2009. 30. NVIDIA. NVIDIA CUDA Programming Guide 3.2, 2010. 31. D. Pisinger. A minimal algorithm for the multiple-choice knapsack problem. European Journal of Operational Research, 83(2):394–410, June 1995. 32. J. M. Pollard. The lattice sieve. pages 43–49 in [23]. 33. J. M. Pollard. Theorems on factorization and primality testing. Proceedings of the Cambridge Philosophical Society, 76:521–528, 1974. 34. C. Pomerance. The quadratic sieve factoring algorithm. In T. Beth, N. Cot, and I. Ingemarsson, editors, Eurocrypt 1984, volume 209 of Lecture Notes in Computer Science, pages 169–182. Springer, Heidelberg, 1985. 35. A. Scholz. Aufgabe 253. Jahresbericht der deutschen Mathematiker-Vereingung, 47:41–42, 1937. 36. J. H. Silverman. The Arithmetic of Elliptic Curves, volume 106 of Gradute Texts in Mathematics. SpringerVerlag, 1986. 37. M. Šimka, J. Pelzl, T. Kleinjung, J. Franke, C. Priplata, C. Stahlke, M. Drutarovský, and V. Fischer. Hardware factorization based on elliptic curve method. In Field-Programmable Custom Computing Machines – FCCM 2005, pages 107–116. IEEE Computer Society, 2005. 38. E. G. Thurber. On addition chains l(mn) ≤ l(n) − b and lower bounds for c(r). Duke Mathematical Journal, 40:907–913, 1973.

ECM at Work


39. P. Zimmermann and B. Dodson. 20 years of ECM. In F. Hess, S. Pauli, and M. E. Pohst, editors, Algorithmic Number Theory – ANTS-VII, volume 4076 of Lecture Notes in Computer Science, pages 525– 542. Springer, Heidelberg, 2006. 40. R. Zimmermann, T. Güneysu, and C. Paar. High-performance integer factoring with reconfigurable devices. In Field Programmable Logic and Applications – FPL 2010, pages 83–88. IEEE, 2010. 41. P. Zimmermann et al. GMP-ECM (elliptic curve method for integer factorization). Software: https: //, 2012.