DOCSLIB.ORG

Implementation of the Quadratic Sieve

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Implementation of the Quadratic Sieve Page 1 of 28 Implementation of the Quadratic Sieve Mark Gordon Cryptography 475 November 30th, 2008 Introduction Finding the factorization of a number, n, is a computationally difficult problem that is at the heart of the security of the RSA encryption algorithm. The naïve solution, trial division, takes O(sqrt(n)) time and is ineffective for even moderately large n. The quadratic sieve offers an improvement on this algorithm and is currently the second asymptotically fastest algorithm for factoring integers. In this paper I present my implementation of the quadratic sieve and its results. The Quadratic Sieve The main idea behind the quadratic sieve is that if we have a and b such that a2=b2 (mod n) then we have a2-b2=n (mod n) which can be re-written as (a-b)(a+b)=n (mod n). Therefore we can take either a-b or a+b and test if it contains a non trivial factor of n using the Euclidean algorithm. One idea to find perfect squares is to find pairs (x, Q(x)), where Q(x) is x2-n (different polynomials are possible), and test if Q(x) is a perfect square. Note that x2=Q(x) mod n so if Q(x) happens to be a perfect square we have a congruence of squares which will allow us to factor n. Finding Squares Unfortunately there are very few x such that Q(x) will be a perfect square. An improvement on this concept would be to try and combine pairs (x, Q(x)) and (y, Q(y)) to yield (xy, Q(x)Q(y)). Note that the congruence (xy)2=Q(x)Q(y) mod n still holds so if it happens that Q(x)Q(y) is a perfect square we once again have a congruence of squares. If we view Q(x) as an exponent vector, Q(x) = p1v1*p2v2*...*pBvB, then Q(x) would be a perfect square if and only if every vi was even. Linear System Restating the problem at hand; we want to take the product of some subset of Q(xi) such that each exponent in the exponent vector is even. This is equivalent to saying we want to add some subset of vectors such that they sum to 0 modulo 2. This is the same Page 2 of 28 as saying we want to find a linear dependence between the vectors modulo 2 which can be solved easily with Gaussian Elimination. Factor Base Because there are a lot of primes that could divide Q(x) requiring us to collect a lot of pairs (x, Q(x)) (and because factoring is hard) it will help if we choose some factor base, F, such that we only collect pairs (x, Q(x)) such that Q(x) factors completely over F. With a restricted size on F we will only need to gather |F|+1 pairs to ensure that we will have a linear dependence and thus be able to generate congruent squares solving the factoring problem. Preparations In order to do anything with large integers a library for doing basic integer operations is required since native integer types on any processor have a fixed (small) size. To accomplish this I wrote a bigint class that stores the number it represents in the base 230 and handles all of the basic arithmetic operations (+, -, *, /, %) and comparisons one would expect. In addition to basic arithmetic the bigint library contains some other functions that were needed to implement the quadratic sieve. This includes: A square root function that computes the floor of the square root of a big integer. A gcd function for computing the greatest common divisor of two big integers using the Euclidean Algorithm. A modular exponentiation algorithm for raising be modulo m using repeated squaring. A modular inverse algorithm for computing x-1 modulo m using the Extended Euclidean Algorithm. A method for detecting if a number is probably prime using the Miller-Rabin probabilistic primality test. A method for generating random numbers of a fixed number of bits. A method for generating a random prime of a fixed number of bits. (This was useful for testing) Page 3 of 28 A method for computing the Legendre Symbol. This symbols tells you about the existence of square roots of a number modulo a prime. This was implemented as described in [4]. A method for computing the square root of a number modulo a prime. This uses the Shanks-Tonelli algorithm and is implemented as described in [3]. The Algorithm All of the previous preparation has been for the purpose of implementing the quadratic sieve which is located within the bigint::factor(bool) method in my implementation (Appendix B). In fact the factor method isn’t just the quadratic sieve as it tries trial division to remove small primes to start with, checks if the number is probably prime (and therefore has no factors), runs Pollard's Rho algorithm for a fixed number of iterations to try and get lucky and find some factors, and then finally moves on to the quadratic sieve. Computing the factor base The quadratic sieve starts out by calculating a factor base. The size of the factor base is calculated as B=2*esqrt(ln(n)ln(ln(n))/4 approximately as suggested in [1]. The elements of F are chosen as the first B primes that have a quadratic residue modulo n. The Sieve of Eratosthenes is used for quickly calculating primes and Legendre's symbol is checked to be 1. After calculating the factor base the square root of n modulo p is calculated for each p in F using the Shanks-Tonelli algorithm. This square root is useful because it allow us to find up to two x's such that Q(x) is divisible by p. Then this can be used, together with the fact that Q(x) = Q(x + p) (mod p), to find two arithmetic progressions that represent all x's such that p divides Q(x). Sieving Now we're ready to sieve. Traditionally sieving is done by selecting some sieving interval and dividing out the largest power of each prime p from each element in the arithmetic progressions associated with that prime within the sieving interval. If at the end of sieving an element is 1 then the associated Q(x) is factorable over the factor base. Page 4 of 28 Instead of doing that I chose to start at x=1+floor(sqrt(n)) and just keep going forward iteratively. To tell what primes should be divided out of Q(x) I instead keep a heap that tracks what primes will be appearing next. The main advantages to this approach are that I don't need tons of extra memory, I don't have to try and guess the size of the sieving interval, and I can get pairs (x, Q(x)) early and test for linear dependencies as I go. However these advantages come at a slight cost to runtime due to the heap operations. Gaussian Elimination Unlike the approach described in [1], I search for linear dependencies as I find new pairs. This usually reduces the number of pairs required but the cut is not substantial. The search for linear dependencies is just done using Gaussian elimination optimized for sparse matrices. The elimination is done carefully enough so that the actual subset of pairs can be reconstructed that formed a linear dependence. Constructing a Solution After finding the subset of pairs that creates the linear dependence we can calculate a and b such that a2=b2 (mod n). a will be calculated as the product of each of xi modulo n in the selected pairs. Then b can be computed by calculating the exponent vector of the product of each Q(xi) and halving each exponent. Finally we can take gcd(a – b, n) and gcd(a + b, n) to try and find a non trivial factor of n. Double Large Primes In addition to tracking pairs (x, Q(x)) that factor completely over the factor base I also track when Q(x) almost factors over the factor base save one large prime L. In this case I check if I’ve seen any other pair (y, Q(y)) such that Q(y) factors over the factor base except for L. If this is the case I combine the pairs and form a pair (x*y, Q(x)*Q(y)) . Now Q(x) * Q(y) factor entirely over the factor base except for an L2 term which I can remember is there when I try to calculate the square root of the products of the subset of Q(xi). Since there may be many of these large-prime Q(x) only R pairs with the smallest associated L are kept in memory where R was selected to be 10,000,000. Performance To test the effectiveness and correctness of my implementation of the quadratic sieve I generated two probable primes p and q and fed p * q to my factoring algorithm. Below is a table of the performance of my quadratic sieve on different sizes of p * q. Note that the quadratic sieve does not change Page 5 of 28 Size of p * Time to Factor (x, Q(x)) q (bits) factor base size pairs needed 160 2 hours 6454 6288 21 minutes 144 7 minutes 3650 3910 13 seconds 128 5 minutes 2313 2114 16 seconds 112 39 1280 1096 seconds 96 33 368 350.7 seconds Known bugs Additionally there appear to be some bugs implementation bugs present when large semi-primes are tested.
Load more

