Stream cipher
![](http://s9.addthis.com/button1-share.gif)
A stream cipher is a cipher which encrypts data by combining the plaintext with the output of a keyed pseudorandom number generator to generate the ciphertext. To decrypt, run the generator with the same key to generate the same pseudorandom data, then reverse the combining operation to convert ciphertext back to plaintext.
Many stream ciphers use bitwise XOR as the combining operation. This is convenient since XOR is its own inverse, so encryption and decryption use exactly the same operations. However, any operation that has an inverse may be used. Some stream ciphers use bytewise (mod 256) addition to encrypt, subtraction to decrypt. Bruce Schneier's Solitaire (http://www.schneier.com/solitaire.html) is intended to be used manually rather than on a computer; it uses addition and subtraction mod 26 to encrypt at letter level.
The hard part of stream cipher design is the pseudorandom generator. An enemy who knows or guesses some plaintext and has intercepted the matching ciphertext can easily get some of the pseudorandom data. If that allows him to infer the internal state of the generator, then he can break the cipher.
A one-time pad is in effect the ultimate stream cipher. It requires a truly random key as long as long as the data to be encrypted, which makes it impractical for many applications. Given such a key, however, there is no need to generate pseudorandom material and therefore no need to worry about the quality of the generator.
Well-known stream ciphers
RC4, Rivest Cipher number four, was designed by Ron Rivest. It has a size parameter; the 8-bit version is in widespread use. This generates pseudo-random data one byte at a time and maintains a 256-byte internal sate. The key can be any size up to the state size, 256 bytes or 2048 bits
Restrictions and weaknesses
A design problem for stream cipher implementations is how to maintain synchronisation; if the encrypting and decrypting devices get out of sync, generating different pseudorandom output, then communication is lost. In many applications, this is an easy problem but in some cases it can be quite difficult. Consider battlefield communications with noise everywhere and an enemy who attempts to disrupt your communications.
There are some usage restrictions. In particular, never encrypt two different messages with the same pseudorandom data (or even the same truly random data; see VENONA). Using P for plaintext, C for ciphertext, R for (pseudo)random, and ^ for XOR this makes the encryptions:
C1 = P1^R C2 = P2^R
The enemy can intercept both ciphertexts, so he does:
X = C1^C2 = P1^R^P2^R
and the Rs conveniently cancel out, so he has
X = P1^P2
This is very weak indeed. Given moderately strong knowledge of plaintext properties — for example, that it is English text — it can be broken using techniques such as frequency counting that have been well-known for centuries and can be done with pencil and paper. See History of cryptography for details. Even with weaker knowledge of the input format, it is still breakable.
Rewrite attacks
Stream ciphers (including One-time pads) are inherently vulnerable to a rewrite attack. If an attacker knows some plaintext and has intercepted the matching ciphertext, then he can discover that portion of the pseudoradom data. This does not matter if the attacker is just a passive eavesdropper. It gives him no plaintext he didn't already know and we don't care that he learns some pseudorandom data. If the pseudorandom generator is well designed, that does not give him an attack on it, and if we are being sensible, we will never re-use that pseudorandom data.
However, an active attacker who knows the plaintext can recover the pseudorandom data, then use it to encode with whatever he chooses. If he can get his version delivered instead of yours, this may be a disaster. If you send "attack at dawn", the delivered message can be anything the same length -- perhaps "retreat to east" or "shoot generals". An active attacker with only a reasonable guess at the plaintext can try the same attack. If the guess is correct, this works and the attacker's bogus message is delivered. If the guess is wrong, a garbled message is delivered.