18.310 Lecture Notes: Cryptography

18.310 lecture notes September 2, 2013 Cryptography 1 Public Key Cryptosystems In these notes, we will be concerned with constructing secret codes. A sender would like to encrypt his message to protect its content while the message is in transit. The receiver would like to easily decode the received message. Our coding scheme should contain the following properties: 1. encoding is easy to perform; 2. decoding is extremely difficult (for protection against eavesdroppers); 3. decoding is easy if you are in possession of some secret “key”. The traditional way of creating secret codes (used in various degrees of sophistication for centuries) is that both the sender and the receiver share a secret, called a key. The sender scrambles the message in a complicated way that depends on the key. The receiver then uses the key to unscramble the message. If these codes are constructed properly (something which is surprisingly hard to do), it seems virtually impossible for somebody without the key to decode the message, even if they have many examples of pairs of messages and their encodings to work from in trying to deduce the key. The drawback of this method is ensuring that every pair of people who need to communicate secretly have a shared secret key. Distributing and managing these keys is surprisingly difficult even when these keys are used for espionage. This would be extremely difficult for secret communication over the internet, when you may wish to send your credit card securely to a store you have never before heard of. Luckily, there is another way to proceed. Diffie and Hellman in 1976 came up with a scheme for handling such communications, called a public key cryptosystem. It is based on the assumption that there is a wide class of functions that are relatively easy to compute but extraordinarily difficult to invert unless you possess a secret. According to this scheme, each communicator or recipient, say Bob or B, publishes in a well defined place (a kind of telephone directory) a description of his function, fB from this class; this is Bob’s public key. Bob knows also the inverse of fB , this is his private key. The assumption is that this inverse is extremely difficult to compute if one does not know some private information. Suppose now that someone, say Alice or A, would like to send a message m to B. She looks up Bob’s public key and sends m = fB (m). Since Bob knows his own private key, he can recover m = fB−1 (m ). The problem here is that Bob has no guarantee that Alice sent the message. Maybe someone else claiming to be Alice sent it. So, instead, suppose that Alice sends the message m = fB (fA−1 (m)) to Bob. Notice that Alice needs to know Bob’s public key (which she can find in the diretory) and also her known private key, which is known only to her. Having received this message, Bob can look up Alice’s public key and recover m by computing m = fA (fB−1 (m )); again, for this purpose, knowledge of Bob’s private key and Alice’s public key is sufficient. Anyone else RSA-1 would have to solve the said-to-be-extraordinarily-difficult task of inverting the action of one or another of these functions on some message in order to read the message or alter it in any way at all. This is the basic setup for a public-key cryptosystem. One can also use it for digital signatures. If Alice wants to show to anyone that she wrote message m, she can publish or send fA−1 (m), and anyone can test it came from Alice by computing fA (m ). We will discuss one of the classes of problems that have been suggested and deployed for communications of this public key type. It was actually developed here at M.I.T., a number of years ago and is known as the RSA public key cryptosystem. It was invented by three MIT people, Ron Rivest, Adi Shamir and Len Adleman in 1977. Their scheme is based on the fact that it is easy to multiply two large numbers together, but it appears to be hard to factor a large number. The record so far for factoring has been to factor a 768-bit number (i.e., 232 digits) given in an RSA challenge, and this took the equivalent of 20,000 years of computing on a single-core machine... The task of factoring a 1024-bit number appears to be 1,000 harder with the current algorithms. 2 The RSA code For this code, choose two very large prime numbers (say with several hundred digits), p and q, and form the product N = pq. Choose a number z < N such that z is relatively prime to (p − 1)(q − 1) = N − p − q + 1. Knowing p and q (or (p − 1)(q − 1)) we can find the multiplicative inverse y to z modulo (p−1)(q−1) by the extended Euclidean algorithm. The pair (N, z) constitutes the public key, and (N, y) constitutes the private key. If we want to encode a message, we first view it as a number in base N . Every digit is a number between 0 and N − 1 and we will encode each digit 0 ≤ m < N separately. The sender computes s = mz mod N and transmits s. Upon receiving s, the receiver, who knows the private key, computes sy mod N . The claim is that this is precisely m, i.e. m = sy mod N . If one could factor N into N = pq then one can easily compute y from z (by the extended Euclid algorithm) and therefore break this public-key cryptosystem. However, as we said previously, factoring large numbers appears to be very challenging. Why does this scheme work? Let x = sy ; we want to show that m = x mod N . We have that x = sy myz (mod N ), and since z and y are multiplicative inverses modulo (p − 1)(q − 1), we get that x = m1+k(p−1)(q−1) = mmk(p−1)(q−1) (mod N ). We want to prove that this is equal to m mod N . We will first show that x ≡ m (mod p) and x ≡ m (mod q) and then deduce from the Chinese remainder theorem that x ≡ m (mod pq). To show that x ≡ m (mod p), we need to consider two cases. First, if m is a multiple of p, then x is also a multiple of p, and so x ≡ m ≡ 0 (mod p). Otherwise, if m is not a multiple of p then it must be relatively prime to p (since p is prime): gcd(m, p) = 1. Thus we can apply Fermat’s Little Theorem, which tells us that mp−1 ≡ 1 (mod p), and thus mk(p−1)(q−1) ≡ 1k(q−1) ≡ 1 Multiplying by m, we indeed obtain x ≡ m (mod p). RSA-2 (mod p). We can apply the same argument to q, to obtain that x ≡ m (mod q) also. Thus the Chinese remainder theorem tells us that x ≡ m (mod N ), and we have proved the correctness of the RSA scheme. In order to use RSA, we need to show how to generate large primes, and also how to efficiently compute mz mod N (or sy mod N ) when z is very large. 3 Raising a Number to a High Power In this section, we show how to raise a number to a high power modulo N efficiently, say mz mod N . The technique is known as repeated squaring and the idea is very simple. If z is a power of 2, say 2k , we can compute mz mod N by starting with m, and repeatedly (k times) squaring it and taking it modulo N . This requires only k multiplications. For example, to compute 332 mod 83, we first compute 32 = 9 (mod 83) then 34 = 92 = 81 (mod 83), then 38 = 812 = (−2)2 = 4 (mod 83) then 316 = 42 = 16 (mod 83), and finally 332 = 162 = 256 = 7 (mod 83). Even though 332 is more than 1015 , the fact that we did every operation modulo 83 meant that we never had to deal with large numbers. In general, when z is not necessarily a power of 2, we write z’s binary representation. Suppose that z requires d bits, and let zk denote the k leading bits of z. Observe that zk = 2zk−1 or zk = 2zk−1 + 1 depending on the kth bit of z. We compute mzk mod N for k = 1, · · · , d. For k = 1, this is simply z 2 mod N . Once we have computed ak−1 = mzk−1 mod N , it is easy to compute ak . Square ak−1 , multiply it by m if the kth leading bit is a 1, and do these operations modulo N . We then get ak and we can repeat. Example. Suppose z = 201. Then z can be respresented by 11001001 in binary. There are 8 steps, in which (i) we square and multiply by m in steps 1, 2, 5, 8 and (ii) we only square in steps 3, 4, 6, and 7. 4 Primality Testing To be able to use RSA, we need to be able to generate large primes. The prime number theorem states that among integers near n, when n is large, approximately one in ln n is a prime. To generate a large prime, we can then generate a random number with the appropriate number of digits or bits, and check if it is prime. If it is, we are done, else we increment it, and try again until we find a prime number. We therefore need to be able to efficiently check if a number is prime. This is known as primality testing. We could try whether it is divisible by any of the small primes, say all primes up to 30. This would detect a good fraction of the composite numbers, but clearly not all of them. Checking all possible factors up to the square root of the number n is extremely slow if n is large, and we are interested in numbers with hundreds of digits. One approach is based on Fermat’s little theorem, and so is called the Fermat primality test. 4.1 Fermat primality test Suppose we are given a large number n, and we want to determine if it’s prime. RSA-3 Let a be any positive number less than n; then by Fermat’s Little Theorem, if n is indeed prime, then since gcd(a, n) = 1 we have that an−1 ≡ 1 (mod n). If n is not prime, on the other hand, this doesn’t have to be true (though it might happen, depending on the specific a and n we choose). So here is a test: choose a large number of randomly chosen values a1 , a2 , . . . , aN , all positive and less than n, and calculate ain−1 (mod n) for each. This we can do very quickly by repeated squaring, as we saw already. If we obtain a value other than 1 for any a, then n is not prime; that a acts a a certificate (“proof”) that n is not prime. We call such an a a Fermat witness for n; if an−1 ≡ 1 (mod n) (and n is composite) then we instead call a a “Fermat liar” for n. As an example, let’s apply this test to n = 1591, using a = 2. By repeated squaring, we get • 21 ≡ 2 (mod 1591), • 23 ≡ 22 · 2 ≡ 8 (mod 1591) • 26 ≡ 82 ≡ 64 (mod 1591) • 212 ≡ 642 ≡ 914 (mod 1591) • 224 ≡ 9142 ≡ 121 (mod 1591) • 249 ≡ 1212 · 2 ≡ 644 (mod 1591) • 299 ≡ 6442 · 2 ≡ 561 (mod 1591) • 2198 ≡ 5612 ≡ 1294 (mod 1591) • 2397 ≡ 12942 · 2 ≡ 1408 (mod 1591) • 2795 ≡ 14082 · 2 ≡ 156 (mod 1591) • 21590 ≡ 1562 ≡ 471 (mod 1591), and this proves that 1591 is not a prime. Indeed, 1591 = 37 · 43. However, we might obtain that 2n−1 ≡ 1 mod n even though n is not prime; this happens for 22 values of n below 10 000. But we can apply the test for multiple values of a, chosen randomly. Let’s define precisely our primality test as follows: Fermat primality test for an integer n 1. Pick a ∈ {1, 2, 3, . . . , n − 1} uniformly at random. 2. Calculate (efficiently via repeated squaring) the value an−1 mod n. If this is not 1, output “not prime”; otherwise output “maybe prime”. We can repeat this test many times; if it outputs “not prime” at least once, we can be sure that it is indeed not prime; if it returns “maybe prime” each time, then perhaps we can conclude that n is very likely to be prime? This turns out to be almost, but not quite, true. There are certain special composite numbers, called Carmichael numbers, that do a very good job of fooling this test. RSA-4 Definition 1. A positive integer n is a Carmichael number if it is composite and an−1 ≡ 1 (mod n) for all a relatively prime to n. If we apply Fermat’s test to a Carmichael number, then the only way it can spot that it’s not prime is if the a chosen happens to share a common factor with n. If the factors of n are all large, then there are few such numbers (compared to n) and we’re very unlikely to pick one of them. It’s not obvious that these numbers exist, but they do, and there are infinitely many of them; the smallest is 561. They are very rare however (much much rarer than primes), and if you pick a large random n, you’d have to be very unlucky to pick a Carmichael number. What we will prove now is that the Fermat test does work on all numbers except for Carmichael numbers. Theorem 1. If n > 2 is composite and not a Carmichael number, then the probability that the Fermat test works is at least 1/2. Proof. Let L = {b ∈ Z∗n : bn−1 ≡ 1 mod n}, i.e., the set of Fermat liars for n. Let W = Z∗n \ L, the set of Fermat witnesses that are relatively prime to n. Since n is not a Carmichael number, W is nonempty. (Note that all elements of Zn \ Z∗n are also Fermat witnesses.) We will show that |L| ≤ |W |, from which the theorem follows. Since then the probability we pick a ∈ L is not more than 1/2; and so the probability of choosing a Fermat witness is at least 1/2. The plan is to find a 1 − 1 map φ from L to W , which immediately gives us that |L| ≤ |W |. The map is very simple: pick an arbitrary a ∈ W (recall it’s nonempty), and define φ(b) = ab mod n ∀b ∈ L. First, let’s see that it is a map from L to W , and not merely a map from L to Zn . For any b ∈ L, φ(b)n−1 = an−1 bn−1 ≡ an−1 ≡ 1 (mod n). So indeed φ(b) ∈ W . It’s also clearly 1 − 1: if φ(b) = φ(b ), then multiplying by a−1 gives b = b . This concludes the proof. We can conclude that the probability that if we run the Fermat test K times on a number n that is composite and not a Carmichael number, the probability that the Fermat test outputs “maybe prime” on all tries is at most 2−K ; by choosing K large enough, we can make the error probability tiny. The defect of the Fermat primality test, that it does not work on Carmichael numbers, can be rectified by more advanced tests, in particular the Miller-Rabin test. This is based on a different certificate of compositeness: if you can find a number a ∈ Zn so that a2 ≡ 1 (mod n), but a ≡  ±1 (mod n), then n is not prime. Exercise. Prove this fact. There is also a (much more complicated) deterministic primality test, due to Agrawal, Kayal and Saxena. RSA-5