Applied Cryptography and Network Security

Transcription

1 Applied Cryptography and Network Security William Garrison 6311 Sennott Square Lecture #8: RSA

2 Didn t we learn about RSA last time? During the last lecture, we saw what RSA does and learned a little bit about how we can use those features Our goal today will be to explore Why RSA actually works Why RSA is efficient* to use Why it is reasonably safe to use RSA In short, it's a details day Note: Efficiency is a relative term J

3 RSA Overview / Roadmap How do we choose large, pseudo-random primes?! Key generation: Choose two large prime numbers! and ", compute # =!" Compute %(#) = (! 1)(" 1) Choose an integer * such that gcd *, % # = 1 Calculate d such that */ 1 (mod %(#)) Public key: #, * Private key:!, ", / This seems tricky, too Why is %(#) = (! 1)(" 1) How can we do this? Usage: Encryption: 3 * (mod #) Isn t this expensive? Decryption: 4 / mod # = 3 56 (mod #) = :; (mod #) = 3 1 (mod #) = 3 Why does this work?

4 Before we can do anything, we need a few large, pseudo-random primes If our numbers are small, primality testing is pretty easy Try to divide n by all numbers less than! The Sieve of Eratosthenes is a general extension of this principle RSA requires big primes, so brute force testing is not an option (Why?) To choose the types of numbers that RSA needs, we instead use a probabilistic primality testing method test : Z Z {T, F} test(n, a) = F means that n is composite based on the witness a test(n, a) = T means that n is probably prime based on the witness a To test a number n for primality: 1. Randomly choose a witness a Often with probability 1/2 2. if test(n, a) = F, n is composite 3. if test(n, a) = T, loop until we're reasonably certain that n is prime k repetitions means P[n composite] = 2 -k

5 Fermat s little theorem can help us! Fermat's little theorem: Given a prime number! and a natural number " such that 1 " <!, then a '() 1 mod! How does this help with primality testing? If a '() 1 mod!, then! is definitely composite If a '() 1 mod!, then! is probably prime Note: Some composite numbers will always pass this test (Yikes!) These are called Carmichael numbers Carmichael numbers are rare, but may still be found Other primality tests (e.g., Miller-Rabin) avoid detecting these numbers This helps us test whether some number is prime. But how exactly does this help us generate RSA keys?

6 Putting it all together foundprime = false while (!foundprime) return r let r = some large, odd, random number foundprime = true for (iters = 0; iters < k; iters++) let a = random number less than r if (a r-1 1 mod r) foundprime = false break The prime number theorem tells us that, on average, the number of primes less than n is approximately n/ln(n) That is, P[n prime] 1/ln(n) Searching for a prime is hard, but not ridiculously so

7 RSA Overview / Roadmap How do we choose large, pseudo-random primes?! Key generation: Choose two large prime numbers! and ", compute # =!" Compute %(#) = (! 1)(" 1) Choose an integer * such that gcd *, % # = 1 Calculate d such that */ 1 (mod %(#)) Public key: #, * Private key:!, ", / Usage: Encryption: 3 * (mod #) This seems tricky, too Isn t this expensive? Why is %(#) = (! 1)(" 1) How can we do this? Decryption: 4 / mod # = 3 56 (mod #) = :; (mod #) = 3 1 (mod #) = 3 Why does this work?

8 !(#) is called Euler's totient function Definition: The totient function,!(#), counts the number of elements less than n that are relatively prime to n For an RSA modulus # = &', calculating!(#) is actually pretty simple Consider each of the &' numbers # All multiples of & share a common factor with # There are ' such numbers {&, 2&, 3&,, '&} Similarly, all multiples of ' share a common factor with # There are & such numbers {', 2', 3',, &'} So, we have that! # = &' & ' + 1 As a result,! # = &' & ' + 1 = (& 1)(' 1) The +1 controls for subtracting pq twice Note: Calculating!(#) is easy because we know how to factor #!

9 RSA Overview / Roadmap Key generation: Choose two large prime numbers! and ", compute # =!" Compute %(#) = (! 1)(" 1) Choose an integer * such that gcd *, % # = 1 Calculate d such that */ 1 (mod %(#)) Public key: #, * Private key:!, ", / Usage: Encryption: 3 * (mod #) This seems tricky, too Isn t this expensive? Why is %(#) = (! 1)(" 1) How can we do this? Decryption: 4 / mod # = 3 56 (mod #) = :; (mod #) = 3 1 (mod #) = 3 Why does this work?

10 Review of greatest common divisors Definition: Let! and " be integers, not both zero. The largest integer # such that d! and # " is called the greatest common divisor of! and ", and is denoted by gcd(!, ") Note: We can (naively) find GCDs by comparing the common divisors of two numbers. Example: What is the GCD of 24 and 36? Factors of 24: 1, 2, 3, 4, 6, 12 Factors of 36: 1, 2, 3, 4, 6, 9, 12, 18 gcd(24, 36) = 12 Wait. Aren't we dealing with numbers that are hard to factor?

11 Luckily, computing GCDs is not all that hard Intuition: Rather than computing the GCD of two big numbers, we can instead compute the GCD of smaller numbers that have the same GCD! Interesting observation: gcd(%, ') is the same as gcd % ', ' Wait, what? Divides First, we must show that * % * ' * (% ') If * % and * ', then % = /* and ' = 0* Then % ' = /* 0* = / 0 * So, * % * ' * (% ') Ok, so * is a divisor of (% '), but is it the greatest divisor? The divisors of (% ') are a subset of of the divisors of % and the divisors of ' Since * = gcd(%, '), it is the greatest of the remaining divisors

12 Euclid s algorithm optimizes this process! Euclid's algorithm finds gcd(%, ') as follows: Set ) *+ = %, ) *- = ',. = 0 While ) 0*+ 0 divide ) 0*- by ) 0*+ to find 2 0 and ) 0 such that ) 0*- = 2 0 ) 0*+ + ) 0. =. + 1 gcd %, ' = ) 0*- Example: Computing gcd(414, 662)

13 That's all fine and good, but how does this help us compute! 1 mod '())? Method 1: Use Euclid s algorithm Choose a random! Use Euclid s algorithm to determine whether gcd!,. ) = 1 Repeat as needed Method 2: We can just choose a large prime number, 0 > max(4, 5) Why does method 2 work? 0 is a prime number, so it has no divisors other than itself and 1 0 is larger than 4 and 5, so 0 4 and 0 5

14 RSA Overview / Roadmap Key generation: Choose two large prime numbers! and ", compute # =!" Compute %(#) = (! 1)(" 1) Choose an integer * such that gcd *, % # = 1 Calculate d such that */ 1 (mod %(#)) Public key: #, * Private key:!, ", / Usage: Encryption: 3 * (mod #) This seems tricky, too How can we do this? Isn t this expensive? Decryption: 4 / mod # = 3 56 (mod #) = :; (mod #) = 3 1 (mod #) = 3 Why does this work?

15 It turns out that Euclid s algorithm can help us compute! # $%, too If we maintain a little extra state, we can figure out numbers & ' and ( ' such that ) ' = & ' + + ( ' - when calculating gcd(+, -) If + and - are relatively prime, this will allow us to calculate + $% 1 = & ' + + ( ' - // If + and - are relatively prime, ) 5 = 1 & ' + = 1 ( ' - // Subtract ( 5 - from both sides & ' + 1 mod - // Definition of congruence So & ' = + $% // Definition of inverse The extended Euclid's algorithm works as follows: Set ) $% = -, ) $9 = +, 5 = 0, & $9 = 1, ( $9 = 0, & $% = 0, ( $% = 1 While ) '$% 0 divide ) '$9 by ) '$% to find < ' and ) ' such that ) '$9 = < ' ) '$% + ) ' & ' = & '$9 < ' & '$% ( ' = ( '$9 < ' ( '$% 5 = gcd +, - = ) '$9 = & '$9 + + ( '$9 - This makes ) ' = & ' + + ( ' - for 5 = 1 and 5 = 2

16 How about an example? Example: Find the inverse of 797 mod 1047 " # " $ " % " & " So, 1 = -490* * *797 = 1 + (-373) *797 1 mod 1047 In other words, -490 is the inverse of 797 mod 1047

17 RSA Overview / Roadmap Key generation: Choose two large prime numbers! and ", compute # =!" Compute %(#) = (! 1)(" 1) Choose an integer * such that gcd *, % # = 1 Calculate d such that */ 1 (mod %(#)) Public key: #, * Private key:!, ", / Usage: Encryption: 3 * (mod #) This seems tricky, too Isn t this expensive? Decryption: 4 / mod # = 3 56 (mod #) = :; (mod #) = 3 1 (mod #) = 3 Why does this work?

18 Isn't exponentiation really expensive? Exponentiation can be sped up using a trick called successive squaring int pow(int m, int e) if(e is even) return pow(m*m, e/2) else return m * pow(m, e 1) For example, consider computing 2 15 Naive method: 2 * 2 * 2 * * 2 = 32,768 Fast method: 2 15 = 2 * 4 7 = 2 * 4 * 16 3 = 2 * 4 * 16 * 16 2 = 2 * 4 * 16 * 256 = 32,768 = 2 * 4 * 4 6 O(e) multiplications O(log(e)) multiplications This only gets us partway there. Various other algorithmic tricks enable modulo exponentiation to be efficient!

19 RSA Overview / Roadmap Key generation: Usage: Choose two large prime numbers! and ", compute # =!" Compute %(#) = (! 1)(" 1) Choose an integer * such that gcd *, % # = 1 Calculate d such that */ 1 (mod %(#)) Public key: #, * Private key:!, ", / Encryption: 3 * (mod #) Isn t this expensive? Decryption: 4 / mod # = 3 56 (mod #) = :; (mod #) = 3 1 (mod #) = 3 Why does this work?

20 Why does decryption work? Note: Decryption will work if and only if! " mod & = (! " mod & = ( )" mod & //! = ( ) mod & = ( *+, -. mod &// /0 1 mod 3(&), so /0 = 63 & + 1 = (. mod & //?!? = ( mod & // (. = ( The only hitch in showing the correctness of the decryption process is proving that ( *+, -. mod & = (. mod & Fortunately, two smart guys can help us out with this Pierre de Fermat 160? Leonhard Euler

21 First, we need to learn about the set! " Definition:! " is the set of all integers relatively prime to n Example:! $% Interesting note: ', )! " : ')! " ' relatively prime to, means that. $, / $ :. $ ' + / $, = 1 ) relatively prime to n means that. 3, / 3 :. 3 ) + / 3, = 1 Multiplying gives us. $. 3 ') +. $ / 3 ' + / $. 3 ) + / $ / 3,, = 1 The above states that! " is closed under multiplication

22 This leads us to something called Euler's theorem Theorem: " $ % : " ( % 1 mod. Proof: Multiply all /. elements of $ % together, calling the product 0 Note that 0 $ %, and has an inverse 0 12 Now, multiply each element of $ % by " and multiply each of the resulting elements together. This will give us " ( % 0 Multiplying each element of $ % actually just rearranges these elements. As a result, we have that " ( % 0 = 0 If we divide both sides of the equation by 0, we get that " ( % = 1 Ok, so what does Euler s theorem have to do with RSA?

23 We can restate Euler's theorem so that it more clearly connects to RSA math Theorem: " $ %, ( $ ) : " +, % )- " mod 2 Proof: " +, % )- = " +, % " = ", % + " = 1 + " = " From Euler s theorem! Now, in RSA All of our math is done mod 2 Our message space is chosen from elements of $ % 56 1 mod 7 2, so 56 = ( for some ( : ;< mod 2 = : +, % )- mod 2 = : - mod 2 = : Decryption works!

24 RSA Overview / Roadmap Key generation: Usage: Choose two large prime numbers! and ", compute # =!" Compute %(#) = (! 1)(" 1) Choose an integer * such that gcd *, % # = 1 Calculate d such that */ 1 (mod %(#)) Public key: #, * Private key:!, ", / Encryption: 3 * (mod #) Decryption: 4 / mod # = 3 56 (mod #) = :; (mod #) = 3 1 (mod #) = 3 But why is RSA safe Why does to this use? work?

25 Now, why exactly is RSA safe to use? In the original RSA paper*, the authors identify four avenues for attacking the mathematics behind RSA 1.Factoring! to find " and # 2.Determining $! without factoring! 3.Determining % without factoring! or learning $! 4.Learning to take & '( roots modulo! As it turns out, all of these attacks are thought to be hard to do But you shouldn't take my word for it Let s see why! *R.L. Rivest, A. Shamir, and L. Adleman, A Method for Obtaining Digital Signatures and Public-Key Cryptosystems, Communications of the ACM 21(2): , Feb

26 It turns out that factoring is a hard* problem First of all, why is factoring an issue?! is the public modulus of the RSA algorithm If we can factor! to find " and #, we can compute $(!) Given $(!) and ', we can easily compute the decryption exponent ( Fortunately, mathematicians believe that factoring numbers is a very difficult problem. History backs up this belief. The fastest general-purpose algorithm for integer factorization is called the general number field sieve. This algorithm has running time: O(e (c+o(1))(log n) 1 3 (log log n) 2 3 ) Note: This running time is sub-exponential i.e., Factoring can be done faster than brute force This explains why RSA keys are larger than AES keys RSA: Typically bits AES: Typically 128 bits

27 What about computing!(#) without factoring? Question: Why would the ability to compute! # be a bad thing? It would allow us to easily compute %, since &% 1 mod!(#) Good news: If we can compute! #, it will allow us to factor n Note 1:! # = #. / + 1 = #. + / + 1 Rewriting gives us. + / = #! # + 1 Note 2:. / =. + / 1 4# Note 3:. + /. / = 2/ Finally, given / and #, we can easily compute # = / + / 1 4# = / + / 1 4./ =. 1 2./ + / 1 =. / 1 What does this mean? If factoring is actually hard, then so is computing! # without factoring (Recall the concept of reduction)

28 What about computing! without factoring " or knowing # "? As it turns out, if we can figure out! without knowing #(") and without factoring ",! can be used to help us factor " Given!, we can compute &! 1, since we know & Note: &! 1 is a multiple of #(") &! 1 mod #(") &! = 1 + /#(") &! 1 = /#(") It has been shown that " can be efficiently factored using any multiple of #("). As such, if we know & and!, we can efficiently factor ".

29 Are there any other attacks that we need to worry about? Recall:! = # $ mod ( ) is part of the public key, so the adversary knows this If we could compute ) *+ roots mod (, we could decrypt without, It is not known whether breaking RSA yields an efficient factoring algorithm, but the inventors conjecture that this is the case This conjecture was made in 1978 To date, it has either been proved or disproved Conclusion: Odds are that breaking RSA efficiently implies that factoring can be done efficiently. Since factoring is hard, RSA is probably safe to use.

30 RSA Wrap Up Hopefully you now have a better understanding of RSA How each step of the process works How these steps can be made reasonably efficient Why RSA is safe to use Unfortunately, this is not the end of the story Although theoretically secure, implementations can be broken We ll revisit this in a later lecture Next time: Secret sharing and threshold cryptography