- Fluhrer, Mantin, and Shamir attack
In
cryptography , the Fluhrer, Mantin, and Shamir attack allows an attacker to recover the key in anRC4 encrypted stream from a large number of messages in that stream.Background
The Fluhrer, Mantin and Shamir (FMS) attack takes advantage of a weakness in the RC4 key scheduling algorithm to reconstruct the key from a number of collected encrypted messages. The FMS attack gained popularity in tools such as
AirSnort andaircrack , both of which attackWEP encrypted wireless networks.For this discussion, we will use the below RC4 key scheduling algorithm (KSA).
begin ksa(with int keylength, with byte key [keylength] ) for i from 0 to 255 S [i] := i endfor j := 0 for i from 0 to 255 j := (j + S [i] + key [i mod keylength] ) mod 256 swap(S [i] ,S [j] ) endfor end
We will also use the below pseudo-random generation algorithm (PRGA).
begin prga(with byte S [256] ) i := 0 j := 0 while GeneratingOutput: i := (i + 1) mod 256 j := (j + S [i] ) mod 256 swap(S [i] ,S [j] ) output S [(S [i] + S [j] ) mod 256] endwhile end
The Attack
The basis of the FMS attack lies in the use of weak
initialization vector s (IVs) used with RC4. RC4 encrypts one byte at a time with akeystream output from "prga()"; RC4 uses the key to initialize astate machine via "ksa()", and then continuously modifies the state and generates a new byte of the keystream from the new state. Theoretically, the key stream functions as a randomone time pad , as apseudo-random number generator controls the output at each step.With certain IVs, an attacker knowing the "m"th byte of the keystream can derive the "m+1"th byte due to a weakness in the PRNG used to generate the keystream. Because the first byte of the plaintext comes from the WEP SNAP header, an attacker can assume she can derive the first byte of the keystream from B oplus 0xAA. From there, she only needs an IV in the form left (a+3, n-1, x ight ) for key index a origin 0, element value space n (256 since 8 bits make a byte), and any X. To start, the attacker needs IVs of left (3, 255, x ight ). WEP uses 24-bit IVs, making each value one byte long.
To start, the attacker utilizes the IV as the first 3 elements in "K [] ". She fills the S-box "S [] " with sequential values from 0 to n as RC4 does when initializing the S-box from a known "K [] ". She then performs the first 3 iterations of "ksa()" to begin initializing the S-box.
After the third step, the attacker can possibly, but not definitely, derive the fourth byte of the key using the keystream output O by computing left (O - j - Sleft [i ight ] ight ) mod n = Kleft [i ight ] , with the value i = 3 at this step.
At this point, the attacker does not yet have the fourth byte of the key. This algorithm does not regenerate the next byte of the key; it generates a possible value of the key. By collecting multiple messages—for example WEP packets—and repeating these steps, she will generate a number of different possible values. The correct value appears significantly more frequently than any other; the attacker can determine the value of the key by recognizing this value and selecting it as the next byte. At this point, she can start the attack over again on the fifth byte of the key.
Although the attacker cannot attack words of the key out of order, she can store messages for later sequential attack on later words once she knows earlier words. Again, she only needs messages with weak IVs, and can discard others. Through this process, she can gather a large number of messages for attack on the entire key; in fact, she can store only a short portion of the beginning of those messages, just enough to carry the attack out as far as the word of the key the IV will allow her to attack.
References
*
Wikimedia Foundation. 2010.