Slashdot Mirror
A Mighty Number Falls
space_in_your_face writes "An international team has broken a long-standing record in an impressive feat of calculation. On March 6, computer clusters from three institutions (the EPFL, the University of Bonn, and NTT in Japan) reached the end of eleven months of strenuous calculation, churning out the prime factors of a well-known, hard-to-factor number — 2^1039 - 1 — that is 307 digits long." The lead researcher believes "the writing is on the wall" for 1024-bit encryption. "Last time, it took nine years for us to generalize from a special to a non-special hard-to factor number (155 digits). I won't make predictions, but let's just say it might be a good idea to stay tuned."
That's not even the point. The algorithm used to factor 2^k - 1, is generally the SNFS which is a highly optimized variant of the NFS, even faster than the GNFS. To factor RSA numbers you need the GNFS.
That said, not all 1024-bit numbers are hard to factor, in fact you have about a 1 in 300 chance of pulling 1024-bit prime out of your ass. The trick here is that RSA numbers are random and have less algebraic structure than Mersenne numbers.
Of course, with all that said, people should be using ECC anyways.
Tom
Someday, I'll have a real sig.
SNFS != GNFS. Factoring specific 1024-bit numbers of that form isn't always super hard.
That they pulled off a SNFS on a 1024 bit number is cool, but not the same amount of work for a GNFS against an 1024-bit RSA key.
Tom
Someday, I'll have a real sig.
2^1039-1=
1159420574 0725730643698071 48876894640753899791 70201772498686835353882248385
9966756608 0006095408005179 47205399326123020487 44028604353028619141014409345
3512334712 7396798885022630 75752809379166028555 10550042581077117617761009413
7970787973 8061870084377771 86828680889844712822 00293520180607475545154137071
1023817
factors:
5585366661 9936291260 7492046583 1594496864
6527018488 6376480100 5234631985 3288374753
×
2075818194 6442382764 5704813703 5946951629
3970800739 5209881208 3870379272 9090324679
3823431438 8414483488 2534053344 7691122230
2815832769 6525376091 4101891052 4199389933
4109711624 3589620659 7216748116 1749004803
6597355734 0925320542 5523689
(spaces added because of lameness filter)
You mean, like generating a analogous OTP out of a pseudo-random number generator? Not only has that been done before, but you're still left with a key: The seed which produced the pseudo-random sequence.
The Navajo code-talkers worked because the encoding was extremely obscure (security through obscurity at its finest!) and cryptography was still in its infancy. I sincerely doubt that the Navajo codes would stand up to a modern cryptographic analysis.
http://en.wikipedia.org/wiki/Navajo_Code_Talkers
Javascript + Nintendo DSi = DSiCade
Adi Shamir designed one already. Instead of 11 months, it takes 12--but it could (in theory) factor any 1024-bit number.
Yes, The RSA Algorithm for public key encryption is based on the difficulty of factoring very large numbers. The key size is the number of bits in the number that has to be factored to break the encryption. Many of the modern security systems, including Verisign certificates for secure websites are based on RSA encryption and 1024 is a very common key size in use. Thus the ease of factoring 1024 bit numbers would indeed be a matter of concern.
RSA 101.
From http://www.ddj.com/blog/portal/archives/2007/05/wo rld_record_fo.html
Using the sieve program developed at the University of Bonn, NTT, EPFL, and the University of Bonn respectively provided 84.1 percent, 8.3 percent, and 7.6 percent of the calculation resources, and the calculation amount equivalent to 95 years of operation on a 3-Ghz Pentium D. PC clusters at NTT and EPFL, consisting of 110 and 36 PCs, respectively, were run in parallel for more than two months for the calculations. The results were 47 non-trivial solutions of the simultaneous equations defined by an approximate 70,000,000 x 70,000,000 large sparse linear matrix.
There are actually three prime factors; the two you listed, and the small factor 5080711. Thus:
8 637648010052346319853288374753 * 20758181946442382764570481370359469516293970800739 52098812083870379272909032467938234314388414483488 25340533447691122230281583276965253760914101891052 41993899334109711624358962065972167481161749004803 659735573409253205425523689
2^1039-1 = 5080711 * 5585366661993629126074920465831594496864652701848
is the correct factorization, as can be readily verified.
Also:
http://www.heise.de/english/newsticker/news/90031
It depends entirely on how you're doing your QAES.
The standard 3DES process is 3DES-EDE which uses 2 keys, thus giving you 112 bits.
ENCRYPT data with key1
DECRYPT output with key2
ENCRYPT output with key1
Since DES is symmetric, any paired combination of encrypt and decrypt will give you the same result. You can do E(D(data)) to get your result, or you can use D(E(data)) for the same thing. If you used the same key for key1 and key2, this would be the same as doing regular DES, and would just take 3x as long.
If you used three different keys for your 3DES instead, you would have the 168-bit key length. Thus, you can apply the same concept to 4AES, and depending on which way you do it you will end up with 256-, 512-, 768- or 1024-bit key strength.
I don't know where she/he got her/his number, but it's wrong.
Use Python, Luke:
So the summary is wrong too: the number is 313, not 307 digits long. At least in base 10.
There's a hidden treasure in Python 3.x: __prepare__()
The reason 3DES provides an effective key length of 112 bits, not 168, isn't because only two keys are used instead of three. We only bother using two keys because the effective length of three-key 3DES is still only 112 bits, so there's little reason to bother storing and managing a third.
The reason the effective length is only 112 bits is something called the "Meet in The Middle" attack. Suppose three keys were used and that the attacker has plaintext and ciphertext to mount a known-plaintext attack. An attacker can apply the first encryption step to the plaintext message using all possible 56-bit keys and then store the results in a big dictionary. Then, the attacker picks a 112-bit key and performs the first two decryption steps on the ciphertext. If the result is in the dictionary, then the attacker has probably found all three keys. If not, he picks another 112-bit key and tries again. So the attacker's work is (a) the effort required to create the dictionary plus (b) the effort required to brute force search a 112-bit keyspace. Since (b) completely dominates (a) we can ignore (a) and use (b) as our estimate of the attack complexity.
In the case of any quadruple encryption, then, the Meet in the Middle attack would require building a dictionary of all possible encryptions using the first two keys, then brute forcing the space of the last two keys. So, the effective strength is equivalent to the size of two of the four keys. Quintuple encryption is equivalent to three keys. Double encryption is equivalent to one key, which is why 2DES was never used.
What does all of this have to do with 1024-bit RSA keys? Not a thing. 1024-bit RSA keys consist of numbers that are the product of two 512-bit prime numbers. That means they're pretty sparse among the set of all possible 1024-bit numbers, and it means they have a particular mathematical structure that can be exploited.
Symmetric ciphers, like AES, are different. Unless there's something wrong with them, their keyspaces are flat, meaning that if they use n-bit keys, every possible n-bit value is a legitimate key. They have no particular mathematical properties, and there is no way to identify the right one except by trying them all.
So, assuming that AES doesn't have some weakness that allows attacks faster than brute force to succeed, how long until we need to use keys bigger than 256 bits?
Forever, basically. Barring weaknesses in the algorithm, 256-bit symmetric keys are safe until, as Bruce Schneier put it "computers are built from something other than matter and occupy something other than space."
In Applied Cryptography he outlines an interesting little computation to demonstrate why this is. Suppose you had a computer that contained a 256-bit register that was maximally efficient, meaning that toggling a bit required exactly one quantum of energy. Since smaller units of energy don't exist, you can't do better than that[*]. With that assumption, you can calculate how much energy it would take to cycle your 256-bit counter through all possible states. Schneier calculates that if you could capture all of the energy from a typical supernova and run your counter on that, you could count from 0 all the way up through about 2^219. So you'd need about 130 billion supernovas to run your counter through all of its 2^256 possible states.
That completely ignores the energy you'd need to perform a trial encryption with each of those values, and it also completely ignores how long it would take to perform all of these operations.
Quantum computers that can somehow handle the complex structures of symmetric ciphers, or some other radical change in computing technology would be required to make 256-bit keys accessible to brute force. A flaw in AES is far more likely, IMO.
[*] Just because someone will call me on it, I should point out that reversible computing means that in theory you might be able to do better than the theorized maximally-efficient computer. In practice, that probably isn't going to make your energy budget small enough to be reachable, and it certainly isn't going to help with the time factor.
Note to ACs: I usually delete AC replies without reading them. If you want to talk to me, log in.
For christsakes, at least read the list; I linked to it. And I did say only the public key algorithms, so AES isn't even relevant.
NSA Suite B:
What I said:
"...all the PK [public key] systems are based on elliptic curves, and not prime factorization, for the trapdoor function."
Of the algorithms in Suite B, AES and SHA aren't public-key algorithms; they're a symmetric block cipher and a hash function. The three relevant PK algorithms are ECMQV, ECDH, and ECDSA, and all of those are specifically noted as being "elliptic curve" variants, rather than the more common RSA-style prime-factorization-based algorithms.
PK algorithms which use elliptic curves use an entirely different set of mathematical functions as the basis for their 'trapdoor' or 'puzzle' (the function that's easy to compute but difficult to run backwards) from RSA. They're based on a variation of the discrete logarithm problem. (From what I understand, the purest form of the discrete logarithm problem isn't reversible at all -- you can run it in one direction, but from the output you can't figure out all of the input parameters were with certainty -- so specific variations of the general problem are used, of which elliptic curves are one.)
Given the popularity of RSA, I think its absence from the list is notable at the very least, and it's furthermore interesting that the NSA seems to really like elliptic curve systems as a basis for PK crypto. At least according to Wikipedia, nobody has ever published a proof of the mathematical hardness of elliptic curve systems...maybe they're even better than is currently realized. (Although, the real tinfoil hat response is, 'maybe they're really flawed somehow, and that's why the NSA wants you to use them!' However, I think this is doubtful for any number of reasons.)
"Ladies and gentlemen, my killbot features Lotus Notes and a machine gun. It is the finest available."