1 // SPDX-License-Identifier: GPL-2.0
3 * Host AP crypt: host-based TKIP encryption implementation for Host AP driver
5 * Copyright (c) 2003-2004, Jouni Malinen <jkmaline@cc.hut.fi>
8 #include <crypto/arc4.h>
9 #include <crypto/hash.h>
10 #include <linux/fips.h>
11 #include <linux/module.h>
12 #include <linux/init.h>
13 #include <linux/slab.h>
14 #include <linux/random.h>
15 #include <linux/skbuff.h>
16 #include <linux/netdevice.h>
17 #include <linux/if_ether.h>
18 #include <linux/if_arp.h>
19 #include <linux/string.h>
20 #include <linux/crc32.h>
21 #include <linux/etherdevice.h>
25 struct rtllib_tkip_data {
26 #define TKIP_KEY_LEN 32
43 u32 dot11RSNAStatsTKIPReplays;
44 u32 dot11RSNAStatsTKIPICVErrors;
45 u32 dot11RSNAStatsTKIPLocalMICFailures;
48 struct arc4_ctx rx_ctx_arc4;
49 struct arc4_ctx tx_ctx_arc4;
50 struct crypto_shash *rx_tfm_michael;
51 struct crypto_shash *tx_tfm_michael;
52 /* scratch buffers for virt_to_page() (crypto API) */
57 static void *rtllib_tkip_init(int key_idx)
59 struct rtllib_tkip_data *priv;
64 priv = kzalloc(sizeof(*priv), GFP_ATOMIC);
67 priv->key_idx = key_idx;
69 priv->tx_tfm_michael = crypto_alloc_shash("michael_mic", 0, 0);
70 if (IS_ERR(priv->tx_tfm_michael)) {
71 pr_debug("Could not allocate crypto API michael_mic\n");
72 priv->tx_tfm_michael = NULL;
76 priv->rx_tfm_michael = crypto_alloc_shash("michael_mic", 0, 0);
77 if (IS_ERR(priv->rx_tfm_michael)) {
78 pr_debug("Could not allocate crypto API michael_mic\n");
79 priv->rx_tfm_michael = NULL;
86 crypto_free_shash(priv->tx_tfm_michael);
87 crypto_free_shash(priv->rx_tfm_michael);
95 static void rtllib_tkip_deinit(void *priv)
97 struct rtllib_tkip_data *_priv = priv;
100 crypto_free_shash(_priv->tx_tfm_michael);
101 crypto_free_shash(_priv->rx_tfm_michael);
103 kfree_sensitive(priv);
107 static inline u16 RotR1(u16 val)
109 return (val >> 1) | (val << 15);
113 static inline u8 Lo8(u16 val)
119 static inline u8 Hi8(u16 val)
125 static inline u16 Lo16(u32 val)
131 static inline u16 Hi16(u32 val)
137 static inline u16 Mk16(u8 hi, u8 lo)
139 return lo | (((u16) hi) << 8);
143 static inline u16 Mk16_le(u16 *v)
149 static const u16 Sbox[256] = {
150 0xC6A5, 0xF884, 0xEE99, 0xF68D, 0xFF0D, 0xD6BD, 0xDEB1, 0x9154,
151 0x6050, 0x0203, 0xCEA9, 0x567D, 0xE719, 0xB562, 0x4DE6, 0xEC9A,
152 0x8F45, 0x1F9D, 0x8940, 0xFA87, 0xEF15, 0xB2EB, 0x8EC9, 0xFB0B,
153 0x41EC, 0xB367, 0x5FFD, 0x45EA, 0x23BF, 0x53F7, 0xE496, 0x9B5B,
154 0x75C2, 0xE11C, 0x3DAE, 0x4C6A, 0x6C5A, 0x7E41, 0xF502, 0x834F,
155 0x685C, 0x51F4, 0xD134, 0xF908, 0xE293, 0xAB73, 0x6253, 0x2A3F,
156 0x080C, 0x9552, 0x4665, 0x9D5E, 0x3028, 0x37A1, 0x0A0F, 0x2FB5,
157 0x0E09, 0x2436, 0x1B9B, 0xDF3D, 0xCD26, 0x4E69, 0x7FCD, 0xEA9F,
158 0x121B, 0x1D9E, 0x5874, 0x342E, 0x362D, 0xDCB2, 0xB4EE, 0x5BFB,
159 0xA4F6, 0x764D, 0xB761, 0x7DCE, 0x527B, 0xDD3E, 0x5E71, 0x1397,
160 0xA6F5, 0xB968, 0x0000, 0xC12C, 0x4060, 0xE31F, 0x79C8, 0xB6ED,
161 0xD4BE, 0x8D46, 0x67D9, 0x724B, 0x94DE, 0x98D4, 0xB0E8, 0x854A,
162 0xBB6B, 0xC52A, 0x4FE5, 0xED16, 0x86C5, 0x9AD7, 0x6655, 0x1194,
163 0x8ACF, 0xE910, 0x0406, 0xFE81, 0xA0F0, 0x7844, 0x25BA, 0x4BE3,
164 0xA2F3, 0x5DFE, 0x80C0, 0x058A, 0x3FAD, 0x21BC, 0x7048, 0xF104,
165 0x63DF, 0x77C1, 0xAF75, 0x4263, 0x2030, 0xE51A, 0xFD0E, 0xBF6D,
166 0x814C, 0x1814, 0x2635, 0xC32F, 0xBEE1, 0x35A2, 0x88CC, 0x2E39,
167 0x9357, 0x55F2, 0xFC82, 0x7A47, 0xC8AC, 0xBAE7, 0x322B, 0xE695,
168 0xC0A0, 0x1998, 0x9ED1, 0xA37F, 0x4466, 0x547E, 0x3BAB, 0x0B83,
169 0x8CCA, 0xC729, 0x6BD3, 0x283C, 0xA779, 0xBCE2, 0x161D, 0xAD76,
170 0xDB3B, 0x6456, 0x744E, 0x141E, 0x92DB, 0x0C0A, 0x486C, 0xB8E4,
171 0x9F5D, 0xBD6E, 0x43EF, 0xC4A6, 0x39A8, 0x31A4, 0xD337, 0xF28B,
172 0xD532, 0x8B43, 0x6E59, 0xDAB7, 0x018C, 0xB164, 0x9CD2, 0x49E0,
173 0xD8B4, 0xACFA, 0xF307, 0xCF25, 0xCAAF, 0xF48E, 0x47E9, 0x1018,
174 0x6FD5, 0xF088, 0x4A6F, 0x5C72, 0x3824, 0x57F1, 0x73C7, 0x9751,
175 0xCB23, 0xA17C, 0xE89C, 0x3E21, 0x96DD, 0x61DC, 0x0D86, 0x0F85,
176 0xE090, 0x7C42, 0x71C4, 0xCCAA, 0x90D8, 0x0605, 0xF701, 0x1C12,
177 0xC2A3, 0x6A5F, 0xAEF9, 0x69D0, 0x1791, 0x9958, 0x3A27, 0x27B9,
178 0xD938, 0xEB13, 0x2BB3, 0x2233, 0xD2BB, 0xA970, 0x0789, 0x33A7,
179 0x2DB6, 0x3C22, 0x1592, 0xC920, 0x8749, 0xAAFF, 0x5078, 0xA57A,
180 0x038F, 0x59F8, 0x0980, 0x1A17, 0x65DA, 0xD731, 0x84C6, 0xD0B8,
181 0x82C3, 0x29B0, 0x5A77, 0x1E11, 0x7BCB, 0xA8FC, 0x6DD6, 0x2C3A,
185 static inline u16 _S_(u16 v)
187 u16 t = Sbox[Hi8(v)];
188 return Sbox[Lo8(v)] ^ ((t << 8) | (t >> 8));
192 #define PHASE1_LOOP_COUNT 8
195 static void tkip_mixing_phase1(u16 *TTAK, const u8 *TK, const u8 *TA, u32 IV32)
199 /* Initialize the 80-bit TTAK from TSC (IV32) and TA[0..5] */
200 TTAK[0] = Lo16(IV32);
201 TTAK[1] = Hi16(IV32);
202 TTAK[2] = Mk16(TA[1], TA[0]);
203 TTAK[3] = Mk16(TA[3], TA[2]);
204 TTAK[4] = Mk16(TA[5], TA[4]);
206 for (i = 0; i < PHASE1_LOOP_COUNT; i++) {
208 TTAK[0] += _S_(TTAK[4] ^ Mk16(TK[1 + j], TK[0 + j]));
209 TTAK[1] += _S_(TTAK[0] ^ Mk16(TK[5 + j], TK[4 + j]));
210 TTAK[2] += _S_(TTAK[1] ^ Mk16(TK[9 + j], TK[8 + j]));
211 TTAK[3] += _S_(TTAK[2] ^ Mk16(TK[13 + j], TK[12 + j]));
212 TTAK[4] += _S_(TTAK[3] ^ Mk16(TK[1 + j], TK[0 + j])) + i;
217 static void tkip_mixing_phase2(u8 *WEPSeed, const u8 *TK, const u16 *TTAK,
220 /* Make temporary area overlap WEP seed so that the final copy can be
221 * avoided on little endian hosts.
223 u16 *PPK = (u16 *) &WEPSeed[4];
225 /* Step 1 - make copy of TTAK and bring in TSC */
231 PPK[5] = TTAK[4] + IV16;
233 /* Step 2 - 96-bit bijective mixing using S-box */
234 PPK[0] += _S_(PPK[5] ^ Mk16_le((u16 *) &TK[0]));
235 PPK[1] += _S_(PPK[0] ^ Mk16_le((u16 *) &TK[2]));
236 PPK[2] += _S_(PPK[1] ^ Mk16_le((u16 *) &TK[4]));
237 PPK[3] += _S_(PPK[2] ^ Mk16_le((u16 *) &TK[6]));
238 PPK[4] += _S_(PPK[3] ^ Mk16_le((u16 *) &TK[8]));
239 PPK[5] += _S_(PPK[4] ^ Mk16_le((u16 *) &TK[10]));
241 PPK[0] += RotR1(PPK[5] ^ Mk16_le((u16 *) &TK[12]));
242 PPK[1] += RotR1(PPK[0] ^ Mk16_le((u16 *) &TK[14]));
243 PPK[2] += RotR1(PPK[1]);
244 PPK[3] += RotR1(PPK[2]);
245 PPK[4] += RotR1(PPK[3]);
246 PPK[5] += RotR1(PPK[4]);
248 /* Step 3 - bring in last of TK bits, assign 24-bit WEP IV value
249 * WEPSeed[0..2] is transmitted as WEP IV
251 WEPSeed[0] = Hi8(IV16);
252 WEPSeed[1] = (Hi8(IV16) | 0x20) & 0x7F;
253 WEPSeed[2] = Lo8(IV16);
254 WEPSeed[3] = Lo8((PPK[5] ^ Mk16_le((u16 *) &TK[0])) >> 1);
260 for (i = 0; i < 6; i++)
261 PPK[i] = (PPK[i] << 8) | (PPK[i] >> 8);
267 static int rtllib_tkip_encrypt(struct sk_buff *skb, int hdr_len, void *priv)
269 struct rtllib_tkip_data *tkey = priv;
272 struct rtllib_hdr_4addr *hdr;
273 struct cb_desc *tcb_desc = (struct cb_desc *)(skb->cb +
279 if (skb_headroom(skb) < 8 || skb_tailroom(skb) < 4 ||
283 hdr = (struct rtllib_hdr_4addr *) skb->data;
285 if (!tcb_desc->bHwSec) {
286 if (!tkey->tx_phase1_done) {
287 tkip_mixing_phase1(tkey->tx_ttak, tkey->key, hdr->addr2,
289 tkey->tx_phase1_done = 1;
291 tkip_mixing_phase2(rc4key, tkey->key, tkey->tx_ttak,
294 tkey->tx_phase1_done = 1;
297 len = skb->len - hdr_len;
298 pos = skb_push(skb, 8);
299 memmove(pos, pos + 8, hdr_len);
302 if (tcb_desc->bHwSec) {
303 *pos++ = Hi8(tkey->tx_iv16);
304 *pos++ = (Hi8(tkey->tx_iv16) | 0x20) & 0x7F;
305 *pos++ = Lo8(tkey->tx_iv16);
312 *pos++ = (tkey->key_idx << 6) | (1 << 5) /* Ext IV included */;
313 *pos++ = tkey->tx_iv32 & 0xff;
314 *pos++ = (tkey->tx_iv32 >> 8) & 0xff;
315 *pos++ = (tkey->tx_iv32 >> 16) & 0xff;
316 *pos++ = (tkey->tx_iv32 >> 24) & 0xff;
318 if (!tcb_desc->bHwSec) {
319 icv = skb_put(skb, 4);
320 crc = ~crc32_le(~0, pos, len);
326 arc4_setkey(&tkey->tx_ctx_arc4, rc4key, 16);
327 arc4_crypt(&tkey->tx_ctx_arc4, pos, pos, len + 4);
331 if (tkey->tx_iv16 == 0) {
332 tkey->tx_phase1_done = 0;
336 if (!tcb_desc->bHwSec)
343 static int rtllib_tkip_decrypt(struct sk_buff *skb, int hdr_len, void *priv)
345 struct rtllib_tkip_data *tkey = priv;
349 struct rtllib_hdr_4addr *hdr;
350 struct cb_desc *tcb_desc = (struct cb_desc *)(skb->cb +
357 if (skb->len < hdr_len + 8 + 4)
360 hdr = (struct rtllib_hdr_4addr *) skb->data;
361 pos = skb->data + hdr_len;
363 if (!(keyidx & (1 << 5))) {
364 if (net_ratelimit()) {
366 "Received packet without ExtIV flag from %pM\n",
372 if (tkey->key_idx != keyidx) {
374 "RX tkey->key_idx=%d frame keyidx=%d priv=%p\n",
375 tkey->key_idx, keyidx, priv);
378 if (!tkey->key_set) {
379 if (net_ratelimit()) {
381 "Received packet from %pM with keyid=%d that does not have a configured key\n",
386 iv16 = (pos[0] << 8) | pos[2];
387 iv32 = pos[4] | (pos[5] << 8) | (pos[6] << 16) | (pos[7] << 24);
390 if (!tcb_desc->bHwSec || (skb->cb[0] == 1)) {
391 if ((iv32 < tkey->rx_iv32 ||
392 (iv32 == tkey->rx_iv32 && iv16 <= tkey->rx_iv16)) &&
394 if (net_ratelimit()) {
396 "Replay detected: STA= %pM previous TSC %08x%04x received TSC %08x%04x\n",
397 hdr->addr2, tkey->rx_iv32,
398 tkey->rx_iv16, iv32, iv16);
400 tkey->dot11RSNAStatsTKIPReplays++;
403 tkey->initialized = true;
405 if (iv32 != tkey->rx_iv32 || !tkey->rx_phase1_done) {
406 tkip_mixing_phase1(tkey->rx_ttak, tkey->key,
408 tkey->rx_phase1_done = 1;
410 tkip_mixing_phase2(rc4key, tkey->key, tkey->rx_ttak, iv16);
412 plen = skb->len - hdr_len - 12;
414 arc4_setkey(&tkey->rx_ctx_arc4, rc4key, 16);
415 arc4_crypt(&tkey->rx_ctx_arc4, pos, pos, plen + 4);
417 crc = ~crc32_le(~0, pos, plen);
423 if (memcmp(icv, pos + plen, 4) != 0) {
424 if (iv32 != tkey->rx_iv32) {
425 /* Previously cached Phase1 result was already
426 * lost, so it needs to be recalculated for the
429 tkey->rx_phase1_done = 0;
431 if (net_ratelimit()) {
433 "ICV error detected: STA= %pM\n",
436 tkey->dot11RSNAStatsTKIPICVErrors++;
442 /* Update real counters only after Michael MIC verification has
445 tkey->rx_iv32_new = iv32;
446 tkey->rx_iv16_new = iv16;
448 /* Remove IV and ICV */
449 memmove(skb->data + 8, skb->data, hdr_len);
451 skb_trim(skb, skb->len - 4);
457 static int michael_mic(struct crypto_shash *tfm_michael, u8 *key, u8 *hdr,
458 u8 *data, size_t data_len, u8 *mic)
460 SHASH_DESC_ON_STACK(desc, tfm_michael);
463 desc->tfm = tfm_michael;
465 if (crypto_shash_setkey(tfm_michael, key, 8))
468 err = crypto_shash_init(desc);
471 err = crypto_shash_update(desc, hdr, 16);
474 err = crypto_shash_update(desc, data, data_len);
477 err = crypto_shash_final(desc, mic);
480 shash_desc_zero(desc);
484 static void michael_mic_hdr(struct sk_buff *skb, u8 *hdr)
486 struct rtllib_hdr_4addr *hdr11;
488 hdr11 = (struct rtllib_hdr_4addr *) skb->data;
489 switch (le16_to_cpu(hdr11->frame_ctl) &
490 (RTLLIB_FCTL_FROMDS | RTLLIB_FCTL_TODS)) {
491 case RTLLIB_FCTL_TODS:
492 ether_addr_copy(hdr, hdr11->addr3); /* DA */
493 ether_addr_copy(hdr + ETH_ALEN, hdr11->addr2); /* SA */
495 case RTLLIB_FCTL_FROMDS:
496 ether_addr_copy(hdr, hdr11->addr1); /* DA */
497 ether_addr_copy(hdr + ETH_ALEN, hdr11->addr3); /* SA */
499 case RTLLIB_FCTL_FROMDS | RTLLIB_FCTL_TODS:
500 ether_addr_copy(hdr, hdr11->addr3); /* DA */
501 ether_addr_copy(hdr + ETH_ALEN, hdr11->addr4); /* SA */
504 ether_addr_copy(hdr, hdr11->addr1); /* DA */
505 ether_addr_copy(hdr + ETH_ALEN, hdr11->addr2); /* SA */
509 hdr[12] = 0; /* priority */
511 hdr[13] = hdr[14] = hdr[15] = 0; /* reserved */
515 static int rtllib_michael_mic_add(struct sk_buff *skb, int hdr_len, void *priv)
517 struct rtllib_tkip_data *tkey = priv;
519 struct rtllib_hdr_4addr *hdr;
521 hdr = (struct rtllib_hdr_4addr *) skb->data;
523 if (skb_tailroom(skb) < 8 || skb->len < hdr_len) {
525 "Invalid packet for Michael MIC add (tailroom=%d hdr_len=%d skb->len=%d)\n",
526 skb_tailroom(skb), hdr_len, skb->len);
530 michael_mic_hdr(skb, tkey->tx_hdr);
532 if (RTLLIB_QOS_HAS_SEQ(le16_to_cpu(hdr->frame_ctl)))
533 tkey->tx_hdr[12] = *(skb->data + hdr_len - 2) & 0x07;
534 pos = skb_put(skb, 8);
535 if (michael_mic(tkey->tx_tfm_michael, &tkey->key[16], tkey->tx_hdr,
536 skb->data + hdr_len, skb->len - 8 - hdr_len, pos))
543 static void rtllib_michael_mic_failure(struct net_device *dev,
544 struct rtllib_hdr_4addr *hdr,
547 union iwreq_data wrqu;
548 struct iw_michaelmicfailure ev;
550 /* TODO: needed parameters: count, keyid, key type, TSC */
551 memset(&ev, 0, sizeof(ev));
552 ev.flags = keyidx & IW_MICFAILURE_KEY_ID;
553 if (hdr->addr1[0] & 0x01)
554 ev.flags |= IW_MICFAILURE_GROUP;
556 ev.flags |= IW_MICFAILURE_PAIRWISE;
557 ev.src_addr.sa_family = ARPHRD_ETHER;
558 ether_addr_copy(ev.src_addr.sa_data, hdr->addr2);
559 memset(&wrqu, 0, sizeof(wrqu));
560 wrqu.data.length = sizeof(ev);
561 wireless_send_event(dev, IWEVMICHAELMICFAILURE, &wrqu, (char *) &ev);
564 static int rtllib_michael_mic_verify(struct sk_buff *skb, int keyidx,
565 int hdr_len, void *priv)
567 struct rtllib_tkip_data *tkey = priv;
569 struct rtllib_hdr_4addr *hdr;
571 hdr = (struct rtllib_hdr_4addr *) skb->data;
576 michael_mic_hdr(skb, tkey->rx_hdr);
577 if (RTLLIB_QOS_HAS_SEQ(le16_to_cpu(hdr->frame_ctl)))
578 tkey->rx_hdr[12] = *(skb->data + hdr_len - 2) & 0x07;
580 if (michael_mic(tkey->rx_tfm_michael, &tkey->key[24], tkey->rx_hdr,
581 skb->data + hdr_len, skb->len - 8 - hdr_len, mic))
584 if (memcmp(mic, skb->data + skb->len - 8, 8) != 0) {
585 struct rtllib_hdr_4addr *hdr;
587 hdr = (struct rtllib_hdr_4addr *) skb->data;
589 "Michael MIC verification failed for MSDU from %pM keyidx=%d\n",
591 netdev_dbg(skb->dev, "%d\n",
592 memcmp(mic, skb->data + skb->len - 8, 8) != 0);
594 pr_info("skb->dev != NULL\n");
595 rtllib_michael_mic_failure(skb->dev, hdr, keyidx);
597 tkey->dot11RSNAStatsTKIPLocalMICFailures++;
601 /* Update TSC counters for RX now that the packet verification has
604 tkey->rx_iv32 = tkey->rx_iv32_new;
605 tkey->rx_iv16 = tkey->rx_iv16_new;
607 skb_trim(skb, skb->len - 8);
613 static int rtllib_tkip_set_key(void *key, int len, u8 *seq, void *priv)
615 struct rtllib_tkip_data *tkey = priv;
617 struct crypto_shash *tfm = tkey->tx_tfm_michael;
618 struct crypto_shash *tfm3 = tkey->rx_tfm_michael;
620 keyidx = tkey->key_idx;
621 memset(tkey, 0, sizeof(*tkey));
622 tkey->key_idx = keyidx;
623 tkey->tx_tfm_michael = tfm;
624 tkey->rx_tfm_michael = tfm3;
626 if (len == TKIP_KEY_LEN) {
627 memcpy(tkey->key, key, TKIP_KEY_LEN);
629 tkey->tx_iv16 = 1; /* TSC is initialized to 1 */
631 tkey->rx_iv32 = (seq[5] << 24) | (seq[4] << 16) |
632 (seq[3] << 8) | seq[2];
633 tkey->rx_iv16 = (seq[1] << 8) | seq[0];
644 static int rtllib_tkip_get_key(void *key, int len, u8 *seq, void *priv)
646 struct rtllib_tkip_data *tkey = priv;
648 if (len < TKIP_KEY_LEN)
653 memcpy(key, tkey->key, TKIP_KEY_LEN);
656 /* Return the sequence number of the last transmitted frame. */
657 u16 iv16 = tkey->tx_iv16;
658 u32 iv32 = tkey->tx_iv32;
663 seq[0] = tkey->tx_iv16;
664 seq[1] = tkey->tx_iv16 >> 8;
665 seq[2] = tkey->tx_iv32;
666 seq[3] = tkey->tx_iv32 >> 8;
667 seq[4] = tkey->tx_iv32 >> 16;
668 seq[5] = tkey->tx_iv32 >> 24;
675 static void rtllib_tkip_print_stats(struct seq_file *m, void *priv)
677 struct rtllib_tkip_data *tkip = priv;
680 "key[%d] alg=TKIP key_set=%d tx_pn=%02x%02x%02x%02x%02x%02x rx_pn=%02x%02x%02x%02x%02x%02x replays=%d icv_errors=%d local_mic_failures=%d\n",
681 tkip->key_idx, tkip->key_set,
682 (tkip->tx_iv32 >> 24) & 0xff,
683 (tkip->tx_iv32 >> 16) & 0xff,
684 (tkip->tx_iv32 >> 8) & 0xff,
685 tkip->tx_iv32 & 0xff,
686 (tkip->tx_iv16 >> 8) & 0xff,
687 tkip->tx_iv16 & 0xff,
688 (tkip->rx_iv32 >> 24) & 0xff,
689 (tkip->rx_iv32 >> 16) & 0xff,
690 (tkip->rx_iv32 >> 8) & 0xff,
691 tkip->rx_iv32 & 0xff,
692 (tkip->rx_iv16 >> 8) & 0xff,
693 tkip->rx_iv16 & 0xff,
694 tkip->dot11RSNAStatsTKIPReplays,
695 tkip->dot11RSNAStatsTKIPICVErrors,
696 tkip->dot11RSNAStatsTKIPLocalMICFailures);
699 static struct lib80211_crypto_ops rtllib_crypt_tkip = {
701 .init = rtllib_tkip_init,
702 .deinit = rtllib_tkip_deinit,
703 .encrypt_mpdu = rtllib_tkip_encrypt,
704 .decrypt_mpdu = rtllib_tkip_decrypt,
705 .encrypt_msdu = rtllib_michael_mic_add,
706 .decrypt_msdu = rtllib_michael_mic_verify,
707 .set_key = rtllib_tkip_set_key,
708 .get_key = rtllib_tkip_get_key,
709 .print_stats = rtllib_tkip_print_stats,
710 .extra_mpdu_prefix_len = 4 + 4, /* IV + ExtIV */
711 .extra_mpdu_postfix_len = 4, /* ICV */
712 .extra_msdu_postfix_len = 8, /* MIC */
713 .owner = THIS_MODULE,
717 static int __init rtllib_crypto_tkip_init(void)
719 return lib80211_register_crypto_ops(&rtllib_crypt_tkip);
723 static void __exit rtllib_crypto_tkip_exit(void)
725 lib80211_unregister_crypto_ops(&rtllib_crypt_tkip);
728 module_init(rtllib_crypto_tkip_init);
729 module_exit(rtllib_crypto_tkip_exit);
731 MODULE_LICENSE("GPL");