Recommended publications
  • The Quadratic Sieve - Introduction to Theory with Regard to Implementation Issues
    The Quadratic Sieve - introduction to theory with regard to implementation issues RNDr. Marian Kechlibar, Ph.D. April 15, 2005 Contents I The Quadratic Sieve 3 1 Introduction 4 1.1 The Quadratic Sieve - short description . 5 1.1.1 Polynomials and relations . 5 1.1.2 Smooth and partial relations . 7 1.1.3 The Double Large Prime Variation . 8 1.1.4 Problems to solve . 10 2 Quadratic Sieve Implementation 12 2.1 The Factor Base . 12 2.2 The sieving process . 15 2.2.1 Interval sieving and solution of polynomials . 16 2.2.2 Practical implementation . 16 2.3 Generation of polynomials . 17 2.3.1 Desirable properties of polynomials . 17 2.3.2 Assessment of magnitude of coecients . 18 2.3.3 MPQS - The Silverman Method . 20 2.3.4 SIQS principle . 21 2.3.5 Desirable properties of b . 22 2.3.6 SIQS - Generation of the Bi's . 23 2.3.7 Generation of b with Gray code formulas . 24 2.3.8 SIQS - General remarks on a determination . 26 2.3.9 SIQS - The bit method for a coecient . 27 2.3.10 SIQS - The Carrier-Wagsta method for a coecient . 28 2.4 Combination of the relations, partial relations and linear algebra 30 2.5 Linear algebra step . 31 2.6 The Singleton Gap . 32 1 3 Experimental Results 36 3.1 Sieving speed - dependence on FB size . 36 3.2 Sieving speed - dependence on usage of 1-partials . 38 3.3 Singletons - dependence on log(N) and FB size . 39 3.4 Properties of the sieving matrices .
    [Show full text]
  • The Quadratic Sieve Factoring Algorithm
    The Quadratic Sieve Factoring Algorithm Eric Landquist MATH 488: Cryptographic Algorithms December 14, 2001 1 1 Introduction Mathematicians have been attempting to find better and faster ways to fac- tor composite numbers since the beginning of time. Initially this involved dividing a number by larger and larger primes until you had the factoriza- tion. This trial division was not improved upon until Fermat applied the factorization of the difference of two squares: a2 b2 = (a b)(a + b). In his method, we begin with the number to be factored:− n. We− find the smallest square larger than n, and test to see if the difference is square. If so, then we can apply the trick of factoring the difference of two squares to find the factors of n. If the difference is not a perfect square, then we find the next largest square, and repeat the process. While Fermat's method is much faster than trial division, when it comes to the real world of factoring, for example factoring an RSA modulus several hundred digits long, the purely iterative method of Fermat is too slow. Sev- eral other methods have been presented, such as the Elliptic Curve Method discovered by H. Lenstra in 1987 and a pair of probabilistic methods by Pollard in the mid 70's, the p 1 method and the ρ method. The fastest algorithms, however, utilize the− same trick as Fermat, examples of which are the Continued Fraction Method, the Quadratic Sieve (and it variants), and the Number Field Sieve (and its variants). The exception to this is the El- liptic Curve Method, which runs almost as fast as the Quadratic Sieve.
    [Show full text]
  • Sieve Algorithms for the Discrete Logarithm in Medium Characteristic Finite Fields Laurent Grémy
    Sieve algorithms for the discrete logarithm in medium characteristic finite fields Laurent Grémy To cite this version: Laurent Grémy. Sieve algorithms for the discrete logarithm in medium characteristic finite fields. Cryptography and Security [cs.CR]. Université de Lorraine, 2017. English. NNT : 2017LORR0141. tel-01647623 HAL Id: tel-01647623 https://tel.archives-ouvertes.fr/tel-01647623 Submitted on 24 Nov 2017 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. AVERTISSEMENT Ce document est le fruit d'un long travail approuvé par le jury de soutenance et mis à disposition de l'ensemble de la communauté universitaire élargie. Il est soumis à la propriété intellectuelle de l'auteur. Ceci implique une obligation de citation et de référencement lors de l’utilisation de ce document. D'autre part, toute contrefaçon, plagiat, reproduction illicite encourt une poursuite pénale. Contact : [email protected] LIENS Code de la Propriété Intellectuelle. articles L 122. 4 Code de la Propriété Intellectuelle. articles L 335.2- L 335.10 http://www.cfcopies.com/V2/leg/leg_droi.php
    [Show full text]
  • The RSA Algorithm Clifton Paul Robinson
    Bridgewater State University Virtual Commons - Bridgewater State University Honors Program Theses and Projects Undergraduate Honors Program 5-1-2018 The Key to Cryptography: The RSA Algorithm Clifton Paul Robinson Follow this and additional works at: http://vc.bridgew.edu/honors_proj Part of the Computer Sciences Commons Recommended Citation Robinson, Clifton Paul. (2018). The Key ot Cryptography: The RSA Algorithm. In BSU Honors Program Theses and Projects. Item 268. Available at: http://vc.bridgew.edu/honors_proj/268 Copyright © 2018 Clifton Paul Robinson This item is available as part of Virtual Commons, the open-access institutional repository of Bridgewater State University, Bridgewater, Massachusetts. The Key to Cryptography: The RSA Algorithm Clifton Paul Robinson Submitted in Partial Completion of the Requirements for Commonwealth Interdisciplinary Honors in Computer Science and Mathematics Bridgewater State University May 1, 2018 Dr. Jacqueline Anderson Thesis Co-Advisor Dr. Michael Black, Thesis Co-Advisor Dr. Ward Heilman, Committee Member Dr. Haleh Khojasteh, Committee Member BRIDGEWATER STATE UNIVERSITY UNDERGRADUATE THESIS The Key To Cryptography: The RSA Algorithm Author: Advisors: Clifton Paul ROBINSON Dr. Jackie ANDERSON Dr. Michael BLACK Submitted in Partial Completion of the Requirements for Commonwealth Honors in Computer Science and Mathematics Dr. Ward Heilman, Reading Committee Dr. Haleh Khojasteh, Reading Committee ii Dedicated to Mom, Dad, James, and Mimi iii Contents Abstractv 1 Introduction1 1.1 The Project Overview........................1 2 Theorems and Definitions2 2.1 Definitions..............................2 2.2 Theorems...............................5 3 The History of Cryptography6 3.1 Origins................................6 3.2 A Transition.............................6 3.3 Cryptography at War........................7 3.4 The Creation and Uses of RSA...................7 4 The Mathematics9 4.1 What is a Prime Number?.....................9 4.2 Factoring Numbers........................
    [Show full text]
  • Integer Factorization and Computing Discrete Logarithms in Maple
    Integer Factorization and Computing Discrete Logarithms in Maple Aaron Bradford∗, Michael Monagan∗, Colin Percival∗ [email protected], [email protected], [email protected] Department of Mathematics, Simon Fraser University, Burnaby, B.C., V5A 1S6, Canada. 1 Introduction As part of our MITACS research project at Simon Fraser University, we have investigated algorithms for integer factorization and computing discrete logarithms. We have implemented a quadratic sieve algorithm for integer factorization in Maple to replace Maple's implementation of the Morrison- Brillhart continued fraction algorithm which was done by Gaston Gonnet in the early 1980's. We have also implemented an indexed calculus algorithm for discrete logarithms in GF(q) to replace Maple's implementation of Shanks' baby-step giant-step algorithm, also done by Gaston Gonnet in the early 1980's. In this paper we describe the algorithms and our optimizations made to them. We give some details of our Maple implementations and present some initial timings. Since Maple is an interpreted language, see [7], there is room for improvement of both implementations by coding critical parts of the algorithms in C. For example, one of the bottle-necks of the indexed calculus algorithm is finding and integers which are B-smooth. Let B be a set of primes. A positive integer y is said to be B-smooth if its prime divisors are all in B. Typically B might be the first 200 primes and y might be a 50 bit integer. ∗This work was supported by the MITACS NCE of Canada. 1 2 Integer Factorization Starting from some very simple instructions | \make integer factorization faster in Maple" | we have implemented the Quadratic Sieve factoring al- gorithm in a combination of Maple and C (which is accessed via Maple's capabilities for external linking).
    [Show full text]
  • On the Number Field Sieve: Polynomial Selection and Smooth Elements in Number Fields
    On the Number Field Sieve: Polynomial Selection and Smooth Elements in Number Fields Nicholas Vincent Coxon BSc (hons) A thesis submitted for the degree of Doctor of Philosophy at The University of Queensland in June 2012 School of Mathematics and Physics Abstract The number field sieve is the asymptotically fastest known algorithm for factoring large integers that are free of small prime factors. Two aspects of the algorithm are considered in this thesis: polynomial selection and smooth elements in number fields. The contributions to polynomial selection are twofold. First, existing methods of polynomial generation, namely those based on Montgomery's method, are extended and tools developed to aid in their analysis. Second, a new approach to polynomial generation is developed and realised. The development of the approach is driven by results obtained on the divisibility properties of univariate resultants. Examples from the literature point toward the utility of applying decoding algorithms for algebraic error-correcting codes to problems of finding elements in a ring with a smooth representation. In this thesis, the problem of finding algebraic integers in a number field with smooth norm is reformulated as a decoding problem for a family of error-correcting codes called NF-codes. An algorithm for solving the weighted list decoding problem for NF-codes is provided. The algorithm is then used to find algebraic integers with norm containing a large smooth factor. Bounds on the existence of such numbers are derived using algorithmic and combinatorial methods. ii Declaration by the Author This thesis is composed of my original work, and contains no material previously published or written by another person except where due reference has been made in the text.
    [Show full text]
  • Factoring and Discrete Log
    Factoring and Discrete Log Nadia Heninger University of Pennsylvania June 1, 2015 Textbook RSA [Rivest Shamir Adleman 1977] Public Key Private Key N = pq modulus p; q primes e encryption exponent d decryption exponent (d = e−1 mod (p − 1)(q − 1)) Encryption public key = (N; e) ciphertext = messagee mod N message = ciphertextd mod N Textbook RSA [Rivest Shamir Adleman 1977] Public Key Private Key N = pq modulus p; q primes e encryption exponent d decryption exponent (d = e−1 mod (p − 1)(q − 1)) Signing public key = (N; e) signature = messaged mod N message = signaturee mod N Computational problems Factoring Problem: Given N, compute its prime factors. I Computationally equivalent to computing private key d. I Factoring is in NP and coNP ! not NP-complete (unless P=NP or similar). Computational problems eth roots mod N Problem: Given N, e, and c, compute x such that xe ≡ c mod N. I Equivalent to decrypting an RSA-encrypted ciphertext. I Equivalent to selective forgery of RSA signatures. I Conflicting results about whether it reduces to factoring: I \Breaking RSA may not be equivalent to factoring" [Boneh Venkatesan 1998] \an algebraic reduction from factoring to breaking low-exponent RSA can be converted into an efficient factoring algorithm" I \Breaking RSA generically is equivalent to factoring" [Aggarwal Maurer 2009] \a generic ring algorithm for breaking RSA in ZN can be converted into an algorithm for factoring" I \RSA assumption": This problem is hard. A garden of attacks on textbook RSA Unpadded RSA encryption is homomorphic under multiplication. Let's have some fun! Attack: Malleability Given a ciphertext c = Enc(m) = me mod N, attacker can forge ciphertext Enc(ma) = cae mod N for any a.
    [Show full text]
  • Factoring Integers with a Brain-Inspired Computer John V
    IEEE TRANSACTIONS ON CIRCUITS AND SYSTEMS—I: REGULAR PAPERS 1 Factoring Integers with a Brain-Inspired Computer John V. Monaco and Manuel M. Vindiola Abstract—The bound to factor large integers is dominated • Constant-time synaptic integration: a single neuron in the by the computational effort to discover numbers that are B- brain may receive electrical potential inputs along synap- smooth, i.e., integers whose largest prime factor does not exceed tic connections from thousands of other neurons. The B. Smooth numbers are traditionally discovered by sieving a polynomial sequence, whereby the logarithmic sum of prime incoming potentials are continuously and instantaneously factors of each polynomial value is compared to a threshold. integrated to compute the neuron’s membrane potential. On a von Neumann architecture, this requires a large block of Like the brain, neuromorphic architectures aim to per- memory for the sieving interval and frequent memory updates, form synaptic integration in constant time, typically by resulting in O(ln ln B) amortized time complexity to check each leveraging physical properties of the underlying device. value for smoothness. This work presents a neuromorphic sieve that achieves a constant-time check for smoothness by reversing Unlike the traditional CPU-based sieve, the factor base is rep- the roles of space and time from the von Neumann architecture resented in space (as spiking neurons) and the sieving interval and exploiting two characteristic properties of brain-inspired in time (as successive time steps). Sieving is performed by computation: massive parallelism and constant time synaptic integration. The effects on sieving performance of two common a population of leaky integrate-and-fire (LIF) neurons whose neuromorphic architectural constraints are examined: limited dynamics are simple enough to be implemented on a range synaptic weight resolution, which forces the factor base to be of current and future architectures.
    [Show full text]
  • Note to Users
    NOTE TO USERS This reproduction is the best copy available. UMI A SURVEY OF RESULTS ON GIUGA'S CONJECTURE AND RELATED CONJECTURES by Joseph R. Hobart BSc., University of Northern British Columbia, 2004 THESIS SUBMITTED IN PARTIAL FULFILLMENT OF THE REQUIREMENTS FOR THE DEGREE OF MASTER OF SCIENCE in MATHEMATICAL, COMPUTER AND PHYSICAL SCIENCES (MATHEMATICS) THE UNIVERSITY OF NORTHERN BRITISH COLUMBIA July 2005 © Joseph R. Hobart, 2005 Library and Bibliothèque et 1 ^ 1 Archives Canada Archives Canada Published Heritage Direction du Branch Patrimoine de l'édition 395 Wellington Street 395, rue Wellington Ottawa ON K1A0N4 Ottawa ON K1A0N4 Canada Canada Your file Votre référence ISBN: 978-0-494-28392-9 Our file Notre référence ISBN: 978-0-494-28392-9 NOTICE: AVIS: The author has granted a non­ L'auteur a accordé une licence non exclusive exclusive license allowing Library permettant à la Bibliothèque et Archives and Archives Canada to reproduce,Canada de reproduire, publier, archiver, publish, archive, preserve, conserve,sauvegarder, conserver, transmettre au public communicate to the public by par télécommunication ou par l'Internet, prêter, telecommunication or on the Internet,distribuer et vendre des thèses partout dans loan, distribute and sell theses le monde, à des fins commerciales ou autres, worldwide, for commercial or non­ sur support microforme, papier, électronique commercial purposes, in microform,et/ou autres formats. paper, electronic and/or any other formats. The author retains copyright L'auteur conserve la propriété du droit d'auteur ownership and moral rights in et des droits moraux qui protège cette thèse. this thesis. Neither the thesis Ni la thèse ni des extraits substantiels de nor substantial extracts from it celle-ci ne doivent être imprimés ou autrement may be printed or otherwise reproduits sans son autorisation.
    [Show full text]
  • Dixon's Factorization Method
    Dixon's Factorization method Nikithkumarreddy yellu December 2015 1 Contents 1 Introduction 3 2 History 3 3 Method 4 3.1 Factor-base . 4 3.2 B-smooth . 4 4 Examples 5 4.1 Example1 . 5 4.2 Example2 . 5 5 Algorithm 6 6 Optimizations 6 7 Conclusion 7 2 1 Introduction Dixon's Factorization method is an integer factorization algorithm. It is the prototypical factor method. The only factor base method for which a run-time bound not dependent on conjectures about the smoothness properties of values of a polynomial is known. Dixon's technology depends on discovering a congru- ence of squares modulo the integer.[2] Using Fermat's factorization algorithm we can find a congruence by selecting a pseudo-random x values and hoping that x2modN is a perfect square. Dixon's algorithm tries to find x and y efficiently by computing x; yZn such 2 2 1 that x ≡ y (modN) : Then with probability ≥ 2 , x 6≡ ±y (modN), hence gcd 1 (x − y; n) produces a factor of n with probability ≥ 2 : 2 History In 1981, John D. Dixon, a mathematician at Carleton University,[3] developed the integer factorization method that bears his name. Dixon's algorithm is not used in practice, because it is quite slow, but it is important in the realm of number theory because it is the only sub-exponential factoring algorithm with a deterministic (not conjectured) run time, and it is the precursor to the quadratic sieve factorization algorithm, which is eminently practical. This approach was discovered by Micheal Morrison and John Brillhart and published in 1975.
    [Show full text]
  • Implementing and Comparing Integer Factorization Algorithms
    Implementing and Comparing Integer Factorization Algorithms Jacqueline Speiser jspeiser p Abstract by choosing B = exp( logN loglogN)) and let the factor base be the set of all primes smaller than B. Next, Integer factorization is an important problem in modern search for positive integers x such that x2 mod N is B- cryptography as it is the basis of RSA encryption. I have smooth, meaning that all the factors of x2 are in the factor implemented two integer factorization algorithms: Pol- 2 e1 e2 ek base. For all B-smooth numbers xi = p p ::: p , lard’s rho algorithm and Dixon’s factorization method. 2 record (xi ;~ei). After we have enough of these relations, While the results are not revolutionary, they illustrate we can solve a system of linear equations to find some the software design difficulties inherent to integer fac- subset of the relations such that ∑~ei =~0 mod 2. (See the torization. The code for this project is available at Implementation section for details on how this is done.) https://github.com/jspeiser/factoring. Note that if k is the size of our factor base, then we only need k + 1 relations to guarantee that such a solution 1 Introduction exists. We have now found a congruence of squares, 2 2 2 ∑i ei1 ∑i eik a = xi and b = p1 ::: pk . This implies that The integer factorization problem is defined as follows: (a + b)(a − b) = 0 mod N, which means that there is a given a composite number N, find two integers x and y 50% chance that gcd(a−b;N) factorspN.
    [Show full text]
  • Integer Factoring
    Designs, Codes and Cryptography, 19, 101–128 (2000) c 2000 Kluwer Academic Publishers, Boston. Manufactured in The Netherlands. Integer Factoring ARJEN K. LENSTRA [email protected] Citibank, N.A., 1 North Gate Road, Mendham, NJ 07945-3104, USA Abstract. Using simple examples and informal discussions this article surveys the key ideas and major advances of the last quarter century in integer factorization. Keywords: Integer factorization, quadratic sieve, number field sieve, elliptic curve method, Morrison–Brillhart Approach 1. Introduction Factoring a positive integer n means finding positive integers u and v such that the product of u and v equals n, and such that both u and v are greater than 1. Such u and v are called factors (or divisors)ofn, and n = u v is called a factorization of n. Positive integers that can be factored are called composites. Positive integers greater than 1 that cannot be factored are called primes. For example, n = 15 can be factored as the product of the primes u = 3 and v = 5, and n = 105 can be factored as the product of the prime u = 7 and the composite v = 15. A factorization of a composite number is not necessarily unique: n = 105 can also be factored as the product of the prime u = 5 and the composite v = 21. But the prime factorization of a number—writing it as a product of prime numbers—is unique, up to the order of the factors: n = 3 5 7isthe prime factorization of n = 105, and n = 5 is the prime factorization of n = 5.
    [Show full text]