What is the fastest integer factorization to break RSA?












1












$begingroup$


I read on Wikipedia, the fastest Algorithm for breaking RSA is GNFS.



And in one IEEE paper (MVFactor: A method to decrease processing time for factorization algorithm), I read the fastest algorithms are TDM, FFM and VFactor.



Which of these is actually right?










share|improve this question









New contributor




user56036 is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.







$endgroup$

















    1












    $begingroup$


    I read on Wikipedia, the fastest Algorithm for breaking RSA is GNFS.



    And in one IEEE paper (MVFactor: A method to decrease processing time for factorization algorithm), I read the fastest algorithms are TDM, FFM and VFactor.



    Which of these is actually right?










    share|improve this question









    New contributor




    user56036 is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
    Check out our Code of Conduct.







    $endgroup$















      1












      1








      1





      $begingroup$


      I read on Wikipedia, the fastest Algorithm for breaking RSA is GNFS.



      And in one IEEE paper (MVFactor: A method to decrease processing time for factorization algorithm), I read the fastest algorithms are TDM, FFM and VFactor.



      Which of these is actually right?










      share|improve this question









      New contributor




      user56036 is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.







      $endgroup$




      I read on Wikipedia, the fastest Algorithm for breaking RSA is GNFS.



      And in one IEEE paper (MVFactor: A method to decrease processing time for factorization algorithm), I read the fastest algorithms are TDM, FFM and VFactor.



      Which of these is actually right?







      factoring






      share|improve this question









      New contributor




      user56036 is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.











      share|improve this question









      New contributor




      user56036 is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.









      share|improve this question




      share|improve this question








      edited 54 mins ago









      kelalaka

      8,60522351




      8,60522351






      New contributor




      user56036 is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.









      asked 2 hours ago









      user56036user56036

      61




      61




      New contributor




      user56036 is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.





      New contributor





      user56036 is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.






      user56036 is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.






















          3 Answers
          3






          active

          oldest

          votes


















          3












          $begingroup$

          The IEEE paper is silly.



          The factorization method they give is quite slow, except for rare cases. For example, in their table 1, where they proudly show that their improved algorithm takes 653.14 seconds to factor a 67 bit number; well, I just tried it using a more conventional algorithm, and it took 6msec; yes, that's 100,000 times as fast...






          share|improve this answer









          $endgroup$









          • 1




            $begingroup$
            Well I think the point of the paper is to improve upon Fermat-Factoring class algorithms, so it is expected that the given algorithm(s) get beaten by the more standard ones for small sizes, but excel on large inputs with (relatively small) prime differences?
            $endgroup$
            – SEJPM
            1 hour ago










          • $begingroup$
            @SEJPM: if that's the case, then they probably shouldn't go on so much about RSA (where the probability of having a sufficiently small difference is tiny)
            $endgroup$
            – poncho
            1 hour ago



















          2












          $begingroup$


          Which of these is actually right?




          Both. From reading the abstract it appears the papper doesn't claim that "VFactor" or Fermat Factorization ("FFM") or Trial Division ("TDM") are the best methods in general. However, if the difference between primes $p,q$ with $n=pq$ is really small, like $ll2^{100}$$;dagger$, then FFM (and probably the VFactor variants as well) will be a lot faster.



          Though in general the difference between two same-length random primes is about $sqrt{n}/2$ which is about $2^{1024}$ for realistically sized moduli, so these attacks don't work there. Even with 400-bit moduli, which are somewhat easily crackable using a home desktop using the GNFS, this difference is still about $2^{200}$ and thus way too large.



          Of course the implementation of the key generation may be faulty and emit primes in a too small interval and it's in these cases where these specialized algorithms really shine.



          $dagger$: "$ll$" meaning "a lot less" here






          share|improve this answer









          $endgroup$





















            2












            $begingroup$

            Quantum algorithms



            There is of course Shor's algorithm, but as this algorithm only runs on quantum computers with a lot of qubits it's not capable to factor larger numbers than $21$ (reference).



            There are multiple apparent new records using adiabatic quantum computation, although some are apparently stunts: See fgrieu's answer on a related question.



            Classical algorithms



            The general number field sieve is the fastest known classical algorithm for factoring numbers over $10^{100}$.



            The Quadratic sieve algorithm is the fastest known classical algorithm for factoring numbers under $10^{100}$.






            share|improve this answer











            $endgroup$









            • 2




              $begingroup$
              Actually, the factorization of 56153 was a stunt; the factors were deliberately chosen to have a special relation (differed in only 2 bits) and it's easy to factor when the factors have a known relation. AFAIK, the largest number that has been factored to date using a generic quantum factorization algorithm is 21.
              $endgroup$
              – poncho
              1 hour ago












            • $begingroup$
              I've always wondered why QS is (at least, consensually said to be) faster than GNFS below a certain thresold (not so consensual), and how much of that is due to lack of work on optimizing GNFS for smaller values.
              $endgroup$
              – fgrieu
              1 hour ago












            Your Answer





            StackExchange.ifUsing("editor", function () {
            return StackExchange.using("mathjaxEditing", function () {
            StackExchange.MarkdownEditor.creationCallbacks.add(function (editor, postfix) {
            StackExchange.mathjaxEditing.prepareWmdForMathJax(editor, postfix, [["$", "$"], ["\\(","\\)"]]);
            });
            });
            }, "mathjax-editing");

            StackExchange.ready(function() {
            var channelOptions = {
            tags: "".split(" "),
            id: "281"
            };
            initTagRenderer("".split(" "), "".split(" "), channelOptions);

            StackExchange.using("externalEditor", function() {
            // Have to fire editor after snippets, if snippets enabled
            if (StackExchange.settings.snippets.snippetsEnabled) {
            StackExchange.using("snippets", function() {
            createEditor();
            });
            }
            else {
            createEditor();
            }
            });

            function createEditor() {
            StackExchange.prepareEditor({
            heartbeatType: 'answer',
            autoActivateHeartbeat: false,
            convertImagesToLinks: false,
            noModals: true,
            showLowRepImageUploadWarning: true,
            reputationToPostImages: null,
            bindNavPrevention: true,
            postfix: "",
            imageUploader: {
            brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
            contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
            allowUrls: true
            },
            noCode: true, onDemand: true,
            discardSelector: ".discard-answer"
            ,immediatelyShowMarkdownHelp:true
            });


            }
            });






            user56036 is a new contributor. Be nice, and check out our Code of Conduct.










            draft saved

            draft discarded


















            StackExchange.ready(
            function () {
            StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcrypto.stackexchange.com%2fquestions%2f68480%2fwhat-is-the-fastest-integer-factorization-to-break-rsa%23new-answer', 'question_page');
            }
            );

            Post as a guest















            Required, but never shown

























            3 Answers
            3






            active

            oldest

            votes








            3 Answers
            3






            active

            oldest

            votes









            active

            oldest

            votes






            active

            oldest

            votes









            3












            $begingroup$

            The IEEE paper is silly.



            The factorization method they give is quite slow, except for rare cases. For example, in their table 1, where they proudly show that their improved algorithm takes 653.14 seconds to factor a 67 bit number; well, I just tried it using a more conventional algorithm, and it took 6msec; yes, that's 100,000 times as fast...






            share|improve this answer









            $endgroup$









            • 1




              $begingroup$
              Well I think the point of the paper is to improve upon Fermat-Factoring class algorithms, so it is expected that the given algorithm(s) get beaten by the more standard ones for small sizes, but excel on large inputs with (relatively small) prime differences?
              $endgroup$
              – SEJPM
              1 hour ago










            • $begingroup$
              @SEJPM: if that's the case, then they probably shouldn't go on so much about RSA (where the probability of having a sufficiently small difference is tiny)
              $endgroup$
              – poncho
              1 hour ago
















            3












            $begingroup$

            The IEEE paper is silly.



            The factorization method they give is quite slow, except for rare cases. For example, in their table 1, where they proudly show that their improved algorithm takes 653.14 seconds to factor a 67 bit number; well, I just tried it using a more conventional algorithm, and it took 6msec; yes, that's 100,000 times as fast...






            share|improve this answer









            $endgroup$









            • 1




              $begingroup$
              Well I think the point of the paper is to improve upon Fermat-Factoring class algorithms, so it is expected that the given algorithm(s) get beaten by the more standard ones for small sizes, but excel on large inputs with (relatively small) prime differences?
              $endgroup$
              – SEJPM
              1 hour ago










            • $begingroup$
              @SEJPM: if that's the case, then they probably shouldn't go on so much about RSA (where the probability of having a sufficiently small difference is tiny)
              $endgroup$
              – poncho
              1 hour ago














            3












            3








            3





            $begingroup$

            The IEEE paper is silly.



            The factorization method they give is quite slow, except for rare cases. For example, in their table 1, where they proudly show that their improved algorithm takes 653.14 seconds to factor a 67 bit number; well, I just tried it using a more conventional algorithm, and it took 6msec; yes, that's 100,000 times as fast...






            share|improve this answer









            $endgroup$



            The IEEE paper is silly.



            The factorization method they give is quite slow, except for rare cases. For example, in their table 1, where they proudly show that their improved algorithm takes 653.14 seconds to factor a 67 bit number; well, I just tried it using a more conventional algorithm, and it took 6msec; yes, that's 100,000 times as fast...







            share|improve this answer












            share|improve this answer



            share|improve this answer










            answered 1 hour ago









            ponchoponcho

            93.5k2146243




            93.5k2146243








            • 1




              $begingroup$
              Well I think the point of the paper is to improve upon Fermat-Factoring class algorithms, so it is expected that the given algorithm(s) get beaten by the more standard ones for small sizes, but excel on large inputs with (relatively small) prime differences?
              $endgroup$
              – SEJPM
              1 hour ago










            • $begingroup$
              @SEJPM: if that's the case, then they probably shouldn't go on so much about RSA (where the probability of having a sufficiently small difference is tiny)
              $endgroup$
              – poncho
              1 hour ago














            • 1




              $begingroup$
              Well I think the point of the paper is to improve upon Fermat-Factoring class algorithms, so it is expected that the given algorithm(s) get beaten by the more standard ones for small sizes, but excel on large inputs with (relatively small) prime differences?
              $endgroup$
              – SEJPM
              1 hour ago










            • $begingroup$
              @SEJPM: if that's the case, then they probably shouldn't go on so much about RSA (where the probability of having a sufficiently small difference is tiny)
              $endgroup$
              – poncho
              1 hour ago








            1




            1




            $begingroup$
            Well I think the point of the paper is to improve upon Fermat-Factoring class algorithms, so it is expected that the given algorithm(s) get beaten by the more standard ones for small sizes, but excel on large inputs with (relatively small) prime differences?
            $endgroup$
            – SEJPM
            1 hour ago




            $begingroup$
            Well I think the point of the paper is to improve upon Fermat-Factoring class algorithms, so it is expected that the given algorithm(s) get beaten by the more standard ones for small sizes, but excel on large inputs with (relatively small) prime differences?
            $endgroup$
            – SEJPM
            1 hour ago












            $begingroup$
            @SEJPM: if that's the case, then they probably shouldn't go on so much about RSA (where the probability of having a sufficiently small difference is tiny)
            $endgroup$
            – poncho
            1 hour ago




            $begingroup$
            @SEJPM: if that's the case, then they probably shouldn't go on so much about RSA (where the probability of having a sufficiently small difference is tiny)
            $endgroup$
            – poncho
            1 hour ago











            2












            $begingroup$


            Which of these is actually right?




            Both. From reading the abstract it appears the papper doesn't claim that "VFactor" or Fermat Factorization ("FFM") or Trial Division ("TDM") are the best methods in general. However, if the difference between primes $p,q$ with $n=pq$ is really small, like $ll2^{100}$$;dagger$, then FFM (and probably the VFactor variants as well) will be a lot faster.



            Though in general the difference between two same-length random primes is about $sqrt{n}/2$ which is about $2^{1024}$ for realistically sized moduli, so these attacks don't work there. Even with 400-bit moduli, which are somewhat easily crackable using a home desktop using the GNFS, this difference is still about $2^{200}$ and thus way too large.



            Of course the implementation of the key generation may be faulty and emit primes in a too small interval and it's in these cases where these specialized algorithms really shine.



            $dagger$: "$ll$" meaning "a lot less" here






            share|improve this answer









            $endgroup$


















              2












              $begingroup$


              Which of these is actually right?




              Both. From reading the abstract it appears the papper doesn't claim that "VFactor" or Fermat Factorization ("FFM") or Trial Division ("TDM") are the best methods in general. However, if the difference between primes $p,q$ with $n=pq$ is really small, like $ll2^{100}$$;dagger$, then FFM (and probably the VFactor variants as well) will be a lot faster.



              Though in general the difference between two same-length random primes is about $sqrt{n}/2$ which is about $2^{1024}$ for realistically sized moduli, so these attacks don't work there. Even with 400-bit moduli, which are somewhat easily crackable using a home desktop using the GNFS, this difference is still about $2^{200}$ and thus way too large.



              Of course the implementation of the key generation may be faulty and emit primes in a too small interval and it's in these cases where these specialized algorithms really shine.



              $dagger$: "$ll$" meaning "a lot less" here






              share|improve this answer









              $endgroup$
















                2












                2








                2





                $begingroup$


                Which of these is actually right?




                Both. From reading the abstract it appears the papper doesn't claim that "VFactor" or Fermat Factorization ("FFM") or Trial Division ("TDM") are the best methods in general. However, if the difference between primes $p,q$ with $n=pq$ is really small, like $ll2^{100}$$;dagger$, then FFM (and probably the VFactor variants as well) will be a lot faster.



                Though in general the difference between two same-length random primes is about $sqrt{n}/2$ which is about $2^{1024}$ for realistically sized moduli, so these attacks don't work there. Even with 400-bit moduli, which are somewhat easily crackable using a home desktop using the GNFS, this difference is still about $2^{200}$ and thus way too large.



                Of course the implementation of the key generation may be faulty and emit primes in a too small interval and it's in these cases where these specialized algorithms really shine.



                $dagger$: "$ll$" meaning "a lot less" here






                share|improve this answer









                $endgroup$




                Which of these is actually right?




                Both. From reading the abstract it appears the papper doesn't claim that "VFactor" or Fermat Factorization ("FFM") or Trial Division ("TDM") are the best methods in general. However, if the difference between primes $p,q$ with $n=pq$ is really small, like $ll2^{100}$$;dagger$, then FFM (and probably the VFactor variants as well) will be a lot faster.



                Though in general the difference between two same-length random primes is about $sqrt{n}/2$ which is about $2^{1024}$ for realistically sized moduli, so these attacks don't work there. Even with 400-bit moduli, which are somewhat easily crackable using a home desktop using the GNFS, this difference is still about $2^{200}$ and thus way too large.



                Of course the implementation of the key generation may be faulty and emit primes in a too small interval and it's in these cases where these specialized algorithms really shine.



                $dagger$: "$ll$" meaning "a lot less" here







                share|improve this answer












                share|improve this answer



                share|improve this answer










                answered 1 hour ago









                SEJPMSEJPM

                29.3k659139




                29.3k659139























                    2












                    $begingroup$

                    Quantum algorithms



                    There is of course Shor's algorithm, but as this algorithm only runs on quantum computers with a lot of qubits it's not capable to factor larger numbers than $21$ (reference).



                    There are multiple apparent new records using adiabatic quantum computation, although some are apparently stunts: See fgrieu's answer on a related question.



                    Classical algorithms



                    The general number field sieve is the fastest known classical algorithm for factoring numbers over $10^{100}$.



                    The Quadratic sieve algorithm is the fastest known classical algorithm for factoring numbers under $10^{100}$.






                    share|improve this answer











                    $endgroup$









                    • 2




                      $begingroup$
                      Actually, the factorization of 56153 was a stunt; the factors were deliberately chosen to have a special relation (differed in only 2 bits) and it's easy to factor when the factors have a known relation. AFAIK, the largest number that has been factored to date using a generic quantum factorization algorithm is 21.
                      $endgroup$
                      – poncho
                      1 hour ago












                    • $begingroup$
                      I've always wondered why QS is (at least, consensually said to be) faster than GNFS below a certain thresold (not so consensual), and how much of that is due to lack of work on optimizing GNFS for smaller values.
                      $endgroup$
                      – fgrieu
                      1 hour ago
















                    2












                    $begingroup$

                    Quantum algorithms



                    There is of course Shor's algorithm, but as this algorithm only runs on quantum computers with a lot of qubits it's not capable to factor larger numbers than $21$ (reference).



                    There are multiple apparent new records using adiabatic quantum computation, although some are apparently stunts: See fgrieu's answer on a related question.



                    Classical algorithms



                    The general number field sieve is the fastest known classical algorithm for factoring numbers over $10^{100}$.



                    The Quadratic sieve algorithm is the fastest known classical algorithm for factoring numbers under $10^{100}$.






                    share|improve this answer











                    $endgroup$









                    • 2




                      $begingroup$
                      Actually, the factorization of 56153 was a stunt; the factors were deliberately chosen to have a special relation (differed in only 2 bits) and it's easy to factor when the factors have a known relation. AFAIK, the largest number that has been factored to date using a generic quantum factorization algorithm is 21.
                      $endgroup$
                      – poncho
                      1 hour ago












                    • $begingroup$
                      I've always wondered why QS is (at least, consensually said to be) faster than GNFS below a certain thresold (not so consensual), and how much of that is due to lack of work on optimizing GNFS for smaller values.
                      $endgroup$
                      – fgrieu
                      1 hour ago














                    2












                    2








                    2





                    $begingroup$

                    Quantum algorithms



                    There is of course Shor's algorithm, but as this algorithm only runs on quantum computers with a lot of qubits it's not capable to factor larger numbers than $21$ (reference).



                    There are multiple apparent new records using adiabatic quantum computation, although some are apparently stunts: See fgrieu's answer on a related question.



                    Classical algorithms



                    The general number field sieve is the fastest known classical algorithm for factoring numbers over $10^{100}$.



                    The Quadratic sieve algorithm is the fastest known classical algorithm for factoring numbers under $10^{100}$.






                    share|improve this answer











                    $endgroup$



                    Quantum algorithms



                    There is of course Shor's algorithm, but as this algorithm only runs on quantum computers with a lot of qubits it's not capable to factor larger numbers than $21$ (reference).



                    There are multiple apparent new records using adiabatic quantum computation, although some are apparently stunts: See fgrieu's answer on a related question.



                    Classical algorithms



                    The general number field sieve is the fastest known classical algorithm for factoring numbers over $10^{100}$.



                    The Quadratic sieve algorithm is the fastest known classical algorithm for factoring numbers under $10^{100}$.







                    share|improve this answer














                    share|improve this answer



                    share|improve this answer








                    edited 1 hour ago

























                    answered 1 hour ago









                    AleksanderRasAleksanderRas

                    2,9101935




                    2,9101935








                    • 2




                      $begingroup$
                      Actually, the factorization of 56153 was a stunt; the factors were deliberately chosen to have a special relation (differed in only 2 bits) and it's easy to factor when the factors have a known relation. AFAIK, the largest number that has been factored to date using a generic quantum factorization algorithm is 21.
                      $endgroup$
                      – poncho
                      1 hour ago












                    • $begingroup$
                      I've always wondered why QS is (at least, consensually said to be) faster than GNFS below a certain thresold (not so consensual), and how much of that is due to lack of work on optimizing GNFS for smaller values.
                      $endgroup$
                      – fgrieu
                      1 hour ago














                    • 2




                      $begingroup$
                      Actually, the factorization of 56153 was a stunt; the factors were deliberately chosen to have a special relation (differed in only 2 bits) and it's easy to factor when the factors have a known relation. AFAIK, the largest number that has been factored to date using a generic quantum factorization algorithm is 21.
                      $endgroup$
                      – poncho
                      1 hour ago












                    • $begingroup$
                      I've always wondered why QS is (at least, consensually said to be) faster than GNFS below a certain thresold (not so consensual), and how much of that is due to lack of work on optimizing GNFS for smaller values.
                      $endgroup$
                      – fgrieu
                      1 hour ago








                    2




                    2




                    $begingroup$
                    Actually, the factorization of 56153 was a stunt; the factors were deliberately chosen to have a special relation (differed in only 2 bits) and it's easy to factor when the factors have a known relation. AFAIK, the largest number that has been factored to date using a generic quantum factorization algorithm is 21.
                    $endgroup$
                    – poncho
                    1 hour ago






                    $begingroup$
                    Actually, the factorization of 56153 was a stunt; the factors were deliberately chosen to have a special relation (differed in only 2 bits) and it's easy to factor when the factors have a known relation. AFAIK, the largest number that has been factored to date using a generic quantum factorization algorithm is 21.
                    $endgroup$
                    – poncho
                    1 hour ago














                    $begingroup$
                    I've always wondered why QS is (at least, consensually said to be) faster than GNFS below a certain thresold (not so consensual), and how much of that is due to lack of work on optimizing GNFS for smaller values.
                    $endgroup$
                    – fgrieu
                    1 hour ago




                    $begingroup$
                    I've always wondered why QS is (at least, consensually said to be) faster than GNFS below a certain thresold (not so consensual), and how much of that is due to lack of work on optimizing GNFS for smaller values.
                    $endgroup$
                    – fgrieu
                    1 hour ago










                    user56036 is a new contributor. Be nice, and check out our Code of Conduct.










                    draft saved

                    draft discarded


















                    user56036 is a new contributor. Be nice, and check out our Code of Conduct.













                    user56036 is a new contributor. Be nice, and check out our Code of Conduct.












                    user56036 is a new contributor. Be nice, and check out our Code of Conduct.
















                    Thanks for contributing an answer to Cryptography Stack Exchange!


                    • Please be sure to answer the question. Provide details and share your research!

                    But avoid



                    • Asking for help, clarification, or responding to other answers.

                    • Making statements based on opinion; back them up with references or personal experience.


                    Use MathJax to format equations. MathJax reference.


                    To learn more, see our tips on writing great answers.




                    draft saved


                    draft discarded














                    StackExchange.ready(
                    function () {
                    StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcrypto.stackexchange.com%2fquestions%2f68480%2fwhat-is-the-fastest-integer-factorization-to-break-rsa%23new-answer', 'question_page');
                    }
                    );

                    Post as a guest















                    Required, but never shown





















































                    Required, but never shown














                    Required, but never shown












                    Required, but never shown







                    Required, but never shown

































                    Required, but never shown














                    Required, but never shown












                    Required, but never shown







                    Required, but never shown







                    Popular posts from this blog

                    flock() on closed filehandle LOCK_FILE at /usr/bin/apt-mirror

                    Mangá

                    Eduardo VII do Reino Unido