2 * Software WEP encryption implementation
3 * Copyright 2002, Jouni Malinen <jkmaline@cc.hut.fi>
4 * Copyright 2003, Instant802 Networks, Inc.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
11 #include <linux/netdevice.h>
12 #include <linux/types.h>
13 #include <linux/random.h>
14 #include <linux/compiler.h>
15 #include <linux/crc32.h>
16 #include <linux/crypto.h>
17 #include <linux/err.h>
19 #include <linux/scatterlist.h>
20 #include <linux/slab.h>
21 #include <asm/unaligned.h>
23 #include <net/mac80211.h>
24 #include "ieee80211_i.h"
28 int ieee80211_wep_init(struct ieee80211_local
*local
)
30 /* start WEP IV from a random value */
31 get_random_bytes(&local
->wep_iv
, IEEE80211_WEP_IV_LEN
);
33 local
->wep_tx_tfm
= crypto_alloc_cipher("arc4", 0, CRYPTO_ALG_ASYNC
);
34 if (IS_ERR(local
->wep_tx_tfm
)) {
35 local
->wep_rx_tfm
= ERR_PTR(-EINVAL
);
36 return PTR_ERR(local
->wep_tx_tfm
);
39 local
->wep_rx_tfm
= crypto_alloc_cipher("arc4", 0, CRYPTO_ALG_ASYNC
);
40 if (IS_ERR(local
->wep_rx_tfm
)) {
41 crypto_free_cipher(local
->wep_tx_tfm
);
42 local
->wep_tx_tfm
= ERR_PTR(-EINVAL
);
43 return PTR_ERR(local
->wep_rx_tfm
);
49 void ieee80211_wep_free(struct ieee80211_local
*local
)
51 if (!IS_ERR(local
->wep_tx_tfm
))
52 crypto_free_cipher(local
->wep_tx_tfm
);
53 if (!IS_ERR(local
->wep_rx_tfm
))
54 crypto_free_cipher(local
->wep_rx_tfm
);
57 static inline bool ieee80211_wep_weak_iv(u32 iv
, int keylen
)
60 * Fluhrer, Mantin, and Shamir have reported weaknesses in the
61 * key scheduling algorithm of RC4. At least IVs (KeyByte + 3,
62 * 0xff, N) can be used to speedup attacks, so avoid using them.
64 if ((iv
& 0xff00) == 0xff00) {
65 u8 B
= (iv
>> 16) & 0xff;
66 if (B
>= 3 && B
< 3 + keylen
)
73 static void ieee80211_wep_get_iv(struct ieee80211_local
*local
,
74 int keylen
, int keyidx
, u8
*iv
)
77 if (ieee80211_wep_weak_iv(local
->wep_iv
, keylen
))
78 local
->wep_iv
+= 0x0100;
83 *iv
++ = (local
->wep_iv
>> 16) & 0xff;
84 *iv
++ = (local
->wep_iv
>> 8) & 0xff;
85 *iv
++ = local
->wep_iv
& 0xff;
90 static u8
*ieee80211_wep_add_iv(struct ieee80211_local
*local
,
92 int keylen
, int keyidx
)
94 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
95 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
99 hdr
->frame_control
|= cpu_to_le16(IEEE80211_FCTL_PROTECTED
);
101 if (WARN_ON(skb_tailroom(skb
) < IEEE80211_WEP_ICV_LEN
||
102 skb_headroom(skb
) < IEEE80211_WEP_IV_LEN
))
105 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
106 newhdr
= skb_push(skb
, IEEE80211_WEP_IV_LEN
);
107 memmove(newhdr
, newhdr
+ IEEE80211_WEP_IV_LEN
, hdrlen
);
109 /* the HW only needs room for the IV, but not the actual IV */
110 if (info
->control
.hw_key
&&
111 (info
->control
.hw_key
->flags
& IEEE80211_KEY_FLAG_PUT_IV_SPACE
))
112 return newhdr
+ hdrlen
;
114 ieee80211_wep_get_iv(local
, keylen
, keyidx
, newhdr
+ hdrlen
);
115 return newhdr
+ hdrlen
;
119 static void ieee80211_wep_remove_iv(struct ieee80211_local
*local
,
121 struct ieee80211_key
*key
)
123 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
126 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
127 memmove(skb
->data
+ IEEE80211_WEP_IV_LEN
, skb
->data
, hdrlen
);
128 skb_pull(skb
, IEEE80211_WEP_IV_LEN
);
132 /* Perform WEP encryption using given key. data buffer must have tailroom
133 * for 4-byte ICV. data_len must not include this ICV. Note: this function
134 * does _not_ add IV. data = RC4(data | CRC32(data)) */
135 int ieee80211_wep_encrypt_data(struct crypto_cipher
*tfm
, u8
*rc4key
,
136 size_t klen
, u8
*data
, size_t data_len
)
144 icv
= cpu_to_le32(~crc32_le(~0, data
, data_len
));
145 put_unaligned(icv
, (__le32
*)(data
+ data_len
));
147 crypto_cipher_setkey(tfm
, rc4key
, klen
);
148 for (i
= 0; i
< data_len
+ IEEE80211_WEP_ICV_LEN
; i
++)
149 crypto_cipher_encrypt_one(tfm
, data
+ i
, data
+ i
);
155 /* Perform WEP encryption on given skb. 4 bytes of extra space (IV) in the
156 * beginning of the buffer 4 bytes of extra space (ICV) in the end of the
157 * buffer will be added. Both IV and ICV will be transmitted, so the
158 * payload length increases with 8 bytes.
160 * WEP frame payload: IV + TX key idx, RC4(data), ICV = RC4(CRC32(data))
162 int ieee80211_wep_encrypt(struct ieee80211_local
*local
,
164 const u8
*key
, int keylen
, int keyidx
)
168 u8 rc4key
[3 + WLAN_KEY_LEN_WEP104
];
170 iv
= ieee80211_wep_add_iv(local
, skb
, keylen
, keyidx
);
174 len
= skb
->len
- (iv
+ IEEE80211_WEP_IV_LEN
- skb
->data
);
176 /* Prepend 24-bit IV to RC4 key */
177 memcpy(rc4key
, iv
, 3);
179 /* Copy rest of the WEP key (the secret part) */
180 memcpy(rc4key
+ 3, key
, keylen
);
182 /* Add room for ICV */
183 skb_put(skb
, IEEE80211_WEP_ICV_LEN
);
185 return ieee80211_wep_encrypt_data(local
->wep_tx_tfm
, rc4key
, keylen
+ 3,
186 iv
+ IEEE80211_WEP_IV_LEN
, len
);
190 /* Perform WEP decryption using given key. data buffer includes encrypted
191 * payload, including 4-byte ICV, but _not_ IV. data_len must not include ICV.
192 * Return 0 on success and -1 on ICV mismatch. */
193 int ieee80211_wep_decrypt_data(struct crypto_cipher
*tfm
, u8
*rc4key
,
194 size_t klen
, u8
*data
, size_t data_len
)
202 crypto_cipher_setkey(tfm
, rc4key
, klen
);
203 for (i
= 0; i
< data_len
+ IEEE80211_WEP_ICV_LEN
; i
++)
204 crypto_cipher_decrypt_one(tfm
, data
+ i
, data
+ i
);
206 crc
= cpu_to_le32(~crc32_le(~0, data
, data_len
));
207 if (memcmp(&crc
, data
+ data_len
, IEEE80211_WEP_ICV_LEN
) != 0)
215 /* Perform WEP decryption on given skb. Buffer includes whole WEP part of
216 * the frame: IV (4 bytes), encrypted payload (including SNAP header),
217 * ICV (4 bytes). skb->len includes both IV and ICV.
219 * Returns 0 if frame was decrypted successfully and ICV was correct and -1 on
220 * failure. If frame is OK, IV and ICV will be removed, i.e., decrypted payload
221 * is moved to the beginning of the skb and skb length will be reduced.
223 static int ieee80211_wep_decrypt(struct ieee80211_local
*local
,
225 struct ieee80211_key
*key
)
228 u8 rc4key
[3 + WLAN_KEY_LEN_WEP104
];
230 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
235 if (!ieee80211_has_protected(hdr
->frame_control
))
238 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
239 if (skb
->len
< hdrlen
+ IEEE80211_WEP_IV_LEN
+ IEEE80211_WEP_ICV_LEN
)
242 len
= skb
->len
- hdrlen
- IEEE80211_WEP_IV_LEN
- IEEE80211_WEP_ICV_LEN
;
244 keyidx
= skb
->data
[hdrlen
+ 3] >> 6;
246 if (!key
|| keyidx
!= key
->conf
.keyidx
)
249 klen
= 3 + key
->conf
.keylen
;
251 /* Prepend 24-bit IV to RC4 key */
252 memcpy(rc4key
, skb
->data
+ hdrlen
, 3);
254 /* Copy rest of the WEP key (the secret part) */
255 memcpy(rc4key
+ 3, key
->conf
.key
, key
->conf
.keylen
);
257 if (ieee80211_wep_decrypt_data(local
->wep_rx_tfm
, rc4key
, klen
,
259 IEEE80211_WEP_IV_LEN
, len
))
263 skb_trim(skb
, skb
->len
- IEEE80211_WEP_ICV_LEN
);
266 memmove(skb
->data
+ IEEE80211_WEP_IV_LEN
, skb
->data
, hdrlen
);
267 skb_pull(skb
, IEEE80211_WEP_IV_LEN
);
273 ieee80211_crypto_wep_decrypt(struct ieee80211_rx_data
*rx
)
275 struct sk_buff
*skb
= rx
->skb
;
276 struct ieee80211_rx_status
*status
= IEEE80211_SKB_RXCB(skb
);
277 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
278 __le16 fc
= hdr
->frame_control
;
280 if (!ieee80211_is_data(fc
) && !ieee80211_is_auth(fc
))
283 if (!(status
->flag
& RX_FLAG_DECRYPTED
)) {
284 if (skb_linearize(rx
->skb
))
285 return RX_DROP_UNUSABLE
;
286 if (ieee80211_wep_decrypt(rx
->local
, rx
->skb
, rx
->key
))
287 return RX_DROP_UNUSABLE
;
288 } else if (!(status
->flag
& RX_FLAG_IV_STRIPPED
)) {
289 if (!pskb_may_pull(rx
->skb
, ieee80211_hdrlen(fc
) +
290 IEEE80211_WEP_IV_LEN
))
291 return RX_DROP_UNUSABLE
;
292 ieee80211_wep_remove_iv(rx
->local
, rx
->skb
, rx
->key
);
294 if (pskb_trim(rx
->skb
, rx
->skb
->len
- IEEE80211_WEP_ICV_LEN
))
295 return RX_DROP_UNUSABLE
;
301 static int wep_encrypt_skb(struct ieee80211_tx_data
*tx
, struct sk_buff
*skb
)
303 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
304 struct ieee80211_key_conf
*hw_key
= info
->control
.hw_key
;
307 if (ieee80211_wep_encrypt(tx
->local
, skb
, tx
->key
->conf
.key
,
308 tx
->key
->conf
.keylen
,
309 tx
->key
->conf
.keyidx
))
311 } else if ((hw_key
->flags
& IEEE80211_KEY_FLAG_GENERATE_IV
) ||
312 (hw_key
->flags
& IEEE80211_KEY_FLAG_PUT_IV_SPACE
)) {
313 if (!ieee80211_wep_add_iv(tx
->local
, skb
,
314 tx
->key
->conf
.keylen
,
315 tx
->key
->conf
.keyidx
))
323 ieee80211_crypto_wep_encrypt(struct ieee80211_tx_data
*tx
)
327 ieee80211_tx_set_protected(tx
);
329 skb_queue_walk(&tx
->skbs
, skb
) {
330 if (wep_encrypt_skb(tx
, skb
) < 0) {
331 I802_DEBUG_INC(tx
->local
->tx_handlers_drop_wep
);