Posted on 08/04/2004 11:09:02 PM PDT by Straight Vermonter
The U.S. and Pakistan may have found a way to read months, or years, worth of secret al Qaeda messages. No one is saying anything about that, but it works like this.
The recent warnings that al Qaeda was planning attacks on specific targets in the United States was said to come from recent people, and information, captured in Pakistan. One of the two key al Qaeda people captured was Mohammed Naeem Noor Khan, an English speaking Pakistani computer engineer. Khan was running an al Qaeda communications network, using email and encryption to distribute messages that could not be read with out the decoding keys. What was left out of these reports was any mention of public key cryptography, PGP (a version of public key cryptography freely available to Internet users), the National Security Agency (NSA) and cracking (decoding) PGP. There’s more to Mister Khan’s capture than meets the eye.
During the 1990s, the NSA was frequently in court trying to keep PGP off the market. In the 1980s, NSA was trying to get the key length of commercial ciphers kept shorter than business wanted. NSA is in charge of developing systems to keep American government messages secret, and figuring out how to crack the codes other nations use. Although the NSA never admitted it, most cryptography experts believed NSA wanted to keep longer keys out of use, because NSA did not have powerful enough techniques, or computers, to crack longer keys.
OK, all this talk of cipers and keys length doesn’t make sense to most people, so let’s offer a brief explanation. It starts with the appearance of inexpensive computers, when it became possible to use new methods to turn messages into apparent gibberish with coding systems. This was done using a “key”, which was a string of letters and numbers. Think of it a kind of password. If the person receiving the message had the right key, the message could be decoded (using a mathematical routine similar to the one that garbled the message in the first place.) The most popular of these techniques was eventually released as an inexpensive commercial product called PGP (Pretty Good Privacy). Users could post a “public key” that other users of the PGP program could use to scramble an email message or data file. When you received a message scrambled with your public key, you entered your private key into PGP and it descrambled the email or file.
The trouble with PGP was that, as far as NSA was concerned, it was too good. NSA got the U.S. government to declare programs like PGP to be military equipment, and subject to export controls. Trying to stop the spread of PGP was absurd, however, and the government eventually backed off. But NSA’s problem with PGP encoded messages remained. Or did it? NSA, obviously, is not going to admit that it can, or cannot, crack PGP encoded messages.
The most straightforward to read an encoded PGP message, without the decoding key is to use a computer to run through every possible combination of the key, to find the ones that work. A 516 digit key can be cracked using this computerized “brute force” method. For example, if you have a computer that can perform a million instructions per second going at it for 30,000 years, you can read the message encoded with a 516 digit key. That’s a little misleading, as a thousand dollar PC in 2004 can generate several thousand MIPS. So it would only take you ten years to crack that code. Of course, if you got several hundred of these PCs working together, you could get the job done in a few weeks. You can see where this is going. NSA has billions of dollars a year to play with, and building “supercomputers” out of cheap PCs has become quite popular.
However, increase the key to 768 characters, and it takes about 6,600 times longer to crack it. Go to key size of 1024, and it takes 1,500 times longer than the 768 character key. Go to a 2048 key size and it takes a billion times longer than a 1024 character long key. PGP can use a 1024 character key, and many users go for the larger key for obvious reasons.
Down at the NSA, all is not lost. Cracking a PGP code can be done with clever math as well as powerful computers. While we know there are a lot of cheap, powerful computers available to the NSA, we also know the NSA has a lot of clever people who specialize in figuring out better ways to crack codes. What we don’t know is if NSA is able to crack PGP messages scrambled using 1024 character codes.
If al Qaeda’s computer savvy Mohammed Naeem Noor Khan was in charge of an al Qaeda communications network that used the Internet, then he was probably using PGP. Al Qaeda use of PGP has been reported many times, as have complaints about the potential for that providing al Qaeda with an invulnerable encryption system. NSA has remained silent. But if Kahn was the man in charge, and he had many of the decryption keys with him when he was captured, that enables the NSA to read many previous messages. How many? Depends on how many keys were captured. Could be months worth. It’s also possible that months worth of actual messages was captured. This kind of information is invaluable in figuring out what al Qaeda has been doing, and is currently planning. Did Kahn have the keys? This is something you don’t want to discuss, one way or the other. You want the al Qaeda users of Kahns network to sweat a bit, even if the keys were not grabbed. And if the keys were obtained, there are tough times ahead for terrorist users of "invulnerable" encryption.
Wouldn't help. PGP is open source. You can study it all you want. Anyone can.
I agree, a dictionary attack on a keystore would be the most probable solution.
I've always wondered about bruteforce attacks. Each attempt with a random key will produce some sort of result. How does the computer recognize when the correct key has been used, and a valid result has appeared?
"I would rather plant spyware on the Hotmail page that loads to any computer that accesses it from Pakistan, and pings the CIA computer from there... "
Intelligence agencies would get in big doodoo if caught doing something like that.
Plus, installing stuff on someome elses computer surrepititiously in that way requires specific browser versions etc to be in place etc - it's just not possible to bug every browser in Pakistan!
"I've always wondered about bruteforce attacks. Each attempt with a random key will produce some sort of result. How does the computer recognize when the correct key has been used, and a valid result has appeared?"
You can't do THAT kind of attack against asymmetric crypto.
You are describing dictionary attacks against symmetric crypto, like DES.
You have a dictionary, you encrypt each word, then compare the result to the captured password file, for example, and look for matches. That is (a vastly simplified but accurate) explanation of how people 'crack' passwords for example.
Yeah the cell phone thing was truly stupid too.
Bruce Schneier has a nice little primer on how to recognize plaintext.
http://www.schneier.com/crypto-gram-9812.html#plaintext
Aren't we all assuming that there is no backdoor to PGP? Does anybody think that the NSA was simply going to drop their opposition to exporting this technology?
how would intelligence agencies get in trouble for that? no one can even hold the people who are doing it accountable!
they have caught a few sympathizers setting up fake AQ websites....who knows what else they are doing...
D-R-I-N-K
M-O-R-E
O-V-A-L-T-I-N-E
(BTTT)
There are 3 different keys that are useful in attacking PGP encrypted traffic.
There's a message key, for the symmetric cipher that's used to encrypt the individual message. That should only be useful for decrypting one message, so it's not that useful. I'm pretty retro, so using PGP 2.6.2 this ciper would be IDEA, its key length will be 128 bits.
There's the private key of the recipient, which decrypts the
message key that's encrypted to the public key of the recipient. This is thing you want, because you can decrypt all messages sent to that key. That you've ever intercepted. Storage is cheap, so it's worthwhile to keep all encrypted traffic you can capture, in case you get ahold of the keys later on.
Then there's a symmetric key used to encrypt the private key for storage on disk. I'm thinking they used IDEA for PGP 2.6.2 to encrypt the private key, but I'm too lazy to look. There's a passphrase that allows decrypting the private key, note that you need the secret keyring to attack this. When you get the passphrase (the passphrase, if weak, will be a lot easier to attack than brute forcing the encryption on the key).
I just finished that article. It was a great piece of journalism. It was really odd to see al Qaeda in the light of functioning like any other organization, with all the pettiness and power struggles.
That picture was hilarious. It was surreal to see these images encased in the familiar Windows environment (and in English, no les). Reminded me of the Taliban rushing around in those old Toyota pickups.
I second your skepticism, but dare not express it in this neighborhood.
That's interesting. But wouldn't the overhead of testing each decrypted message slow down brute forcing considerably? It's one thing to try a billion keys a second, and it's quite another to look at each decryption and decide if it's any good or not.
If the encryptor knew the plaintext recognition algorithm, he could also take steps to dodge recognition:
LikeHereIsMyPlainTextMessage.
If they're looking for spaces they're out of luck.
A brute-force cracking machine tries every possible key until it finds the right one. If the machine has a chunk of ciphertext and decrypts it with one key after the other, how does it know when it found the correct plaintext?
It seems obvious to me, but I get this question often enough to address it in these pages. The machine knows that it found the plaintext because it looks like plaintext.
Plaintext tends to look like plaintext. It's an English-language message, or a data file from a computer application (programs like Microsoft Word have large known headers; even PK-ZIP files have known headers), or a database in a reasonable format. When you look at a decrypted file, it looks like something understandable. When you look at a ciphertext file, or a file decrypted with the wrong key, it looks like gibberish.
In the 1940s, Claude Shannon invented a concept called the unicity distance. Among other things, the unicity distance measures the amount of ciphertext required such that there is only one reasonable plaintext. This number depends both on the characteristics of the plaintext and the key length of the encryption algorithm.
For example, RC4 encrypts data in bytes. Imagine a single ASCII letter as plaintext. There are 26 possible plaintexts out of 256 possible decryptions. Any random key, when used to decrypt the ciphertext, has a 26/256 chance of producing a valid plaintext. The analyst has no way to tell the wrong plaintext from the correct plaintext.
Now imagine a 1K e-mail message. The analyst tries random keys, and eventually a plaintext emerges that looks like an e-mail message: words, phrases, sentences, grammar. The odds are infinitesimal that this is not the correct plaintext.
Everything else is in the middle. The unicity distance determines when you can think like the second example instead of the first.
For a standard English message, the unicity distance is K/6.8, where K is the key length. (The 6.8 is a measure of the redundancy of English in ASCII. For other plaintexts it will be more or less, but not that much more or less.) For DES, the unicity distance is 8.2 bytes. For 128-bit ciphers, it is about 19 bytes.
This means that if you are trying to brute-force DES you need two ciphertext blocks. (DES's block length is 8 bytes.) Decrypt the first ciphertext block with one key after another. If the resulting plaintext looks like English, then decrypt the second block with the same key. If the second plaintext block also looks like English, you've found the correct key.
The unicity distance grows as the redundancy of the plaintext shrinks. For compressed files, the redundancy might be 2.5, or three blocks of DES ciphertext. For a 256-bit-key cipher, that would be 105 plaintext bytes. If the plaintext is a random key, the redundancy is zero and the unicity distance reaches infinity: it is impossible to recognize the correct plaintext from an incorrect plaintext.
But that's a special case. Most of the time, it is easy to recognize plaintext.
Hope you're right.
Actually, it's not all that hard to bug a lot of them. Writing a worm that attacks a particular Internet address space and checks for local languages, etc., is well within possibility, and vastly cheaper than recon satellites.
You can assume that U.S. intelligence and/or law enforcement have tried to strongarm every provider of encrypted communication to provide a backdoor.
There are, however, open source versions of PGP.
You need some clue, hack, or exploit. Even in the days of Enigma, info gathered in the field about the machines, cleartexts, etc., were vital to success. I don't believe that there is fundamental knowledge that exists only inside NSA that enables them to crack encryption that other people cannot crack or prove a crack exists.
That said, 2048 bit keys are probably not excessive.
"A 1024-bit key takes 1.16x10^77 times as long to crack as a 768-bit key (1 followed by 76 zeros)."
That would be a 1 followed by 77 zeros. Just like 1 times 10^2 is a one followed by 2 zeros.
Disclaimer: Opinions posted on Free Republic are those of the individual posters and do not necessarily represent the opinion of Free Republic or its management. All materials posted herein are protected by copyright law and the exemption for fair use of copyrighted works.