[svn-upgrade] new version madwifi (0.9.4+r4133.20100922)
[debian/madwifi.git] / net80211 / ieee80211_crypto_tkip.c
1 /*-
2  * Copyright (c) 2002-2005 Sam Leffler, Errno Consulting
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. The name of the author may not be used to endorse or promote products
14  *    derived from this software without specific prior written permission.
15  *
16  * Alternatively, this software may be distributed under the terms of the
17  * GNU General Public License ("GPL") version 2 as published by the Free
18  * Software Foundation.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
22  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
24  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
29  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  *
31  * $Id: ieee80211_crypto_tkip.c 4126 2010-03-23 22:50:36Z proski $
32  */
33
34 /*
35  * IEEE 802.11i TKIP crypto support.
36  *
37  * Part of this module is derived from similar code in the Host
38  * AP driver. The code is used with the consent of the author and
39  * it's license is included below.
40  */
41 #ifndef AUTOCONF_INCLUDED
42 #include <linux/config.h>
43 #endif
44 #include <linux/version.h>
45 #include <linux/module.h>
46 #include <linux/skbuff.h>
47 #include <linux/netdevice.h>
48 #include <linux/init.h>
49
50 #include "if_media.h"
51
52 #include <net80211/ieee80211_var.h>
53
54 static void *tkip_attach(struct ieee80211vap *, struct ieee80211_key *);
55 static void tkip_detach(struct ieee80211_key *);
56 static int tkip_setkey(struct ieee80211_key *);
57 static int tkip_encap(struct ieee80211_key *, struct sk_buff *, u_int8_t);
58 static int tkip_enmic(struct ieee80211_key *, struct sk_buff *, int);
59 static int tkip_decap(struct ieee80211_key *, struct sk_buff *, int);
60 static int tkip_demic(struct ieee80211_key *, struct sk_buff *, int);
61
62 static const struct ieee80211_cipher tkip  = {
63         .ic_name        = "TKIP",
64         .ic_cipher      = IEEE80211_CIPHER_TKIP,
65         .ic_header      = IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN +
66                           IEEE80211_WEP_EXTIVLEN,
67         .ic_trailer     = IEEE80211_WEP_CRCLEN,
68         .ic_miclen      = IEEE80211_WEP_MICLEN,
69         .ic_attach      = tkip_attach,
70         .ic_detach      = tkip_detach,
71         .ic_setkey      = tkip_setkey,
72         .ic_encap       = tkip_encap,
73         .ic_decap       = tkip_decap,
74         .ic_enmic       = tkip_enmic,
75         .ic_demic       = tkip_demic,
76 };
77
78 struct tkip_ctx {
79         struct ieee80211vap *tc_vap;    /* for diagnostics + statistics */
80         struct ieee80211com *tc_ic;
81
82         u16     tx_ttak[5];
83         int     tx_phase1_done;
84         u8      tx_rc4key[16];          /* XXX for test module; make locals? */
85
86         u16     rx_ttak[5];
87         int     rx_phase1_done;
88         u8      rx_rc4key[16];          /* XXX for test module; make locals? */
89         uint64_t rx_rsc;                /* held until MIC verified */
90 };
91
92 static void michael_mic(struct tkip_ctx *, const u8 *,
93         struct sk_buff *, u_int, size_t,
94         u8 mic[IEEE80211_WEP_MICLEN]);
95 static int tkip_encrypt(struct tkip_ctx *, struct ieee80211_key *,
96         struct sk_buff *, int);
97 static int tkip_decrypt(struct tkip_ctx *, struct ieee80211_key *,
98         struct sk_buff *, int);
99
100 static void *
101 tkip_attach(struct ieee80211vap *vap, struct ieee80211_key *k)
102 {
103         struct tkip_ctx *ctx;
104
105         _MOD_INC_USE(THIS_MODULE, return NULL);
106
107         MALLOC(ctx, struct tkip_ctx *, sizeof(struct tkip_ctx),
108                 M_DEVBUF, M_NOWAIT | M_ZERO);
109         if (ctx == NULL) {
110                 vap->iv_stats.is_crypto_nomem++;
111                 _MOD_DEC_USE(THIS_MODULE);
112                 return NULL;
113         }
114
115         ctx->tc_vap = vap;
116         ctx->tc_ic = vap->iv_ic;
117         return ctx;
118 }
119
120 static void
121 tkip_detach(struct ieee80211_key *k)
122 {
123         struct tkip_ctx *ctx = k->wk_private;
124
125         FREE(ctx, M_DEVBUF);
126
127         _MOD_DEC_USE(THIS_MODULE);
128 }
129
130 static int
131 tkip_setkey(struct ieee80211_key *k)
132 {
133         struct tkip_ctx *ctx = k->wk_private;
134
135         if (k->wk_keylen != (128 / NBBY)) {
136                 (void) ctx;             /* XXX */
137                 IEEE80211_DPRINTF(ctx->tc_vap, IEEE80211_MSG_CRYPTO,
138                         "%s: Invalid key length %u, expecting %u\n",
139                         __func__, k->wk_keylen, 128 / NBBY);
140                 return 0;
141         }
142         k->wk_keytsc = 1;               /* TSC starts at 1 */
143         return 1;
144 }
145
146 /*
147  * Add privacy headers and do any s/w encryption required.
148  */
149 static int
150 tkip_encap(struct ieee80211_key *k, struct sk_buff *skb, u_int8_t keyid)
151 {
152         struct tkip_ctx *ctx = k->wk_private;
153         struct ieee80211vap *vap = ctx->tc_vap;
154         struct ieee80211com *ic = ctx->tc_ic;
155         u_int8_t *ivp;
156         int hdrlen;
157
158         /*
159          * Handle TKIP counter measures requirement.
160          */
161         if (vap->iv_flags & IEEE80211_F_COUNTERM) {
162 #ifdef IEEE80211_DEBUG
163                 struct ieee80211_frame *wh =
164                         (struct ieee80211_frame *) skb->data;
165 #endif
166
167                 IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_CRYPTO, wh->i_addr2,
168                         "Discard frame due to countermeasures (%s)", __func__);
169                 vap->iv_stats.is_crypto_tkipcm++;
170                 return 0;
171         }
172         hdrlen = ieee80211_hdrspace(ic, skb->data);
173
174         /*
175          * Copy down 802.11 header and add the IV, KeyID, and ExtIV.
176          */
177         ivp = skb_push(skb, tkip.ic_header);
178         memmove(ivp, ivp + tkip.ic_header, hdrlen);
179         ivp += hdrlen;
180
181         ivp[0] = k->wk_keytsc >> 8;             /* TSC1 */
182         ivp[1] = (ivp[0] | 0x20) & 0x7f;        /* WEP seed */
183         ivp[2] = k->wk_keytsc >> 0;             /* TSC0 */
184         ivp[3] = keyid | IEEE80211_WEP_EXTIV;   /* KeyID | ExtID */
185         ivp[4] = k->wk_keytsc >> 16;            /* TSC2 */
186         ivp[5] = k->wk_keytsc >> 24;            /* TSC3 */
187         ivp[6] = k->wk_keytsc >> 32;            /* TSC4 */
188         ivp[7] = k->wk_keytsc >> 40;            /* TSC5 */
189
190         /*
191          * Finally, do software encrypt if needed.
192          */
193         if (k->wk_flags & IEEE80211_KEY_SWCRYPT) {
194                 if (!tkip_encrypt(ctx, k, skb, hdrlen))
195                         return 0;
196                 /* NB: tkip_encrypt handles wk_keytsc */
197         } else
198                 k->wk_keytsc++;
199
200         return 1;
201 }
202
203 /*
204  * Add MIC to the frame as needed.
205  */
206 static int
207 tkip_enmic(struct ieee80211_key *k, struct sk_buff *skb0, int force)
208 {
209         struct tkip_ctx *ctx = k->wk_private;
210
211         if (force || (k->wk_flags & IEEE80211_KEY_SWMIC)) {
212                 struct ieee80211_frame *wh =
213                         (struct ieee80211_frame *) skb0->data;
214                 struct ieee80211vap *vap = ctx->tc_vap;
215                 struct ieee80211com *ic = ctx->tc_ic;
216                 int hdrlen;
217                 struct sk_buff *skb;
218                 size_t data_len;
219                 uint8_t mic[IEEE80211_WEP_MICLEN];
220
221                 vap->iv_stats.is_crypto_tkipenmic++;
222
223                 skb = skb0;
224                 data_len = skb->len;
225                 while (skb->next != NULL) {
226                         skb = skb->next;
227                         data_len += skb->len;
228                 }
229                 if (skb_tailroom(skb) < tkip.ic_miclen) {
230                         /* NB: should not happen */
231                         IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_CRYPTO,
232                                 wh->i_addr1,
233                                 "No room for Michael MIC, tailroom %u",
234                                 skb_tailroom(skb));
235                         /* XXX statistic */
236                         return 0;
237                 }
238
239                 hdrlen = ieee80211_hdrspace(ic, wh);
240                 michael_mic(ctx, k->wk_txmic,
241                         skb0, hdrlen, data_len - hdrlen, mic);
242                 memcpy(skb_put(skb, tkip.ic_miclen), mic, tkip.ic_miclen);
243         }
244         return 1;
245 }
246
247 static __inline uint64_t
248 READ_6(uint8_t b0, uint8_t b1, uint8_t b2, uint8_t b3, uint8_t b4, uint8_t b5)
249 {
250         uint32_t iv32 = (b0 << 0) | (b1 << 8) | (b2 << 16) | (b3 << 24);
251         uint16_t iv16 = (b4 << 0) | (b5 << 8);
252         return (((uint64_t)iv16) << 32) | iv32;
253 }
254
255 /*
256  * Validate and strip privacy headers (and trailer) for a
257  * received frame.  If necessary, decrypt the frame using
258  * the specified key.
259  */
260 static int
261 tkip_decap(struct ieee80211_key *k, struct sk_buff *skb, int hdrlen)
262 {
263         struct tkip_ctx *ctx = k->wk_private;
264         struct ieee80211vap *vap = ctx->tc_vap;
265         struct ieee80211_frame *wh;
266         uint8_t *ivp;
267         u_int8_t tid;
268
269         /*
270          * Header should have extended IV and sequence number;
271          * verify the former and validate the latter.
272          */
273         wh = (struct ieee80211_frame *)skb->data;
274
275         ivp = skb->data + hdrlen;
276         if ((ivp[IEEE80211_WEP_IVLEN] & IEEE80211_WEP_EXTIV) == 0) {
277                 /*
278                  * No extended IV; discard frame.
279                  */
280                 IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_CRYPTO, wh->i_addr2,
281                         "%s", "missing ExtIV for TKIP cipher");
282                 vap->iv_stats.is_rx_tkipformat++;
283                 return 0;
284         }
285         /*
286          * Handle TKIP counter measures requirement.
287          */
288         if (vap->iv_flags & IEEE80211_F_COUNTERM) {
289                 IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_CRYPTO, wh->i_addr2,
290                         "discard frame due to countermeasures (%s)", __func__);
291                 vap->iv_stats.is_crypto_tkipcm++;
292                 return 0;
293         }
294
295         tid = 0;
296         if (IEEE80211_QOS_HAS_SEQ(wh)) 
297                 tid = ((struct ieee80211_qosframe *)wh)->i_qos[0] & IEEE80211_QOS_TID;
298
299         ctx->rx_rsc = READ_6(ivp[2], ivp[0], ivp[4], ivp[5], ivp[6], ivp[7]);
300         if (ctx->rx_rsc <= k->wk_keyrsc[tid]) {
301                 /*
302                  * Replay violation; notify upper layer.
303                  */
304                 ieee80211_notify_replay_failure(vap, wh, k, ctx->rx_rsc);
305                 vap->iv_stats.is_rx_tkipreplay++;
306                 return 0;
307         }
308         /*
309          * NB: We can't update the rsc in the key until MIC is verified.
310          *
311          * We assume we are not preempted between doing the check above
312          * and updating wk_keyrsc when stripping the MIC in tkip_demic.
313          * Otherwise we might process another packet and discard it as
314          * a replay.
315          */
316
317         /*
318          * Check if the device handled the decrypt in hardware.
319          * If so we just strip the header; otherwise we need to
320          * handle the decrypt in software.
321          */
322         if ((k->wk_flags & IEEE80211_KEY_SWCRYPT) &&
323             !tkip_decrypt(ctx, k, skb, hdrlen))
324                 return 0;
325
326         /*
327          * Copy up 802.11 header and strip crypto bits.
328          */
329         memmove(skb->data + tkip.ic_header, skb->data, hdrlen);
330         skb_pull(skb, tkip.ic_header);
331         while (skb->next != NULL)
332                 skb = skb->next;
333         skb_trim(skb, skb->len - tkip.ic_trailer);
334
335         return 1;
336 }
337
338 /*
339  * Verify and strip MIC from the frame.
340  */
341 static int
342 tkip_demic(struct ieee80211_key *k, struct sk_buff *skb0, int hdrlen)
343 {
344         struct tkip_ctx *ctx = k->wk_private;
345         struct sk_buff *skb;
346         size_t pktlen;
347         struct ieee80211_frame *wh ;
348         u_int8_t tid;
349
350         skb = skb0;
351         pktlen = skb->len;
352         while (skb->next != NULL) {
353                 skb = skb->next;
354                 pktlen += skb->len;
355         }
356         wh = (struct ieee80211_frame *) skb0->data;
357         /* NB: skb left pointing at last in chain */
358         if (k->wk_flags & IEEE80211_KEY_SWMIC) {
359                 struct ieee80211vap *vap = ctx->tc_vap;
360                 u8 mic[IEEE80211_WEP_MICLEN];
361                 u8 mic0[IEEE80211_WEP_MICLEN];
362
363                 vap->iv_stats.is_crypto_tkipdemic++;
364
365                 michael_mic(ctx, k->wk_rxmic, 
366                         skb0, hdrlen, pktlen - (hdrlen + tkip.ic_miclen),
367                         mic);
368                 /* XXX assert skb->len >= tkip.ic_miclen */
369                 memcpy(mic0, skb->data + skb->len - tkip.ic_miclen,
370                         tkip.ic_miclen);
371                 if (memcmp(mic, mic0, tkip.ic_miclen)) {
372                         /* NB: 802.11 layer handles statistic and debug msg */
373                         ieee80211_notify_michael_failure(vap, wh, k->wk_keyix);
374                         return 0;
375                 }
376         }
377         /*
378          * Strip MIC from the tail.
379          */
380         skb_trim(skb, skb->len - tkip.ic_miclen);
381
382         /*
383          * Ok to update rsc now that MIC has been verified.
384          */
385         tid = 0;
386         if (IEEE80211_QOS_HAS_SEQ(wh)) 
387                 tid = ((struct ieee80211_qosframe *)wh)->i_qos[0] & IEEE80211_QOS_TID;
388         k->wk_keyrsc[tid] = ctx->rx_rsc;
389
390         return 1;
391 }
392
393 /*
394  * Host AP crypt: host-based TKIP encryption implementation for Host AP driver
395  *
396  * Copyright (c) 2003-2004, Jouni Malinen <jkmaline@cc.hut.fi>
397  *
398  * This program is free software; you can redistribute it and/or modify
399  * it under the terms of the GNU General Public License version 2 as
400  * published by the Free Software Foundation. See README and COPYING for
401  * more details.
402  *
403  * Alternatively, this software may be distributed under the terms of BSD
404  * license.
405  */
406
407 static const __u32 crc32_table[256] = {
408         0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
409         0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
410         0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
411         0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
412         0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
413         0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
414         0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
415         0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
416         0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
417         0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
418         0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
419         0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
420         0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
421         0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
422         0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
423         0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
424         0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
425         0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
426         0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
427         0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
428         0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
429         0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
430         0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
431         0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
432         0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
433         0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
434         0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
435         0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
436         0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
437         0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
438         0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
439         0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
440         0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
441         0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
442         0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
443         0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
444         0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
445         0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
446         0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
447         0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
448         0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
449         0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
450         0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
451         0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
452         0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
453         0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
454         0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
455         0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
456         0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
457         0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
458         0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
459         0x2d02ef8dL
460 };
461
462 static __inline u16
463 RotR1(u16 val)
464 {
465         return (val >> 1) | (val << 15);
466 }
467
468 static __inline u8
469 Lo8(u16 val)
470 {
471         return val & 0xff;
472 }
473
474 static __inline u8
475 Hi8(u16 val)
476 {
477         return val >> 8;
478 }
479
480 static __inline u16
481 Lo16(u32 val)
482 {
483         return val & 0xffff;
484 }
485
486 static __inline u16
487 Hi16(u32 val)
488 {
489         return val >> 16;
490 }
491
492 static __inline u16
493 Mk16(u8 hi, u8 lo)
494 {
495         return lo | (((u16) hi) << 8);
496 }
497
498 static __inline u16
499 Mk16_le(const __le16 *v)
500 {
501         return le16_to_cpu(*v);
502 }
503
504 static const u16 Sbox[256] = {
505         0xC6A5, 0xF884, 0xEE99, 0xF68D, 0xFF0D, 0xD6BD, 0xDEB1, 0x9154,
506         0x6050, 0x0203, 0xCEA9, 0x567D, 0xE719, 0xB562, 0x4DE6, 0xEC9A,
507         0x8F45, 0x1F9D, 0x8940, 0xFA87, 0xEF15, 0xB2EB, 0x8EC9, 0xFB0B,
508         0x41EC, 0xB367, 0x5FFD, 0x45EA, 0x23BF, 0x53F7, 0xE496, 0x9B5B,
509         0x75C2, 0xE11C, 0x3DAE, 0x4C6A, 0x6C5A, 0x7E41, 0xF502, 0x834F,
510         0x685C, 0x51F4, 0xD134, 0xF908, 0xE293, 0xAB73, 0x6253, 0x2A3F,
511         0x080C, 0x9552, 0x4665, 0x9D5E, 0x3028, 0x37A1, 0x0A0F, 0x2FB5,
512         0x0E09, 0x2436, 0x1B9B, 0xDF3D, 0xCD26, 0x4E69, 0x7FCD, 0xEA9F,
513         0x121B, 0x1D9E, 0x5874, 0x342E, 0x362D, 0xDCB2, 0xB4EE, 0x5BFB,
514         0xA4F6, 0x764D, 0xB761, 0x7DCE, 0x527B, 0xDD3E, 0x5E71, 0x1397,
515         0xA6F5, 0xB968, 0x0000, 0xC12C, 0x4060, 0xE31F, 0x79C8, 0xB6ED,
516         0xD4BE, 0x8D46, 0x67D9, 0x724B, 0x94DE, 0x98D4, 0xB0E8, 0x854A,
517         0xBB6B, 0xC52A, 0x4FE5, 0xED16, 0x86C5, 0x9AD7, 0x6655, 0x1194,
518         0x8ACF, 0xE910, 0x0406, 0xFE81, 0xA0F0, 0x7844, 0x25BA, 0x4BE3,
519         0xA2F3, 0x5DFE, 0x80C0, 0x058A, 0x3FAD, 0x21BC, 0x7048, 0xF104,
520         0x63DF, 0x77C1, 0xAF75, 0x4263, 0x2030, 0xE51A, 0xFD0E, 0xBF6D,
521         0x814C, 0x1814, 0x2635, 0xC32F, 0xBEE1, 0x35A2, 0x88CC, 0x2E39,
522         0x9357, 0x55F2, 0xFC82, 0x7A47, 0xC8AC, 0xBAE7, 0x322B, 0xE695,
523         0xC0A0, 0x1998, 0x9ED1, 0xA37F, 0x4466, 0x547E, 0x3BAB, 0x0B83,
524         0x8CCA, 0xC729, 0x6BD3, 0x283C, 0xA779, 0xBCE2, 0x161D, 0xAD76,
525         0xDB3B, 0x6456, 0x744E, 0x141E, 0x92DB, 0x0C0A, 0x486C, 0xB8E4,
526         0x9F5D, 0xBD6E, 0x43EF, 0xC4A6, 0x39A8, 0x31A4, 0xD337, 0xF28B,
527         0xD532, 0x8B43, 0x6E59, 0xDAB7, 0x018C, 0xB164, 0x9CD2, 0x49E0,
528         0xD8B4, 0xACFA, 0xF307, 0xCF25, 0xCAAF, 0xF48E, 0x47E9, 0x1018,
529         0x6FD5, 0xF088, 0x4A6F, 0x5C72, 0x3824, 0x57F1, 0x73C7, 0x9751,
530         0xCB23, 0xA17C, 0xE89C, 0x3E21, 0x96DD, 0x61DC, 0x0D86, 0x0F85,
531         0xE090, 0x7C42, 0x71C4, 0xCCAA, 0x90D8, 0x0605, 0xF701, 0x1C12,
532         0xC2A3, 0x6A5F, 0xAEF9, 0x69D0, 0x1791, 0x9958, 0x3A27, 0x27B9,
533         0xD938, 0xEB13, 0x2BB3, 0x2233, 0xD2BB, 0xA970, 0x0789, 0x33A7,
534         0x2DB6, 0x3C22, 0x1592, 0xC920, 0x8749, 0xAAFF, 0x5078, 0xA57A,
535         0x038F, 0x59F8, 0x0980, 0x1A17, 0x65DA, 0xD731, 0x84C6, 0xD0B8,
536         0x82C3, 0x29B0, 0x5A77, 0x1E11, 0x7BCB, 0xA8FC, 0x6DD6, 0x2C3A,
537 };
538
539 static __inline u16
540 _S_(u16 v)
541 {
542         u16 t = Sbox[Hi8(v)];
543         return Sbox[Lo8(v)] ^ ((t << 8) | (t >> 8));
544 }
545
546 #define PHASE1_LOOP_COUNT 8
547
548 static void
549 tkip_mixing_phase1(u16 *TTAK, const u8 *TK, const u8 *TA, u32 IV32)
550 {
551         int i, j;
552
553         /* Initialize the 80-bit TTAK from TSC (IV32) and TA[0..5] */
554         TTAK[0] = Lo16(IV32);
555         TTAK[1] = Hi16(IV32);
556         TTAK[2] = Mk16(TA[1], TA[0]);
557         TTAK[3] = Mk16(TA[3], TA[2]);
558         TTAK[4] = Mk16(TA[5], TA[4]);
559
560         for (i = 0; i < PHASE1_LOOP_COUNT; i++) {
561                 j = 2 * (i & 1);
562                 TTAK[0] += _S_(TTAK[4] ^ Mk16(TK[1 + j], TK[0 + j]));
563                 TTAK[1] += _S_(TTAK[0] ^ Mk16(TK[5 + j], TK[4 + j]));
564                 TTAK[2] += _S_(TTAK[1] ^ Mk16(TK[9 + j], TK[8 + j]));
565                 TTAK[3] += _S_(TTAK[2] ^ Mk16(TK[13 + j], TK[12 + j]));
566                 TTAK[4] += _S_(TTAK[3] ^ Mk16(TK[1 + j], TK[0 + j])) + i;
567         }
568 }
569
570 #ifndef _BYTE_ORDER
571 #error "Don't know native byte order"
572 #endif
573
574 static void
575 tkip_mixing_phase2(u8 *WEPSeed, const u8 *TK, const u16 *TTAK, u16 IV16)
576 {
577         /* Make temporary area overlap WEP seed so that the final copy can be
578          * avoided on little endian hosts. */
579         u16 *PPK = (u16 *) &WEPSeed[4];
580
581         /* Step 1 - make copy of TTAK and bring in TSC */
582         PPK[0] = TTAK[0];
583         PPK[1] = TTAK[1];
584         PPK[2] = TTAK[2];
585         PPK[3] = TTAK[3];
586         PPK[4] = TTAK[4];
587         PPK[5] = TTAK[4] + IV16;
588
589         /* Step 2 - 96-bit bijective mixing using S-box */
590         PPK[0] += _S_(PPK[5] ^ Mk16_le((const __le16 *) &TK[0]));
591         PPK[1] += _S_(PPK[0] ^ Mk16_le((const __le16 *) &TK[2]));
592         PPK[2] += _S_(PPK[1] ^ Mk16_le((const __le16 *) &TK[4]));
593         PPK[3] += _S_(PPK[2] ^ Mk16_le((const __le16 *) &TK[6]));
594         PPK[4] += _S_(PPK[3] ^ Mk16_le((const __le16 *) &TK[8]));
595         PPK[5] += _S_(PPK[4] ^ Mk16_le((const __le16 *) &TK[10]));
596
597         PPK[0] += RotR1(PPK[5] ^ Mk16_le((const __le16 *) &TK[12]));
598         PPK[1] += RotR1(PPK[0] ^ Mk16_le((const __le16 *) &TK[14]));
599         PPK[2] += RotR1(PPK[1]);
600         PPK[3] += RotR1(PPK[2]);
601         PPK[4] += RotR1(PPK[3]);
602         PPK[5] += RotR1(PPK[4]);
603
604         /* Step 3 - bring in last of TK bits, assign 24-bit WEP IV value
605          * WEPSeed[0..2] is transmitted as WEP IV */
606         WEPSeed[0] = Hi8(IV16);
607         WEPSeed[1] = (Hi8(IV16) | 0x20) & 0x7F;
608         WEPSeed[2] = Lo8(IV16);
609         WEPSeed[3] = Lo8((PPK[5] ^ Mk16_le((const __le16 *) &TK[0])) >> 1);
610
611 #if _BYTE_ORDER == _BIG_ENDIAN
612         {
613                 int i;
614                 for (i = 0; i < 6; i++)
615                         PPK[i] = (PPK[i] << 8) | (PPK[i] >> 8);
616         }
617 #endif
618 }
619
620 static void
621 wep_encrypt(u8 *key, struct sk_buff *skb0, u_int off, size_t data_len)
622 {
623 #define S_SWAP(a,b) do { uint8_t t = S[a]; S[a] = S[b]; S[b] = t; } while(0)
624         struct sk_buff *skb = skb0;
625         uint32_t i, j, k, crc;
626         size_t buflen;
627         uint8_t S[256];
628         uint8_t *pos, *icv;
629
630         /* Setup RC4 state */
631         for (i = 0; i < 256; i++)
632                 S[i] = i;
633         j = 0;
634         for (i = 0; i < 256; i++) {
635                 j = (j + S[i] + key[i & 0x0f]) & 0xff;
636                 S_SWAP(i, j);
637         }
638
639         /* Compute CRC32 over unencrypted data and apply RC4 to data */
640         crc = ~0;
641         i = j = 0;
642         pos = skb->data + off;
643         buflen = skb->len - off;
644         for (;;) {
645                 if (buflen > data_len)
646                         buflen = data_len;
647                 data_len -= buflen;
648                 for (k = 0; k < buflen; k++) {
649                         crc = crc32_table[(crc ^ *pos) & 0xff] ^ (crc >> 8);
650                         i = (i + 1) & 0xff;
651                         j = (j + S[i]) & 0xff;
652                         S_SWAP(i, j);
653                         *pos++ ^= S[(S[i] + S[j]) & 0xff];
654                 }
655                 if (skb->next == NULL) {
656                         KASSERT(data_len == 0,
657                                 ("missing data, data_len %u", (int)data_len));
658                         break;
659                 }
660                 skb = skb->next;
661                 pos = skb->data;
662                 buflen = skb->len;
663         }
664         crc = ~crc;
665
666         icv = skb_put(skb, tkip.ic_trailer);
667         /* Append little-endian CRC32 and encrypt it to produce ICV */
668         icv[0] = crc;
669         icv[1] = crc >> 8;
670         icv[2] = crc >> 16;
671         icv[3] = crc >> 24;
672         for (k = 0; k < IEEE80211_WEP_CRCLEN; k++) {
673                 i = (i + 1) & 0xff;
674                 j = (j + S[i]) & 0xff;
675                 S_SWAP(i, j);
676                 icv[k] ^= S[(S[i] + S[j]) & 0xff];
677         }
678 #undef S_SWAP
679 }
680
681 static int
682 wep_decrypt(u8 *key, struct sk_buff *skb, u_int off, size_t data_len)
683 {
684 #define S_SWAP(a,b) do { uint8_t t = S[a]; S[a] = S[b]; S[b] = t; } while(0)
685         u32 i, j, k, crc;
686         u8 S[256];
687         u8 *pos, icv[4];
688         size_t buflen;
689
690         /* Setup RC4 state */
691         for (i = 0; i < 256; i++)
692                 S[i] = i;
693         j = 0;
694         for (i = 0; i < 256; i++) {
695                 j = (j + S[i] + key[i & 0x0f]) & 0xff;
696                 S_SWAP(i, j);
697         }
698
699         /* Apply RC4 to data and compute CRC32 over decrypted data */
700         crc = ~0;
701         i = j = 0;
702         pos = skb->data + off;
703         buflen = skb->len - off;
704         for (;;) {
705                 if (buflen > data_len)
706                         buflen = data_len;
707                 data_len -= buflen;
708                 for (k = 0; k < buflen; k++) {
709                         i = (i + 1) & 0xff;
710                         j = (j + S[i]) & 0xff;
711                         S_SWAP(i, j);
712                         *pos ^= S[(S[i] + S[j]) & 0xff];
713                         crc = crc32_table[(crc ^ *pos) & 0xff] ^ (crc >> 8);
714                         pos++;
715                 }
716                 if (skb->next == NULL) {
717                         if (data_len != 0) {
718                                 /* XXX msg? stat? cannot happen? */
719                                 return -1;
720                         }
721                         break;
722                 }
723                 skb = skb->next;
724                 pos = skb->data;
725                 buflen = skb->len;
726         }
727         crc = ~crc;
728
729         /* Encrypt little-endian CRC32 and verify that it matches with the
730          * received ICV */
731         icv[0] = crc;
732         icv[1] = crc >> 8;
733         icv[2] = crc >> 16;
734         icv[3] = crc >> 24;
735         for (k = 0; k < 4; k++) {
736                 i = (i + 1) & 0xff;
737                 j = (j + S[i]) & 0xff;
738                 S_SWAP(i, j);
739                 if ((icv[k] ^ S[(S[i] + S[j]) & 0xff]) != *pos++) {
740                         /* ICV mismatch - drop frame */
741                         return -1;
742                 }
743         }
744         return 0;
745 #undef S_SWAP
746 }
747
748
749 static __inline u32
750 rotl(u32 val, int bits)
751 {
752         return (val << bits) | (val >> (32 - bits));
753 }
754
755
756 static __inline u32
757 rotr(u32 val, int bits)
758 {
759         return (val >> bits) | (val << (32 - bits));
760 }
761
762
763 static __inline u32
764 xswap(u32 val)
765 {
766         return ((val & 0x00ff00ff) << 8) | ((val & 0xff00ff00) >> 8);
767 }
768
769
770 #define michael_block(l, r)     \
771 do {                            \
772         r ^= rotl(l, 17);       \
773         l += r;                 \
774         r ^= xswap(l);          \
775         l += r;                 \
776         r ^= rotl(l, 3);        \
777         l += r;                 \
778         r ^= rotr(l, 2);        \
779         l += r;                 \
780 } while (0)
781
782
783 static __inline u32
784 get_le32_split(u8 b0, u8 b1, u8 b2, u8 b3)
785 {
786         return b0 | (b1 << 8) | (b2 << 16) | (b3 << 24);
787 }
788
789 static __inline u32
790 get_le32(const u8 *p)
791 {
792         return get_le32_split(p[0], p[1], p[2], p[3]);
793 }
794
795
796 static __inline void
797 put_le32(u8 *p, u32 v)
798 {
799         p[0] = v;
800         p[1] = v >> 8;
801         p[2] = v >> 16;
802         p[3] = v >> 24;
803 }
804
805 /*
806  * Craft pseudo header used to calculate the MIC.
807  */
808 static void
809 michael_mic_hdr(const struct ieee80211_frame *wh0, u8 hdr[16])
810 {
811         const struct ieee80211_frame_addr4 *wh =
812                 (const struct ieee80211_frame_addr4 *) wh0;
813
814         switch (wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) {
815         case IEEE80211_FC1_DIR_NODS:
816                 IEEE80211_ADDR_COPY(hdr, wh->i_addr1); /* DA */
817                 IEEE80211_ADDR_COPY(hdr + IEEE80211_ADDR_LEN, wh->i_addr2);
818                 break;
819         case IEEE80211_FC1_DIR_TODS:
820                 IEEE80211_ADDR_COPY(hdr, wh->i_addr3); /* DA */
821                 IEEE80211_ADDR_COPY(hdr + IEEE80211_ADDR_LEN, wh->i_addr2);
822                 break;
823         case IEEE80211_FC1_DIR_FROMDS:
824                 IEEE80211_ADDR_COPY(hdr, wh->i_addr1); /* DA */
825                 IEEE80211_ADDR_COPY(hdr + IEEE80211_ADDR_LEN, wh->i_addr3);
826                 break;
827         case IEEE80211_FC1_DIR_DSTODS:
828                 IEEE80211_ADDR_COPY(hdr, wh->i_addr3); /* DA */
829                 IEEE80211_ADDR_COPY(hdr + IEEE80211_ADDR_LEN, wh->i_addr4);
830                 break;
831         }
832
833         if (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_QOS) {
834                 const struct ieee80211_qosframe *qwh =
835                         (const struct ieee80211_qosframe *) wh;
836                 hdr[12] = qwh->i_qos[0] & IEEE80211_QOS_TID;
837         } else
838                 hdr[12] = 0;
839         hdr[13] = hdr[14] = hdr[15] = 0; /* reserved */
840 }
841
842 static void
843 michael_mic(struct tkip_ctx *ctx, const u8 *key,
844         struct sk_buff *skb, u_int off, size_t data_len,
845         u8 mic[IEEE80211_WEP_MICLEN])
846 {
847         uint8_t hdr[16];
848         u32 l, r;
849         const uint8_t *data;
850         u_int space;
851
852         michael_mic_hdr((struct ieee80211_frame *) skb->data, hdr);
853
854         l = get_le32(key);
855         r = get_le32(key + 4);
856
857         /* Michael MIC pseudo header: DA, SA, 3 x 0, Priority */
858         l ^= get_le32(hdr);
859         michael_block(l, r);
860         l ^= get_le32(&hdr[4]);
861         michael_block(l, r);
862         l ^= get_le32(&hdr[8]);
863         michael_block(l, r);
864         l ^= get_le32(&hdr[12]);
865         michael_block(l, r);
866
867         /* first buffer has special handling */
868         data = skb->data + off;
869         space = skb->len - off;
870         for (;;) {
871                 if (space > data_len)
872                         space = data_len;
873                 /* collect 32-bit blocks from current buffer */
874                 while (space >= sizeof(uint32_t)) {
875                         l ^= get_le32(data);
876                         michael_block(l, r);
877                         data += sizeof(uint32_t), space -= sizeof(uint32_t);
878                         data_len -= sizeof(uint32_t);
879                 }
880                 if (data_len < sizeof(uint32_t))
881                         break;
882                 skb = skb->next;
883                 if (skb == NULL) {
884                         KASSERT(0, ("out of data, data_len %lu\n",
885                                     (unsigned long)data_len));
886                         break;
887                 }
888                 if (space != 0) {
889                         const uint8_t *data_next;
890                         /*
891                          * Block straddles buffers, split references.
892                          */
893                         data_next = skb->data;
894                         KASSERT(skb->len >= sizeof(uint32_t) - space,
895                                 ("not enough data in following buffer, "
896                                 "skb len %u need %u\n", skb->len,
897                                 (int)sizeof(uint32_t) - space));
898                         switch (space) {
899                         case 1:
900                                 l ^= get_le32_split(data[0], data_next[0],
901                                         data_next[1], data_next[2]);
902                                 data = data_next + 3;
903                                 space = skb->len - 3;
904                                 break;
905                         case 2:
906                                 l ^= get_le32_split(data[0], data[1],
907                                         data_next[0], data_next[1]);
908                                 data = data_next + 2;
909                                 space = skb->len - 2;
910                                 break;
911                         case 3:
912                                 l ^= get_le32_split(data[0], data[1],
913                                         data[2], data_next[0]);
914                                 data = data_next + 1;
915                                 space = skb->len - 1;
916                                 break;
917                         }
918                         michael_block(l, r);
919                         data_len -= sizeof(uint32_t);
920                 } else {
921                         /*
922                          * Setup for next buffer.
923                          */
924                         data = skb->data;
925                         space = skb->len;
926                 }
927         }
928         /* Last block and padding (0x5a, 4..7 x 0) */
929         switch (data_len) {
930         case 0:
931                 l ^= get_le32_split(0x5a, 0, 0, 0);
932                 break;
933         case 1:
934                 l ^= get_le32_split(data[0], 0x5a, 0, 0);
935                 break;
936         case 2:
937                 l ^= get_le32_split(data[0], data[1], 0x5a, 0);
938                 break;
939         case 3:
940                 l ^= get_le32_split(data[0], data[1], data[2], 0x5a);
941                 break;
942         }
943         michael_block(l, r);
944         /* l ^= 0; */
945         michael_block(l, r);
946
947         put_le32(mic, l);
948         put_le32(mic + 4, r);
949 }
950
951 static int
952 tkip_encrypt(struct tkip_ctx *ctx, struct ieee80211_key *key,
953         struct sk_buff *skb0, int hdrlen)
954 {
955         struct ieee80211_frame *wh = (struct ieee80211_frame *) skb0->data;
956         struct ieee80211vap *vap = ctx->tc_vap;
957         struct sk_buff *skb;
958         size_t pktlen;
959
960         vap->iv_stats.is_crypto_tkip++;
961
962         skb = skb0;
963         pktlen = skb->len;
964         while (skb->next != NULL) {
965                 skb = skb->next;
966                 pktlen += skb->len;
967         }
968         if (skb_tailroom(skb) < tkip.ic_trailer) {
969                 /* NB: should not happen */
970                 IEEE80211_NOTE_MAC(vap, IEEE80211_MSG_CRYPTO,
971                         wh->i_addr1, "No room for TKIP CRC, tailroom %u",
972                         skb_tailroom(skb));
973                 /* XXX statistic */
974                 return 0;
975         }
976
977         if (!ctx->tx_phase1_done) {
978                 tkip_mixing_phase1(ctx->tx_ttak, key->wk_key, wh->i_addr2,
979                         (u32)(key->wk_keytsc >> 16));
980                 ctx->tx_phase1_done = 1;
981         }
982         tkip_mixing_phase2(ctx->tx_rc4key, key->wk_key, ctx->tx_ttak,
983                 (u16) key->wk_keytsc);
984
985         wep_encrypt(ctx->tx_rc4key,
986                 skb0, hdrlen + tkip.ic_header,
987                 pktlen - (hdrlen + tkip.ic_header));
988
989         key->wk_keytsc++;
990         if ((u16)(key->wk_keytsc) == 0)
991                 ctx->tx_phase1_done = 0;
992         return 1;
993 }
994
995 static int
996 tkip_decrypt(struct tkip_ctx *ctx, struct ieee80211_key *key,
997         struct sk_buff *skb0, int hdrlen)
998 {
999         struct ieee80211_frame *wh = (struct ieee80211_frame *) skb0->data;
1000         struct ieee80211vap *vap = ctx->tc_vap;
1001         struct sk_buff *skb;
1002         size_t pktlen;
1003         u32 iv32;
1004         u16 iv16;
1005         u_int8_t tid;
1006
1007         vap->iv_stats.is_crypto_tkip++;
1008
1009         skb = skb0;
1010         pktlen = skb->len;
1011         while (skb->next != NULL) {
1012                 skb = skb->next;
1013                 pktlen += skb->len;
1014         }
1015         /* NB: tkip_decap already verified header and left seq in rx_rsc */
1016         iv16 = (u16) ctx->rx_rsc;
1017         iv32 = (u32) (ctx->rx_rsc >> 16);
1018
1019         wh = (struct ieee80211_frame *) skb0->data;
1020         tid = 0;
1021         if (IEEE80211_QOS_HAS_SEQ(wh)) 
1022                 tid = ((struct ieee80211_qosframe *)wh)->i_qos[0] & IEEE80211_QOS_TID;
1023         if (iv32 != (u32)(key->wk_keyrsc[tid] >> 16) || !ctx->rx_phase1_done) {
1024                 tkip_mixing_phase1(ctx->rx_ttak, key->wk_key,
1025                         wh->i_addr2, iv32);
1026                 ctx->rx_phase1_done = 1;
1027         }
1028         tkip_mixing_phase2(ctx->rx_rc4key, key->wk_key, ctx->rx_ttak, iv16);
1029
1030         /* NB: skb is unstripped; deduct headers + ICV to get payload */
1031         if (wep_decrypt(ctx->rx_rc4key,
1032             skb0, hdrlen + tkip.ic_header,
1033             pktlen - (hdrlen + tkip.ic_header + tkip.ic_trailer))) {
1034                 if (iv32 != (u32)(key->wk_keyrsc[tid] >> 16)) {
1035                         /* Previously cached Phase1 result was already lost, so
1036                          * it needs to be recalculated for the next packet. */
1037                         ctx->rx_phase1_done = 0;
1038                 }
1039                 IEEE80211_DPRINTF(vap, IEEE80211_MSG_CRYPTO,
1040                         "[%s] TKIP ICV mismatch on decrypt (keyix %d, rsc %llu)\n",
1041                         ether_sprintf(wh->i_addr2), key->wk_keyix, ctx->rx_rsc);
1042                 vap->iv_stats.is_rx_tkipicv++;
1043                 return 0;
1044         }
1045         return 1;
1046 }
1047
1048 /*
1049  * Module glue.
1050  */
1051 MODULE_AUTHOR("Errno Consulting, Sam Leffler");
1052 MODULE_DESCRIPTION("802.11 wireless support: TKIP cipher");
1053 #ifdef MODULE_LICENSE
1054 MODULE_LICENSE("Dual BSD/GPL");
1055 #endif
1056
1057 static int __init
1058 init_crypto_tkip(void)
1059 {
1060         ieee80211_crypto_register(&tkip);
1061         return 0;
1062 }
1063 module_init(init_crypto_tkip);
1064
1065 static void __exit
1066 exit_crypto_tkip(void)
1067 {
1068         ieee80211_crypto_unregister(&tkip);
1069 }
1070 module_exit(exit_crypto_tkip);