blob: 5a48d8e0aec1a98a73761cfe9626d32c4fd47383 [file] [log] [blame]
Jeff Garzikb4538722005-05-12 22:48:20 -04001/*
2 * Host AP crypt: host-based TKIP encryption implementation for Host AP driver
3 *
Jouni Malinen85d32e72007-03-24 17:15:30 -07004 * Copyright (c) 2003-2004, Jouni Malinen <j@w1.fi>
Jeff Garzikb4538722005-05-12 22:48:20 -04005 *
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. See README and COPYING for
9 * more details.
10 */
11
Herbert Xuf12cc202006-08-22 20:36:13 +100012#include <linux/err.h>
Jeff Garzikb4538722005-05-12 22:48:20 -040013#include <linux/module.h>
14#include <linux/init.h>
15#include <linux/slab.h>
16#include <linux/random.h>
17#include <linux/skbuff.h>
18#include <linux/netdevice.h>
Al Virod7fe0f22006-12-03 23:15:30 -050019#include <linux/mm.h>
Jeff Garzikb4538722005-05-12 22:48:20 -040020#include <linux/if_ether.h>
21#include <linux/if_arp.h>
22#include <asm/string.h>
23
24#include <net/ieee80211.h>
25
Jeff Garzikb4538722005-05-12 22:48:20 -040026#include <linux/crypto.h>
27#include <asm/scatterlist.h>
28#include <linux/crc32.h>
29
30MODULE_AUTHOR("Jouni Malinen");
31MODULE_DESCRIPTION("Host AP crypt: TKIP");
32MODULE_LICENSE("GPL");
33
34struct ieee80211_tkip_data {
35#define TKIP_KEY_LEN 32
36 u8 key[TKIP_KEY_LEN];
37 int key_set;
38
39 u32 tx_iv32;
40 u16 tx_iv16;
41 u16 tx_ttak[5];
42 int tx_phase1_done;
43
44 u32 rx_iv32;
45 u16 rx_iv16;
46 u16 rx_ttak[5];
47 int rx_phase1_done;
48 u32 rx_iv32_new;
49 u16 rx_iv16_new;
50
51 u32 dot11RSNAStatsTKIPReplays;
52 u32 dot11RSNAStatsTKIPICVErrors;
53 u32 dot11RSNAStatsTKIPLocalMICFailures;
54
55 int key_idx;
56
Jeff Garzik28eb1772006-09-22 20:10:23 -040057 struct crypto_blkcipher *rx_tfm_arc4;
58 struct crypto_hash *rx_tfm_michael;
59 struct crypto_blkcipher *tx_tfm_arc4;
60 struct crypto_hash *tx_tfm_michael;
Jeff Garzikb4538722005-05-12 22:48:20 -040061
62 /* scratch buffers for virt_to_page() (crypto API) */
63 u8 rx_hdr[16], tx_hdr[16];
James Ketrenos20d64712005-09-21 11:53:43 -050064
James Ketrenos6eb6edf2005-09-22 10:34:15 +000065 unsigned long flags;
Jeff Garzikb4538722005-05-12 22:48:20 -040066};
67
James Ketrenos6eb6edf2005-09-22 10:34:15 +000068static unsigned long ieee80211_tkip_set_flags(unsigned long flags, void *priv)
69{
70 struct ieee80211_tkip_data *_priv = priv;
71 unsigned long old_flags = _priv->flags;
72 _priv->flags = flags;
73 return old_flags;
74}
75
76static unsigned long ieee80211_tkip_get_flags(void *priv)
77{
78 struct ieee80211_tkip_data *_priv = priv;
79 return _priv->flags;
80}
81
82static void *ieee80211_tkip_init(int key_idx)
Jeff Garzikb4538722005-05-12 22:48:20 -040083{
84 struct ieee80211_tkip_data *priv;
85
Zhu Yi8aa914b2006-01-19 16:22:07 +080086 priv = kzalloc(sizeof(*priv), GFP_ATOMIC);
Jeff Garzikb4538722005-05-12 22:48:20 -040087 if (priv == NULL)
88 goto fail;
James Ketrenos20d64712005-09-21 11:53:43 -050089
Jeff Garzikb4538722005-05-12 22:48:20 -040090 priv->key_idx = key_idx;
91
Jeff Garzik28eb1772006-09-22 20:10:23 -040092 priv->tx_tfm_arc4 = crypto_alloc_blkcipher("ecb(arc4)", 0,
Herbert Xuf12cc202006-08-22 20:36:13 +100093 CRYPTO_ALG_ASYNC);
Jeff Garzik28eb1772006-09-22 20:10:23 -040094 if (IS_ERR(priv->tx_tfm_arc4)) {
Jeff Garzikb4538722005-05-12 22:48:20 -040095 printk(KERN_DEBUG "ieee80211_crypt_tkip: could not allocate "
96 "crypto API arc4\n");
Jeff Garzik18379872006-09-22 21:19:05 -040097 priv->tx_tfm_arc4 = NULL;
Jeff Garzikb4538722005-05-12 22:48:20 -040098 goto fail;
99 }
100
Jeff Garzik28eb1772006-09-22 20:10:23 -0400101 priv->tx_tfm_michael = crypto_alloc_hash("michael_mic", 0,
102 CRYPTO_ALG_ASYNC);
103 if (IS_ERR(priv->tx_tfm_michael)) {
Zhu Yi5a656942006-08-21 11:33:56 +0800104 printk(KERN_DEBUG "ieee80211_crypt_tkip: could not allocate "
105 "crypto API michael_mic\n");
Jeff Garzik18379872006-09-22 21:19:05 -0400106 priv->tx_tfm_michael = NULL;
Zhu Yi5a656942006-08-21 11:33:56 +0800107 goto fail;
108 }
109
Jeff Garzik28eb1772006-09-22 20:10:23 -0400110 priv->rx_tfm_arc4 = crypto_alloc_blkcipher("ecb(arc4)", 0,
111 CRYPTO_ALG_ASYNC);
112 if (IS_ERR(priv->rx_tfm_arc4)) {
Zhu Yi5a656942006-08-21 11:33:56 +0800113 printk(KERN_DEBUG "ieee80211_crypt_tkip: could not allocate "
114 "crypto API arc4\n");
Jeff Garzik18379872006-09-22 21:19:05 -0400115 priv->rx_tfm_arc4 = NULL;
Zhu Yi5a656942006-08-21 11:33:56 +0800116 goto fail;
117 }
118
Jeff Garzik28eb1772006-09-22 20:10:23 -0400119 priv->rx_tfm_michael = crypto_alloc_hash("michael_mic", 0,
120 CRYPTO_ALG_ASYNC);
121 if (IS_ERR(priv->rx_tfm_michael)) {
Jeff Garzikb4538722005-05-12 22:48:20 -0400122 printk(KERN_DEBUG "ieee80211_crypt_tkip: could not allocate "
123 "crypto API michael_mic\n");
Jeff Garzik18379872006-09-22 21:19:05 -0400124 priv->rx_tfm_michael = NULL;
Jeff Garzikb4538722005-05-12 22:48:20 -0400125 goto fail;
126 }
127
128 return priv;
129
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400130 fail:
Jeff Garzikb4538722005-05-12 22:48:20 -0400131 if (priv) {
Zhu Yi5a656942006-08-21 11:33:56 +0800132 if (priv->tx_tfm_michael)
Jeff Garzik28eb1772006-09-22 20:10:23 -0400133 crypto_free_hash(priv->tx_tfm_michael);
Zhu Yi5a656942006-08-21 11:33:56 +0800134 if (priv->tx_tfm_arc4)
Jeff Garzik28eb1772006-09-22 20:10:23 -0400135 crypto_free_blkcipher(priv->tx_tfm_arc4);
Zhu Yi5a656942006-08-21 11:33:56 +0800136 if (priv->rx_tfm_michael)
Jeff Garzik28eb1772006-09-22 20:10:23 -0400137 crypto_free_hash(priv->rx_tfm_michael);
Zhu Yi5a656942006-08-21 11:33:56 +0800138 if (priv->rx_tfm_arc4)
Jeff Garzik28eb1772006-09-22 20:10:23 -0400139 crypto_free_blkcipher(priv->rx_tfm_arc4);
Jeff Garzikb4538722005-05-12 22:48:20 -0400140 kfree(priv);
141 }
142
143 return NULL;
144}
145
Jeff Garzikb4538722005-05-12 22:48:20 -0400146static void ieee80211_tkip_deinit(void *priv)
147{
148 struct ieee80211_tkip_data *_priv = priv;
Zhu Yi5a656942006-08-21 11:33:56 +0800149 if (_priv) {
150 if (_priv->tx_tfm_michael)
Jeff Garzik28eb1772006-09-22 20:10:23 -0400151 crypto_free_hash(_priv->tx_tfm_michael);
Zhu Yi5a656942006-08-21 11:33:56 +0800152 if (_priv->tx_tfm_arc4)
Jeff Garzik28eb1772006-09-22 20:10:23 -0400153 crypto_free_blkcipher(_priv->tx_tfm_arc4);
Zhu Yi5a656942006-08-21 11:33:56 +0800154 if (_priv->rx_tfm_michael)
Jeff Garzik28eb1772006-09-22 20:10:23 -0400155 crypto_free_hash(_priv->rx_tfm_michael);
Zhu Yi5a656942006-08-21 11:33:56 +0800156 if (_priv->rx_tfm_arc4)
Jeff Garzik28eb1772006-09-22 20:10:23 -0400157 crypto_free_blkcipher(_priv->rx_tfm_arc4);
Zhu Yi5a656942006-08-21 11:33:56 +0800158 }
Jeff Garzikb4538722005-05-12 22:48:20 -0400159 kfree(priv);
160}
161
Jeff Garzikb4538722005-05-12 22:48:20 -0400162static inline u16 RotR1(u16 val)
163{
164 return (val >> 1) | (val << 15);
165}
166
Jeff Garzikb4538722005-05-12 22:48:20 -0400167static inline u8 Lo8(u16 val)
168{
169 return val & 0xff;
170}
171
Jeff Garzikb4538722005-05-12 22:48:20 -0400172static inline u8 Hi8(u16 val)
173{
174 return val >> 8;
175}
176
Jeff Garzikb4538722005-05-12 22:48:20 -0400177static inline u16 Lo16(u32 val)
178{
179 return val & 0xffff;
180}
181
Jeff Garzikb4538722005-05-12 22:48:20 -0400182static inline u16 Hi16(u32 val)
183{
184 return val >> 16;
185}
186
Jeff Garzikb4538722005-05-12 22:48:20 -0400187static inline u16 Mk16(u8 hi, u8 lo)
188{
189 return lo | (((u16) hi) << 8);
190}
191
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400192static inline u16 Mk16_le(u16 * v)
Jeff Garzikb4538722005-05-12 22:48:20 -0400193{
194 return le16_to_cpu(*v);
195}
196
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400197static const u16 Sbox[256] = {
Jeff Garzikb4538722005-05-12 22:48:20 -0400198 0xC6A5, 0xF884, 0xEE99, 0xF68D, 0xFF0D, 0xD6BD, 0xDEB1, 0x9154,
199 0x6050, 0x0203, 0xCEA9, 0x567D, 0xE719, 0xB562, 0x4DE6, 0xEC9A,
200 0x8F45, 0x1F9D, 0x8940, 0xFA87, 0xEF15, 0xB2EB, 0x8EC9, 0xFB0B,
201 0x41EC, 0xB367, 0x5FFD, 0x45EA, 0x23BF, 0x53F7, 0xE496, 0x9B5B,
202 0x75C2, 0xE11C, 0x3DAE, 0x4C6A, 0x6C5A, 0x7E41, 0xF502, 0x834F,
203 0x685C, 0x51F4, 0xD134, 0xF908, 0xE293, 0xAB73, 0x6253, 0x2A3F,
204 0x080C, 0x9552, 0x4665, 0x9D5E, 0x3028, 0x37A1, 0x0A0F, 0x2FB5,
205 0x0E09, 0x2436, 0x1B9B, 0xDF3D, 0xCD26, 0x4E69, 0x7FCD, 0xEA9F,
206 0x121B, 0x1D9E, 0x5874, 0x342E, 0x362D, 0xDCB2, 0xB4EE, 0x5BFB,
207 0xA4F6, 0x764D, 0xB761, 0x7DCE, 0x527B, 0xDD3E, 0x5E71, 0x1397,
208 0xA6F5, 0xB968, 0x0000, 0xC12C, 0x4060, 0xE31F, 0x79C8, 0xB6ED,
209 0xD4BE, 0x8D46, 0x67D9, 0x724B, 0x94DE, 0x98D4, 0xB0E8, 0x854A,
210 0xBB6B, 0xC52A, 0x4FE5, 0xED16, 0x86C5, 0x9AD7, 0x6655, 0x1194,
211 0x8ACF, 0xE910, 0x0406, 0xFE81, 0xA0F0, 0x7844, 0x25BA, 0x4BE3,
212 0xA2F3, 0x5DFE, 0x80C0, 0x058A, 0x3FAD, 0x21BC, 0x7048, 0xF104,
213 0x63DF, 0x77C1, 0xAF75, 0x4263, 0x2030, 0xE51A, 0xFD0E, 0xBF6D,
214 0x814C, 0x1814, 0x2635, 0xC32F, 0xBEE1, 0x35A2, 0x88CC, 0x2E39,
215 0x9357, 0x55F2, 0xFC82, 0x7A47, 0xC8AC, 0xBAE7, 0x322B, 0xE695,
216 0xC0A0, 0x1998, 0x9ED1, 0xA37F, 0x4466, 0x547E, 0x3BAB, 0x0B83,
217 0x8CCA, 0xC729, 0x6BD3, 0x283C, 0xA779, 0xBCE2, 0x161D, 0xAD76,
218 0xDB3B, 0x6456, 0x744E, 0x141E, 0x92DB, 0x0C0A, 0x486C, 0xB8E4,
219 0x9F5D, 0xBD6E, 0x43EF, 0xC4A6, 0x39A8, 0x31A4, 0xD337, 0xF28B,
220 0xD532, 0x8B43, 0x6E59, 0xDAB7, 0x018C, 0xB164, 0x9CD2, 0x49E0,
221 0xD8B4, 0xACFA, 0xF307, 0xCF25, 0xCAAF, 0xF48E, 0x47E9, 0x1018,
222 0x6FD5, 0xF088, 0x4A6F, 0x5C72, 0x3824, 0x57F1, 0x73C7, 0x9751,
223 0xCB23, 0xA17C, 0xE89C, 0x3E21, 0x96DD, 0x61DC, 0x0D86, 0x0F85,
224 0xE090, 0x7C42, 0x71C4, 0xCCAA, 0x90D8, 0x0605, 0xF701, 0x1C12,
225 0xC2A3, 0x6A5F, 0xAEF9, 0x69D0, 0x1791, 0x9958, 0x3A27, 0x27B9,
226 0xD938, 0xEB13, 0x2BB3, 0x2233, 0xD2BB, 0xA970, 0x0789, 0x33A7,
227 0x2DB6, 0x3C22, 0x1592, 0xC920, 0x8749, 0xAAFF, 0x5078, 0xA57A,
228 0x038F, 0x59F8, 0x0980, 0x1A17, 0x65DA, 0xD731, 0x84C6, 0xD0B8,
229 0x82C3, 0x29B0, 0x5A77, 0x1E11, 0x7BCB, 0xA8FC, 0x6DD6, 0x2C3A,
230};
231
Jeff Garzikb4538722005-05-12 22:48:20 -0400232static inline u16 _S_(u16 v)
233{
234 u16 t = Sbox[Hi8(v)];
235 return Sbox[Lo8(v)] ^ ((t << 8) | (t >> 8));
236}
237
Jeff Garzikb4538722005-05-12 22:48:20 -0400238#define PHASE1_LOOP_COUNT 8
239
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400240static void tkip_mixing_phase1(u16 * TTAK, const u8 * TK, const u8 * TA,
241 u32 IV32)
Jeff Garzikb4538722005-05-12 22:48:20 -0400242{
243 int i, j;
244
245 /* Initialize the 80-bit TTAK from TSC (IV32) and TA[0..5] */
246 TTAK[0] = Lo16(IV32);
247 TTAK[1] = Hi16(IV32);
248 TTAK[2] = Mk16(TA[1], TA[0]);
249 TTAK[3] = Mk16(TA[3], TA[2]);
250 TTAK[4] = Mk16(TA[5], TA[4]);
251
252 for (i = 0; i < PHASE1_LOOP_COUNT; i++) {
253 j = 2 * (i & 1);
254 TTAK[0] += _S_(TTAK[4] ^ Mk16(TK[1 + j], TK[0 + j]));
255 TTAK[1] += _S_(TTAK[0] ^ Mk16(TK[5 + j], TK[4 + j]));
256 TTAK[2] += _S_(TTAK[1] ^ Mk16(TK[9 + j], TK[8 + j]));
257 TTAK[3] += _S_(TTAK[2] ^ Mk16(TK[13 + j], TK[12 + j]));
258 TTAK[4] += _S_(TTAK[3] ^ Mk16(TK[1 + j], TK[0 + j])) + i;
259 }
260}
261
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400262static void tkip_mixing_phase2(u8 * WEPSeed, const u8 * TK, const u16 * TTAK,
Jeff Garzikb4538722005-05-12 22:48:20 -0400263 u16 IV16)
264{
265 /* Make temporary area overlap WEP seed so that the final copy can be
266 * avoided on little endian hosts. */
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400267 u16 *PPK = (u16 *) & WEPSeed[4];
Jeff Garzikb4538722005-05-12 22:48:20 -0400268
269 /* Step 1 - make copy of TTAK and bring in TSC */
270 PPK[0] = TTAK[0];
271 PPK[1] = TTAK[1];
272 PPK[2] = TTAK[2];
273 PPK[3] = TTAK[3];
274 PPK[4] = TTAK[4];
275 PPK[5] = TTAK[4] + IV16;
276
277 /* Step 2 - 96-bit bijective mixing using S-box */
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400278 PPK[0] += _S_(PPK[5] ^ Mk16_le((u16 *) & TK[0]));
279 PPK[1] += _S_(PPK[0] ^ Mk16_le((u16 *) & TK[2]));
280 PPK[2] += _S_(PPK[1] ^ Mk16_le((u16 *) & TK[4]));
281 PPK[3] += _S_(PPK[2] ^ Mk16_le((u16 *) & TK[6]));
282 PPK[4] += _S_(PPK[3] ^ Mk16_le((u16 *) & TK[8]));
283 PPK[5] += _S_(PPK[4] ^ Mk16_le((u16 *) & TK[10]));
Jeff Garzikb4538722005-05-12 22:48:20 -0400284
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400285 PPK[0] += RotR1(PPK[5] ^ Mk16_le((u16 *) & TK[12]));
286 PPK[1] += RotR1(PPK[0] ^ Mk16_le((u16 *) & TK[14]));
Jeff Garzikb4538722005-05-12 22:48:20 -0400287 PPK[2] += RotR1(PPK[1]);
288 PPK[3] += RotR1(PPK[2]);
289 PPK[4] += RotR1(PPK[3]);
290 PPK[5] += RotR1(PPK[4]);
291
292 /* Step 3 - bring in last of TK bits, assign 24-bit WEP IV value
293 * WEPSeed[0..2] is transmitted as WEP IV */
294 WEPSeed[0] = Hi8(IV16);
295 WEPSeed[1] = (Hi8(IV16) | 0x20) & 0x7F;
296 WEPSeed[2] = Lo8(IV16);
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400297 WEPSeed[3] = Lo8((PPK[5] ^ Mk16_le((u16 *) & TK[0])) >> 1);
Jeff Garzikb4538722005-05-12 22:48:20 -0400298
299#ifdef __BIG_ENDIAN
300 {
301 int i;
302 for (i = 0; i < 6; i++)
303 PPK[i] = (PPK[i] << 8) | (PPK[i] >> 8);
304 }
305#endif
306}
307
Zhu Yi9184d932006-01-19 16:22:32 +0800308static int ieee80211_tkip_hdr(struct sk_buff *skb, int hdr_len,
309 u8 * rc4key, int keylen, void *priv)
Jeff Garzikb4538722005-05-12 22:48:20 -0400310{
311 struct ieee80211_tkip_data *tkey = priv;
312 int len;
Zhu Yi9184d932006-01-19 16:22:32 +0800313 u8 *pos;
James Ketrenosee34af32005-09-21 11:54:36 -0500314 struct ieee80211_hdr_4addr *hdr;
Jeff Garzikb4538722005-05-12 22:48:20 -0400315
James Ketrenosee34af32005-09-21 11:54:36 -0500316 hdr = (struct ieee80211_hdr_4addr *)skb->data;
James Ketrenos20d64712005-09-21 11:53:43 -0500317
James Ketrenos31b59ea2005-09-21 11:58:49 -0500318 if (skb_headroom(skb) < 8 || skb->len < hdr_len)
Zhu Yi9184d932006-01-19 16:22:32 +0800319 return -1;
320
321 if (rc4key == NULL || keylen < 16)
322 return -1;
Jeff Garzikb4538722005-05-12 22:48:20 -0400323
Jeff Garzikb4538722005-05-12 22:48:20 -0400324 if (!tkey->tx_phase1_done) {
325 tkip_mixing_phase1(tkey->tx_ttak, tkey->key, hdr->addr2,
326 tkey->tx_iv32);
327 tkey->tx_phase1_done = 1;
328 }
329 tkip_mixing_phase2(rc4key, tkey->key, tkey->tx_ttak, tkey->tx_iv16);
330
331 len = skb->len - hdr_len;
332 pos = skb_push(skb, 8);
333 memmove(pos, pos + 8, hdr_len);
334 pos += hdr_len;
Jeff Garzikb4538722005-05-12 22:48:20 -0400335
James Ketrenos31b59ea2005-09-21 11:58:49 -0500336 *pos++ = *rc4key;
337 *pos++ = *(rc4key + 1);
338 *pos++ = *(rc4key + 2);
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400339 *pos++ = (tkey->key_idx << 6) | (1 << 5) /* Ext IV included */ ;
Jeff Garzikb4538722005-05-12 22:48:20 -0400340 *pos++ = tkey->tx_iv32 & 0xff;
341 *pos++ = (tkey->tx_iv32 >> 8) & 0xff;
342 *pos++ = (tkey->tx_iv32 >> 16) & 0xff;
343 *pos++ = (tkey->tx_iv32 >> 24) & 0xff;
344
Zhu Yi9184d932006-01-19 16:22:32 +0800345 tkey->tx_iv16++;
346 if (tkey->tx_iv16 == 0) {
347 tkey->tx_phase1_done = 0;
348 tkey->tx_iv32++;
349 }
Jeff Garzikb4538722005-05-12 22:48:20 -0400350
Zhu Yi9184d932006-01-19 16:22:32 +0800351 return 8;
James Ketrenos31b59ea2005-09-21 11:58:49 -0500352}
353
354static int ieee80211_tkip_encrypt(struct sk_buff *skb, int hdr_len, void *priv)
355{
356 struct ieee80211_tkip_data *tkey = priv;
Jeff Garzik28eb1772006-09-22 20:10:23 -0400357 struct blkcipher_desc desc = { .tfm = tkey->tx_tfm_arc4 };
James Ketrenos31b59ea2005-09-21 11:58:49 -0500358 int len;
Zhu Yi9184d932006-01-19 16:22:32 +0800359 u8 rc4key[16], *pos, *icv;
360 u32 crc;
James Ketrenos31b59ea2005-09-21 11:58:49 -0500361 struct scatterlist sg;
362
James Ketrenos6eb6edf2005-09-22 10:34:15 +0000363 if (tkey->flags & IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) {
James Ketrenos31b59ea2005-09-21 11:58:49 -0500364 if (net_ratelimit()) {
365 struct ieee80211_hdr_4addr *hdr =
366 (struct ieee80211_hdr_4addr *)skb->data;
Zhu Yi9184d932006-01-19 16:22:32 +0800367 printk(KERN_DEBUG ": TKIP countermeasures: dropped "
James Ketrenos31b59ea2005-09-21 11:58:49 -0500368 "TX packet to " MAC_FMT "\n",
James Ketrenos6eb6edf2005-09-22 10:34:15 +0000369 MAC_ARG(hdr->addr1));
James Ketrenos31b59ea2005-09-21 11:58:49 -0500370 }
371 return -1;
372 }
373
374 if (skb_tailroom(skb) < 4 || skb->len < hdr_len)
375 return -1;
376
377 len = skb->len - hdr_len;
378 pos = skb->data + hdr_len;
379
Zhu Yi9184d932006-01-19 16:22:32 +0800380 if ((ieee80211_tkip_hdr(skb, hdr_len, rc4key, 16, priv)) < 0)
James Ketrenos31b59ea2005-09-21 11:58:49 -0500381 return -1;
382
Zhu Yi9184d932006-01-19 16:22:32 +0800383 icv = skb_put(skb, 4);
384
385 crc = ~crc32_le(~0, pos, len);
386 icv[0] = crc;
387 icv[1] = crc >> 8;
388 icv[2] = crc >> 16;
389 icv[3] = crc >> 24;
390
Jeff Garzik28eb1772006-09-22 20:10:23 -0400391 crypto_blkcipher_setkey(tkey->tx_tfm_arc4, rc4key, 16);
Jeff Garzikb4538722005-05-12 22:48:20 -0400392 sg.page = virt_to_page(pos);
393 sg.offset = offset_in_page(pos);
394 sg.length = len + 4;
Herbert Xuf12cc202006-08-22 20:36:13 +1000395 return crypto_blkcipher_encrypt(&desc, &sg, &sg, len + 4);
Zhu Yib4328d82006-08-21 11:33:09 +0800396}
397
Jeff Garzik18379872006-09-22 21:19:05 -0400398/*
399 * deal with seq counter wrapping correctly.
400 * refer to timer_after() for jiffies wrapping handling
401 */
402static inline int tkip_replay_check(u32 iv32_n, u16 iv16_n,
403 u32 iv32_o, u16 iv16_o)
404{
405 if ((s32)iv32_n - (s32)iv32_o < 0 ||
406 (iv32_n == iv32_o && iv16_n <= iv16_o))
407 return 1;
408 return 0;
409}
410
Jeff Garzikb4538722005-05-12 22:48:20 -0400411static int ieee80211_tkip_decrypt(struct sk_buff *skb, int hdr_len, void *priv)
412{
413 struct ieee80211_tkip_data *tkey = priv;
Jeff Garzik28eb1772006-09-22 20:10:23 -0400414 struct blkcipher_desc desc = { .tfm = tkey->rx_tfm_arc4 };
Jeff Garzikb4538722005-05-12 22:48:20 -0400415 u8 rc4key[16];
416 u8 keyidx, *pos;
417 u32 iv32;
418 u16 iv16;
James Ketrenosee34af32005-09-21 11:54:36 -0500419 struct ieee80211_hdr_4addr *hdr;
Jeff Garzikb4538722005-05-12 22:48:20 -0400420 u8 icv[4];
421 u32 crc;
422 struct scatterlist sg;
423 int plen;
424
James Ketrenosee34af32005-09-21 11:54:36 -0500425 hdr = (struct ieee80211_hdr_4addr *)skb->data;
James Ketrenos20d64712005-09-21 11:53:43 -0500426
James Ketrenos6eb6edf2005-09-22 10:34:15 +0000427 if (tkey->flags & IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) {
James Ketrenos20d64712005-09-21 11:53:43 -0500428 if (net_ratelimit()) {
Zhu Yi9184d932006-01-19 16:22:32 +0800429 printk(KERN_DEBUG ": TKIP countermeasures: dropped "
James Ketrenos20d64712005-09-21 11:53:43 -0500430 "received packet from " MAC_FMT "\n",
James Ketrenos6eb6edf2005-09-22 10:34:15 +0000431 MAC_ARG(hdr->addr2));
James Ketrenos20d64712005-09-21 11:53:43 -0500432 }
433 return -1;
434 }
435
Jeff Garzikb4538722005-05-12 22:48:20 -0400436 if (skb->len < hdr_len + 8 + 4)
437 return -1;
438
Jeff Garzikb4538722005-05-12 22:48:20 -0400439 pos = skb->data + hdr_len;
440 keyidx = pos[3];
441 if (!(keyidx & (1 << 5))) {
442 if (net_ratelimit()) {
443 printk(KERN_DEBUG "TKIP: received packet without ExtIV"
444 " flag from " MAC_FMT "\n", MAC_ARG(hdr->addr2));
445 }
446 return -2;
447 }
448 keyidx >>= 6;
449 if (tkey->key_idx != keyidx) {
450 printk(KERN_DEBUG "TKIP: RX tkey->key_idx=%d frame "
451 "keyidx=%d priv=%p\n", tkey->key_idx, keyidx, priv);
452 return -6;
453 }
454 if (!tkey->key_set) {
455 if (net_ratelimit()) {
456 printk(KERN_DEBUG "TKIP: received packet from " MAC_FMT
457 " with keyid=%d that does not have a configured"
458 " key\n", MAC_ARG(hdr->addr2), keyidx);
459 }
460 return -3;
461 }
462 iv16 = (pos[0] << 8) | pos[2];
463 iv32 = pos[4] | (pos[5] << 8) | (pos[6] << 16) | (pos[7] << 24);
464 pos += 8;
465
Zhu Yib4328d82006-08-21 11:33:09 +0800466 if (tkip_replay_check(iv32, iv16, tkey->rx_iv32, tkey->rx_iv16)) {
Jeff Garzikb4538722005-05-12 22:48:20 -0400467 if (net_ratelimit()) {
Larry Fingeraeb998c2007-04-09 11:24:41 -0500468 IEEE80211_DEBUG_DROP("TKIP: replay detected: STA=" MAC_FMT
Jeff Garzikb4538722005-05-12 22:48:20 -0400469 " previous TSC %08x%04x received TSC "
470 "%08x%04x\n", MAC_ARG(hdr->addr2),
471 tkey->rx_iv32, tkey->rx_iv16, iv32, iv16);
472 }
473 tkey->dot11RSNAStatsTKIPReplays++;
474 return -4;
475 }
476
477 if (iv32 != tkey->rx_iv32 || !tkey->rx_phase1_done) {
478 tkip_mixing_phase1(tkey->rx_ttak, tkey->key, hdr->addr2, iv32);
479 tkey->rx_phase1_done = 1;
480 }
481 tkip_mixing_phase2(rc4key, tkey->key, tkey->rx_ttak, iv16);
482
483 plen = skb->len - hdr_len - 12;
484
Jeff Garzik28eb1772006-09-22 20:10:23 -0400485 crypto_blkcipher_setkey(tkey->rx_tfm_arc4, rc4key, 16);
Jeff Garzikb4538722005-05-12 22:48:20 -0400486 sg.page = virt_to_page(pos);
487 sg.offset = offset_in_page(pos);
488 sg.length = plen + 4;
Herbert Xuf12cc202006-08-22 20:36:13 +1000489 if (crypto_blkcipher_decrypt(&desc, &sg, &sg, plen + 4)) {
490 if (net_ratelimit()) {
491 printk(KERN_DEBUG ": TKIP: failed to decrypt "
492 "received packet from " MAC_FMT "\n",
493 MAC_ARG(hdr->addr2));
494 }
495 return -7;
496 }
Jeff Garzikb4538722005-05-12 22:48:20 -0400497
498 crc = ~crc32_le(~0, pos, plen);
499 icv[0] = crc;
500 icv[1] = crc >> 8;
501 icv[2] = crc >> 16;
502 icv[3] = crc >> 24;
503 if (memcmp(icv, pos + plen, 4) != 0) {
504 if (iv32 != tkey->rx_iv32) {
505 /* Previously cached Phase1 result was already lost, so
506 * it needs to be recalculated for the next packet. */
507 tkey->rx_phase1_done = 0;
508 }
509 if (net_ratelimit()) {
Larry Fingeraeb998c2007-04-09 11:24:41 -0500510 IEEE80211_DEBUG_DROP("TKIP: ICV error detected: STA="
Jeff Garzikb4538722005-05-12 22:48:20 -0400511 MAC_FMT "\n", MAC_ARG(hdr->addr2));
512 }
513 tkey->dot11RSNAStatsTKIPICVErrors++;
514 return -5;
515 }
516
517 /* Update real counters only after Michael MIC verification has
518 * completed */
519 tkey->rx_iv32_new = iv32;
520 tkey->rx_iv16_new = iv16;
521
522 /* Remove IV and ICV */
523 memmove(skb->data + 8, skb->data, hdr_len);
524 skb_pull(skb, 8);
525 skb_trim(skb, skb->len - 4);
526
527 return keyidx;
528}
529
Jeff Garzik28eb1772006-09-22 20:10:23 -0400530static int michael_mic(struct crypto_hash *tfm_michael, u8 * key, u8 * hdr,
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400531 u8 * data, size_t data_len, u8 * mic)
Jeff Garzikb4538722005-05-12 22:48:20 -0400532{
Herbert Xu35058682006-08-24 19:10:20 +1000533 struct hash_desc desc;
Jeff Garzikb4538722005-05-12 22:48:20 -0400534 struct scatterlist sg[2];
535
Zhu Yi5a656942006-08-21 11:33:56 +0800536 if (tfm_michael == NULL) {
Jeff Garzikb4538722005-05-12 22:48:20 -0400537 printk(KERN_WARNING "michael_mic: tfm_michael == NULL\n");
538 return -1;
539 }
540 sg[0].page = virt_to_page(hdr);
541 sg[0].offset = offset_in_page(hdr);
542 sg[0].length = 16;
543
544 sg[1].page = virt_to_page(data);
545 sg[1].offset = offset_in_page(data);
546 sg[1].length = data_len;
547
Jeff Garzik28eb1772006-09-22 20:10:23 -0400548 if (crypto_hash_setkey(tfm_michael, key, 8))
Herbert Xu35058682006-08-24 19:10:20 +1000549 return -1;
Jeff Garzikb4538722005-05-12 22:48:20 -0400550
Jeff Garzik28eb1772006-09-22 20:10:23 -0400551 desc.tfm = tfm_michael;
Herbert Xu35058682006-08-24 19:10:20 +1000552 desc.flags = 0;
553 return crypto_hash_digest(&desc, sg, data_len + 16, mic);
Jeff Garzikb4538722005-05-12 22:48:20 -0400554}
555
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400556static void michael_mic_hdr(struct sk_buff *skb, u8 * hdr)
Jeff Garzikb4538722005-05-12 22:48:20 -0400557{
James Ketrenosee34af32005-09-21 11:54:36 -0500558 struct ieee80211_hdr_4addr *hdr11;
Zhu Yiea284152006-04-13 17:17:06 +0800559 u16 stype;
Jeff Garzikb4538722005-05-12 22:48:20 -0400560
James Ketrenosee34af32005-09-21 11:54:36 -0500561 hdr11 = (struct ieee80211_hdr_4addr *)skb->data;
Zhu Yiea284152006-04-13 17:17:06 +0800562 stype = WLAN_FC_GET_STYPE(le16_to_cpu(hdr11->frame_ctl));
563
Jeff Garzikb4538722005-05-12 22:48:20 -0400564 switch (le16_to_cpu(hdr11->frame_ctl) &
565 (IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS)) {
566 case IEEE80211_FCTL_TODS:
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400567 memcpy(hdr, hdr11->addr3, ETH_ALEN); /* DA */
568 memcpy(hdr + ETH_ALEN, hdr11->addr2, ETH_ALEN); /* SA */
Jeff Garzikb4538722005-05-12 22:48:20 -0400569 break;
570 case IEEE80211_FCTL_FROMDS:
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400571 memcpy(hdr, hdr11->addr1, ETH_ALEN); /* DA */
572 memcpy(hdr + ETH_ALEN, hdr11->addr3, ETH_ALEN); /* SA */
Jeff Garzikb4538722005-05-12 22:48:20 -0400573 break;
574 case IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS:
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400575 memcpy(hdr, hdr11->addr3, ETH_ALEN); /* DA */
576 memcpy(hdr + ETH_ALEN, hdr11->addr4, ETH_ALEN); /* SA */
Jeff Garzikb4538722005-05-12 22:48:20 -0400577 break;
578 case 0:
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400579 memcpy(hdr, hdr11->addr1, ETH_ALEN); /* DA */
580 memcpy(hdr + ETH_ALEN, hdr11->addr2, ETH_ALEN); /* SA */
Jeff Garzikb4538722005-05-12 22:48:20 -0400581 break;
582 }
583
Zhu Yiea284152006-04-13 17:17:06 +0800584 if (stype & IEEE80211_STYPE_QOS_DATA) {
585 const struct ieee80211_hdr_3addrqos *qoshdr =
586 (struct ieee80211_hdr_3addrqos *)skb->data;
Zhu Yi65b6a272006-08-21 11:32:31 +0800587 hdr[12] = qoshdr->qos_ctl & cpu_to_le16(IEEE80211_QCTL_TID);
Zhu Yiea284152006-04-13 17:17:06 +0800588 } else
589 hdr[12] = 0; /* priority */
590
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400591 hdr[13] = hdr[14] = hdr[15] = 0; /* reserved */
Jeff Garzikb4538722005-05-12 22:48:20 -0400592}
593
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400594static int ieee80211_michael_mic_add(struct sk_buff *skb, int hdr_len,
595 void *priv)
Jeff Garzikb4538722005-05-12 22:48:20 -0400596{
597 struct ieee80211_tkip_data *tkey = priv;
598 u8 *pos;
599
600 if (skb_tailroom(skb) < 8 || skb->len < hdr_len) {
601 printk(KERN_DEBUG "Invalid packet for Michael MIC add "
602 "(tailroom=%d hdr_len=%d skb->len=%d)\n",
603 skb_tailroom(skb), hdr_len, skb->len);
604 return -1;
605 }
606
607 michael_mic_hdr(skb, tkey->tx_hdr);
608 pos = skb_put(skb, 8);
Zhu Yi5a656942006-08-21 11:33:56 +0800609 if (michael_mic(tkey->tx_tfm_michael, &tkey->key[16], tkey->tx_hdr,
Jeff Garzikb4538722005-05-12 22:48:20 -0400610 skb->data + hdr_len, skb->len - 8 - hdr_len, pos))
611 return -1;
612
613 return 0;
614}
615
Jeff Garzikb4538722005-05-12 22:48:20 -0400616static void ieee80211_michael_mic_failure(struct net_device *dev,
James Ketrenosee34af32005-09-21 11:54:36 -0500617 struct ieee80211_hdr_4addr *hdr,
618 int keyidx)
Jeff Garzikb4538722005-05-12 22:48:20 -0400619{
620 union iwreq_data wrqu;
621 struct iw_michaelmicfailure ev;
622
623 /* TODO: needed parameters: count, keyid, key type, TSC */
624 memset(&ev, 0, sizeof(ev));
625 ev.flags = keyidx & IW_MICFAILURE_KEY_ID;
626 if (hdr->addr1[0] & 0x01)
627 ev.flags |= IW_MICFAILURE_GROUP;
628 else
629 ev.flags |= IW_MICFAILURE_PAIRWISE;
630 ev.src_addr.sa_family = ARPHRD_ETHER;
631 memcpy(ev.src_addr.sa_data, hdr->addr2, ETH_ALEN);
632 memset(&wrqu, 0, sizeof(wrqu));
633 wrqu.data.length = sizeof(ev);
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400634 wireless_send_event(dev, IWEVMICHAELMICFAILURE, &wrqu, (char *)&ev);
Jeff Garzikb4538722005-05-12 22:48:20 -0400635}
Jeff Garzikb4538722005-05-12 22:48:20 -0400636
637static int ieee80211_michael_mic_verify(struct sk_buff *skb, int keyidx,
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400638 int hdr_len, void *priv)
Jeff Garzikb4538722005-05-12 22:48:20 -0400639{
640 struct ieee80211_tkip_data *tkey = priv;
641 u8 mic[8];
642
643 if (!tkey->key_set)
644 return -1;
645
646 michael_mic_hdr(skb, tkey->rx_hdr);
Zhu Yi5a656942006-08-21 11:33:56 +0800647 if (michael_mic(tkey->rx_tfm_michael, &tkey->key[24], tkey->rx_hdr,
Jeff Garzikb4538722005-05-12 22:48:20 -0400648 skb->data + hdr_len, skb->len - 8 - hdr_len, mic))
649 return -1;
650 if (memcmp(mic, skb->data + skb->len - 8, 8) != 0) {
James Ketrenosee34af32005-09-21 11:54:36 -0500651 struct ieee80211_hdr_4addr *hdr;
652 hdr = (struct ieee80211_hdr_4addr *)skb->data;
Jeff Garzikb4538722005-05-12 22:48:20 -0400653 printk(KERN_DEBUG "%s: Michael MIC verification failed for "
654 "MSDU from " MAC_FMT " keyidx=%d\n",
655 skb->dev ? skb->dev->name : "N/A", MAC_ARG(hdr->addr2),
656 keyidx);
657 if (skb->dev)
658 ieee80211_michael_mic_failure(skb->dev, hdr, keyidx);
659 tkey->dot11RSNAStatsTKIPLocalMICFailures++;
660 return -1;
661 }
662
663 /* Update TSC counters for RX now that the packet verification has
664 * completed. */
665 tkey->rx_iv32 = tkey->rx_iv32_new;
666 tkey->rx_iv16 = tkey->rx_iv16_new;
667
668 skb_trim(skb, skb->len - 8);
669
670 return 0;
671}
672
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400673static int ieee80211_tkip_set_key(void *key, int len, u8 * seq, void *priv)
Jeff Garzikb4538722005-05-12 22:48:20 -0400674{
675 struct ieee80211_tkip_data *tkey = priv;
676 int keyidx;
Jeff Garzik28eb1772006-09-22 20:10:23 -0400677 struct crypto_hash *tfm = tkey->tx_tfm_michael;
678 struct crypto_blkcipher *tfm2 = tkey->tx_tfm_arc4;
679 struct crypto_hash *tfm3 = tkey->rx_tfm_michael;
680 struct crypto_blkcipher *tfm4 = tkey->rx_tfm_arc4;
Jeff Garzikb4538722005-05-12 22:48:20 -0400681
682 keyidx = tkey->key_idx;
683 memset(tkey, 0, sizeof(*tkey));
684 tkey->key_idx = keyidx;
Zhu Yi5a656942006-08-21 11:33:56 +0800685 tkey->tx_tfm_michael = tfm;
686 tkey->tx_tfm_arc4 = tfm2;
687 tkey->rx_tfm_michael = tfm3;
688 tkey->rx_tfm_arc4 = tfm4;
Jeff Garzikb4538722005-05-12 22:48:20 -0400689 if (len == TKIP_KEY_LEN) {
690 memcpy(tkey->key, key, TKIP_KEY_LEN);
691 tkey->key_set = 1;
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400692 tkey->tx_iv16 = 1; /* TSC is initialized to 1 */
Jeff Garzikb4538722005-05-12 22:48:20 -0400693 if (seq) {
694 tkey->rx_iv32 = (seq[5] << 24) | (seq[4] << 16) |
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400695 (seq[3] << 8) | seq[2];
Jeff Garzikb4538722005-05-12 22:48:20 -0400696 tkey->rx_iv16 = (seq[1] << 8) | seq[0];
697 }
698 } else if (len == 0)
699 tkey->key_set = 0;
700 else
701 return -1;
702
703 return 0;
704}
705
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400706static int ieee80211_tkip_get_key(void *key, int len, u8 * seq, void *priv)
Jeff Garzikb4538722005-05-12 22:48:20 -0400707{
708 struct ieee80211_tkip_data *tkey = priv;
709
710 if (len < TKIP_KEY_LEN)
711 return -1;
712
713 if (!tkey->key_set)
714 return 0;
715 memcpy(key, tkey->key, TKIP_KEY_LEN);
716
717 if (seq) {
718 /* Return the sequence number of the last transmitted frame. */
719 u16 iv16 = tkey->tx_iv16;
720 u32 iv32 = tkey->tx_iv32;
721 if (iv16 == 0)
722 iv32--;
723 iv16--;
724 seq[0] = tkey->tx_iv16;
725 seq[1] = tkey->tx_iv16 >> 8;
726 seq[2] = tkey->tx_iv32;
727 seq[3] = tkey->tx_iv32 >> 8;
728 seq[4] = tkey->tx_iv32 >> 16;
729 seq[5] = tkey->tx_iv32 >> 24;
730 }
731
732 return TKIP_KEY_LEN;
733}
734
Jeff Garzik0edd5b42005-09-07 00:48:31 -0400735static char *ieee80211_tkip_print_stats(char *p, void *priv)
Jeff Garzikb4538722005-05-12 22:48:20 -0400736{
737 struct ieee80211_tkip_data *tkip = priv;
738 p += sprintf(p, "key[%d] alg=TKIP key_set=%d "
739 "tx_pn=%02x%02x%02x%02x%02x%02x "
740 "rx_pn=%02x%02x%02x%02x%02x%02x "
741 "replays=%d icv_errors=%d local_mic_failures=%d\n",
742 tkip->key_idx, tkip->key_set,
743 (tkip->tx_iv32 >> 24) & 0xff,
744 (tkip->tx_iv32 >> 16) & 0xff,
745 (tkip->tx_iv32 >> 8) & 0xff,
746 tkip->tx_iv32 & 0xff,
747 (tkip->tx_iv16 >> 8) & 0xff,
748 tkip->tx_iv16 & 0xff,
749 (tkip->rx_iv32 >> 24) & 0xff,
750 (tkip->rx_iv32 >> 16) & 0xff,
751 (tkip->rx_iv32 >> 8) & 0xff,
752 tkip->rx_iv32 & 0xff,
753 (tkip->rx_iv16 >> 8) & 0xff,
754 tkip->rx_iv16 & 0xff,
755 tkip->dot11RSNAStatsTKIPReplays,
756 tkip->dot11RSNAStatsTKIPICVErrors,
757 tkip->dot11RSNAStatsTKIPLocalMICFailures);
758 return p;
759}
760
Jeff Garzikb4538722005-05-12 22:48:20 -0400761static struct ieee80211_crypto_ops ieee80211_crypt_tkip = {
James Ketrenos74079fd2005-09-13 17:35:21 -0500762 .name = "TKIP",
763 .init = ieee80211_tkip_init,
764 .deinit = ieee80211_tkip_deinit,
Zhu Yi9184d932006-01-19 16:22:32 +0800765 .build_iv = ieee80211_tkip_hdr,
James Ketrenos74079fd2005-09-13 17:35:21 -0500766 .encrypt_mpdu = ieee80211_tkip_encrypt,
767 .decrypt_mpdu = ieee80211_tkip_decrypt,
768 .encrypt_msdu = ieee80211_michael_mic_add,
769 .decrypt_msdu = ieee80211_michael_mic_verify,
770 .set_key = ieee80211_tkip_set_key,
771 .get_key = ieee80211_tkip_get_key,
772 .print_stats = ieee80211_tkip_print_stats,
James Ketrenos1264fc02005-09-21 11:54:53 -0500773 .extra_mpdu_prefix_len = 4 + 4, /* IV + ExtIV */
774 .extra_mpdu_postfix_len = 4, /* ICV */
775 .extra_msdu_postfix_len = 8, /* MIC */
James Ketrenos6eb6edf2005-09-22 10:34:15 +0000776 .get_flags = ieee80211_tkip_get_flags,
777 .set_flags = ieee80211_tkip_set_flags,
James Ketrenos74079fd2005-09-13 17:35:21 -0500778 .owner = THIS_MODULE,
Jeff Garzikb4538722005-05-12 22:48:20 -0400779};
780
Jeff Garzikb4538722005-05-12 22:48:20 -0400781static int __init ieee80211_crypto_tkip_init(void)
782{
783 return ieee80211_register_crypto_ops(&ieee80211_crypt_tkip);
784}
785
Jeff Garzikb4538722005-05-12 22:48:20 -0400786static void __exit ieee80211_crypto_tkip_exit(void)
787{
788 ieee80211_unregister_crypto_ops(&ieee80211_crypt_tkip);
789}
790
Jeff Garzikb4538722005-05-12 22:48:20 -0400791module_init(ieee80211_crypto_tkip_init);
792module_exit(ieee80211_crypto_tkip_exit);