net/mac80211/wpa.c

   1 /*
   2  * Copyright 2002-2004, Instant802 Networks, Inc.
   3  * Copyright 2008, Jouni Malinen <j@w1.fi>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  */
   9
  10 #include <linux/netdevice.h>
  11 #include <linux/types.h>
  12 #include <linux/skbuff.h>
  13 #include <linux/compiler.h>
  14 #include <linux/ieee80211.h>
  15 #include <linux/gfp.h>
  16 #include <asm/unaligned.h>
  17 #include <net/mac80211.h>
  18
  19 #include "ieee80211_i.h"
  20 #include "michael.h"
  21 #include "tkip.h"
  22 #include "aes_ccm.h"
  23 #include "aes_cmac.h"
  24 #include "wpa.h"
  25
  26 ieee80211_tx_result
  27 ieee80211_tx_h_michael_mic_add(struct ieee80211_tx_data *tx)
  28 {
  29         u8 *data, *key, *mic;
  30         size_t data_len;
  31         unsigned int hdrlen;
  32         struct ieee80211_hdr *hdr;
  33         struct sk_buff *skb = tx->skb;
  34         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
  35         int tail;
  36
  37         hdr = (struct ieee80211_hdr *)skb->data;
  38         if (!tx->key || tx->key->conf.cipher != WLAN_CIPHER_SUITE_TKIP ||
  39             skb->len < 24 || !ieee80211_is_data_present(hdr->frame_control))
  40                 return TX_CONTINUE;
  41
  42         hdrlen = ieee80211_hdrlen(hdr->frame_control);
  43         if (skb->len < hdrlen)
  44                 return TX_DROP;
  45
  46         data = skb->data + hdrlen;
  47         data_len = skb->len - hdrlen;
  48
  49         if (unlikely(info->flags & IEEE80211_TX_INTFL_TKIP_MIC_FAILURE)) {
  50                 /* Need to use software crypto for the test */
  51                 info->control.hw_key = NULL;
  52         }
  53
  54         if (info->control.hw_key &&
  55             !(tx->flags & IEEE80211_TX_FRAGMENTED) &&
  56             !(tx->key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_MMIC)) {
  57                 /* hwaccel - with no need for SW-generated MMIC */
  58                 return TX_CONTINUE;
  59         }
  60
  61         tail = MICHAEL_MIC_LEN;
  62         if (!info->control.hw_key)
  63                 tail += TKIP_ICV_LEN;
  64
  65         if (WARN_ON(skb_tailroom(skb) < tail ||
  66                     skb_headroom(skb) < TKIP_IV_LEN))
  67                 return TX_DROP;
  68
  69         key = &tx->key->conf.key[NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY];
  70         mic = skb_put(skb, MICHAEL_MIC_LEN);
  71         michael_mic(key, hdr, data, data_len, mic);
  72         if (unlikely(info->flags & IEEE80211_TX_INTFL_TKIP_MIC_FAILURE))
  73                 mic[0]++;
  74
  75         return TX_CONTINUE;
  76 }
  77
  78
  79 ieee80211_rx_result
  80 ieee80211_rx_h_michael_mic_verify(struct ieee80211_rx_data *rx)
  81 {
  82         u8 *data, *key = NULL;
  83         size_t data_len;
  84         unsigned int hdrlen;
  85         u8 mic[MICHAEL_MIC_LEN];
  86         struct sk_buff *skb = rx->skb;
  87         struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
  88         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
  89
  90         /*
  91          * it makes no sense to check for MIC errors on anything other
  92          * than data frames.
  93          */
  94         if (!ieee80211_is_data_present(hdr->frame_control))
  95                 return RX_CONTINUE;
  96
  97         /*
  98          * No way to verify the MIC if the hardware stripped it or
  99          * the IV with the key index. In this case we have solely rely
 100          * on the driver to set RX_FLAG_MMIC_ERROR in the event of a
 101          * MIC failure report.
 102          */
 103         if (status->flag & (RX_FLAG_MMIC_STRIPPED | RX_FLAG_IV_STRIPPED)) {
 104                 if (status->flag & RX_FLAG_MMIC_ERROR)
 105                         goto mic_fail;
 106
 107                 if (!(status->flag & RX_FLAG_IV_STRIPPED))
 108                         goto update_iv;
 109
 110                 return RX_CONTINUE;
 111         }
 112
 113         /*
 114          * Some hardware seems to generate Michael MIC failure reports; even
 115          * though, the frame was not encrypted with TKIP and therefore has no
 116          * MIC. Ignore the flag them to avoid triggering countermeasures.
 117          */
 118         if (!rx->key || rx->key->conf.cipher != WLAN_CIPHER_SUITE_TKIP ||
 119             !(status->flag & RX_FLAG_DECRYPTED))
 120                 return RX_CONTINUE;
 121
 122         if (rx->sdata->vif.type == NL80211_IFTYPE_AP && rx->key->conf.keyidx) {
 123                 /*
 124                  * APs with pairwise keys should never receive Michael MIC
 125                  * errors for non-zero keyidx because these are reserved for
 126                  * group keys and only the AP is sending real multicast
 127                  * frames in the BSS. (
 128                  */
 129                 return RX_DROP_UNUSABLE;
 130         }
 131
 132         if (status->flag & RX_FLAG_MMIC_ERROR)
 133                 goto mic_fail;
 134
 135         hdrlen = ieee80211_hdrlen(hdr->frame_control);
 136         if (skb->len < hdrlen + MICHAEL_MIC_LEN)
 137                 return RX_DROP_UNUSABLE;
 138
 139         data = skb->data + hdrlen;
 140         data_len = skb->len - hdrlen - MICHAEL_MIC_LEN;
 141         key = &rx->key->conf.key[NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY];
 142         michael_mic(key, hdr, data, data_len, mic);
 143         if (memcmp(mic, data + data_len, MICHAEL_MIC_LEN) != 0)
 144                 goto mic_fail;
 145
 146         /* remove Michael MIC from payload */
 147         skb_trim(skb, skb->len - MICHAEL_MIC_LEN);
 148
 149 update_iv:
 150         /* update IV in key information to be able to detect replays */
 151         rx->key->u.tkip.rx[rx->queue].iv32 = rx->tkip_iv32;
 152         rx->key->u.tkip.rx[rx->queue].iv16 = rx->tkip_iv16;
 153
 154         return RX_CONTINUE;
 155
 156 mic_fail:
 157         mac80211_ev_michael_mic_failure(rx->sdata, rx->key->conf.keyidx,
 158                                         (void *) skb->data, NULL, GFP_ATOMIC);
 159         return RX_DROP_UNUSABLE;
 160 }
 161
 162
 163 static int tkip_encrypt_skb(struct ieee80211_tx_data *tx, struct sk_buff *skb)
 164 {
 165         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
 166         struct ieee80211_key *key = tx->key;
 167         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 168         unsigned int hdrlen;
 169         int len, tail;
 170         u8 *pos;
 171
 172         if (info->control.hw_key &&
 173             !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_GENERATE_IV)) {
 174                 /* hwaccel - with no need for software-generated IV */
 175                 return 0;
 176         }
 177
 178         hdrlen = ieee80211_hdrlen(hdr->frame_control);
 179         len = skb->len - hdrlen;
 180
 181         if (info->control.hw_key)
 182                 tail = 0;
 183         else
 184                 tail = TKIP_ICV_LEN;
 185
 186         if (WARN_ON(skb_tailroom(skb) < tail ||
 187                     skb_headroom(skb) < TKIP_IV_LEN))
 188                 return -1;
 189
 190         pos = skb_push(skb, TKIP_IV_LEN);
 191         memmove(pos, pos + TKIP_IV_LEN, hdrlen);
 192         pos += hdrlen;
 193
 194         /* Increase IV for the frame */
 195         key->u.tkip.tx.iv16++;
 196         if (key->u.tkip.tx.iv16 == 0)
 197                 key->u.tkip.tx.iv32++;
 198
 199         pos = ieee80211_tkip_add_iv(pos, key, key->u.tkip.tx.iv16);
 200
 201         /* hwaccel - with software IV */
 202         if (info->control.hw_key)
 203                 return 0;
 204
 205         /* Add room for ICV */
 206         skb_put(skb, TKIP_ICV_LEN);
 207
 208         hdr = (struct ieee80211_hdr *) skb->data;
 209         return ieee80211_tkip_encrypt_data(tx->local->wep_tx_tfm,
 210                                            key, pos, len, hdr->addr2);
 211 }
 212
 213
 214 ieee80211_tx_result
 215 ieee80211_crypto_tkip_encrypt(struct ieee80211_tx_data *tx)
 216 {
 217         struct sk_buff *skb = tx->skb;
 218
 219         ieee80211_tx_set_protected(tx);
 220
 221         do {
 222                 if (tkip_encrypt_skb(tx, skb) < 0)
 223                         return TX_DROP;
 224         } while ((skb = skb->next));
 225
 226         return TX_CONTINUE;
 227 }
 228
 229
 230 ieee80211_rx_result
 231 ieee80211_crypto_tkip_decrypt(struct ieee80211_rx_data *rx)
 232 {
 233         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) rx->skb->data;
 234         int hdrlen, res, hwaccel = 0;
 235         struct ieee80211_key *key = rx->key;
 236         struct sk_buff *skb = rx->skb;
 237         struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
 238
 239         hdrlen = ieee80211_hdrlen(hdr->frame_control);
 240
 241         if (!ieee80211_is_data(hdr->frame_control))
 242                 return RX_CONTINUE;
 243
 244         if (!rx->sta || skb->len - hdrlen < 12)
 245                 return RX_DROP_UNUSABLE;
 246
 247         /*
 248          * Let TKIP code verify IV, but skip decryption.
 249          * In the case where hardware checks the IV as well,
 250          * we don't even get here, see ieee80211_rx_h_decrypt()
 251          */
 252         if (status->flag & RX_FLAG_DECRYPTED)
 253                 hwaccel = 1;
 254
 255         res = ieee80211_tkip_decrypt_data(rx->local->wep_rx_tfm,
 256                                           key, skb->data + hdrlen,
 257                                           skb->len - hdrlen, rx->sta->sta.addr,
 258                                           hdr->addr1, hwaccel, rx->queue,
 259                                           &rx->tkip_iv32,
 260                                           &rx->tkip_iv16);
 261         if (res != TKIP_DECRYPT_OK)
 262                 return RX_DROP_UNUSABLE;
 263
 264         /* Trim ICV */
 265         skb_trim(skb, skb->len - TKIP_ICV_LEN);
 266
 267         /* Remove IV */
 268         memmove(skb->data + TKIP_IV_LEN, skb->data, hdrlen);
 269         skb_pull(skb, TKIP_IV_LEN);
 270
 271         return RX_CONTINUE;
 272 }
 273
 274
 275 static void ccmp_special_blocks(struct sk_buff *skb, u8 *pn, u8 *scratch,
 276                                 int encrypted)
 277 {
 278         __le16 mask_fc;
 279         int a4_included, mgmt;
 280         u8 qos_tid;
 281         u8 *b_0, *aad;
 282         u16 data_len, len_a;
 283         unsigned int hdrlen;
 284         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
 285
 286         b_0 = scratch + 3 * AES_BLOCK_LEN;
 287         aad = scratch + 4 * AES_BLOCK_LEN;
 288
 289         /*
 290          * Mask FC: zero subtype b4 b5 b6 (if not mgmt)
 291          * Retry, PwrMgt, MoreData; set Protected
 292          */
 293         mgmt = ieee80211_is_mgmt(hdr->frame_control);
 294         mask_fc = hdr->frame_control;
 295         mask_fc &= ~cpu_to_le16(IEEE80211_FCTL_RETRY |
 296                                 IEEE80211_FCTL_PM | IEEE80211_FCTL_MOREDATA);
 297         if (!mgmt)
 298                 mask_fc &= ~cpu_to_le16(0x0070);
 299         mask_fc |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
 300
 301         hdrlen = ieee80211_hdrlen(hdr->frame_control);
 302         len_a = hdrlen - 2;
 303         a4_included = ieee80211_has_a4(hdr->frame_control);
 304
 305         if (ieee80211_is_data_qos(hdr->frame_control))
 306                 qos_tid = *ieee80211_get_qos_ctl(hdr) & IEEE80211_QOS_CTL_TID_MASK;
 307         else
 308                 qos_tid = 0;
 309
 310         data_len = skb->len - hdrlen - CCMP_HDR_LEN;
 311         if (encrypted)
 312                 data_len -= CCMP_MIC_LEN;
 313
 314         /* First block, b_0 */
 315         b_0[0] = 0x59; /* flags: Adata: 1, M: 011, L: 001 */
 316         /* Nonce: Nonce Flags | A2 | PN
 317          * Nonce Flags: Priority (b0..b3) | Management (b4) | Reserved (b5..b7)
 318          */
 319         b_0[1] = qos_tid | (mgmt << 4);
 320         memcpy(&b_0[2], hdr->addr2, ETH_ALEN);
 321         memcpy(&b_0[8], pn, CCMP_PN_LEN);
 322         /* l(m) */
 323         put_unaligned_be16(data_len, &b_0[14]);
 324
 325         /* AAD (extra authenticate-only data) / masked 802.11 header
 326          * FC | A1 | A2 | A3 | SC | [A4] | [QC] */
 327         put_unaligned_be16(len_a, &aad[0]);
 328         put_unaligned(mask_fc, (__le16 *)&aad[2]);
 329         memcpy(&aad[4], &hdr->addr1, 3 * ETH_ALEN);
 330
 331         /* Mask Seq#, leave Frag# */
 332         aad[22] = *((u8 *) &hdr->seq_ctrl) & 0x0f;
 333         aad[23] = 0;
 334
 335         if (a4_included) {
 336                 memcpy(&aad[24], hdr->addr4, ETH_ALEN);
 337                 aad[30] = qos_tid;
 338                 aad[31] = 0;
 339         } else {
 340                 memset(&aad[24], 0, ETH_ALEN + IEEE80211_QOS_CTL_LEN);
 341                 aad[24] = qos_tid;
 342         }
 343 }
 344
 345
 346 static inline void ccmp_pn2hdr(u8 *hdr, u8 *pn, int key_id)
 347 {
 348         hdr[0] = pn[5];
 349         hdr[1] = pn[4];
 350         hdr[2] = 0;
 351         hdr[3] = 0x20 | (key_id << 6);
 352         hdr[4] = pn[3];
 353         hdr[5] = pn[2];
 354         hdr[6] = pn[1];
 355         hdr[7] = pn[0];
 356 }
 357
 358
 359 static inline void ccmp_hdr2pn(u8 *pn, u8 *hdr)
 360 {
 361         pn[0] = hdr[7];
 362         pn[1] = hdr[6];
 363         pn[2] = hdr[5];
 364         pn[3] = hdr[4];
 365         pn[4] = hdr[1];
 366         pn[5] = hdr[0];
 367 }
 368
 369
 370 static int ccmp_encrypt_skb(struct ieee80211_tx_data *tx, struct sk_buff *skb)
 371 {
 372         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
 373         struct ieee80211_key *key = tx->key;
 374         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 375         int hdrlen, len, tail;
 376         u8 *pos, *pn;
 377         int i;
 378
 379         if (info->control.hw_key &&
 380             !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_GENERATE_IV)) {
 381                 /*
 382                  * hwaccel has no need for preallocated room for CCMP
 383                  * header or MIC fields
 384                  */
 385                 return 0;
 386         }
 387
 388         hdrlen = ieee80211_hdrlen(hdr->frame_control);
 389         len = skb->len - hdrlen;
 390
 391         if (info->control.hw_key)
 392                 tail = 0;
 393         else
 394                 tail = CCMP_MIC_LEN;
 395
 396         if (WARN_ON(skb_tailroom(skb) < tail ||
 397                     skb_headroom(skb) < CCMP_HDR_LEN))
 398                 return -1;
 399
 400         pos = skb_push(skb, CCMP_HDR_LEN);
 401         memmove(pos, pos + CCMP_HDR_LEN, hdrlen);
 402         hdr = (struct ieee80211_hdr *) pos;
 403         pos += hdrlen;
 404
 405         /* PN = PN + 1 */
 406         pn = key->u.ccmp.tx_pn;
 407
 408         for (i = CCMP_PN_LEN - 1; i >= 0; i--) {
 409                 pn[i]++;
 410                 if (pn[i])
 411                         break;
 412         }
 413
 414         ccmp_pn2hdr(pos, pn, key->conf.keyidx);
 415
 416         /* hwaccel - with software CCMP header */
 417         if (info->control.hw_key)
 418                 return 0;
 419
 420         pos += CCMP_HDR_LEN;
 421         ccmp_special_blocks(skb, pn, key->u.ccmp.tx_crypto_buf, 0);
 422         ieee80211_aes_ccm_encrypt(key->u.ccmp.tfm, key->u.ccmp.tx_crypto_buf, pos, len,
 423                                   pos, skb_put(skb, CCMP_MIC_LEN));
 424
 425         return 0;
 426 }
 427
 428
 429 ieee80211_tx_result
 430 ieee80211_crypto_ccmp_encrypt(struct ieee80211_tx_data *tx)
 431 {
 432         struct sk_buff *skb = tx->skb;
 433
 434         ieee80211_tx_set_protected(tx);
 435
 436         do {
 437                 if (ccmp_encrypt_skb(tx, skb) < 0)
 438                         return TX_DROP;
 439         } while ((skb = skb->next));
 440
 441         return TX_CONTINUE;
 442 }
 443
 444
 445 ieee80211_rx_result
 446 ieee80211_crypto_ccmp_decrypt(struct ieee80211_rx_data *rx)
 447 {
 448         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
 449         int hdrlen;
 450         struct ieee80211_key *key = rx->key;
 451         struct sk_buff *skb = rx->skb;
 452         struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
 453         u8 pn[CCMP_PN_LEN];
 454         int data_len;
 455         int queue;
 456
 457         hdrlen = ieee80211_hdrlen(hdr->frame_control);
 458
 459         if (!ieee80211_is_data(hdr->frame_control) &&
 460             !ieee80211_is_robust_mgmt_frame(hdr))
 461                 return RX_CONTINUE;
 462
 463         data_len = skb->len - hdrlen - CCMP_HDR_LEN - CCMP_MIC_LEN;
 464         if (!rx->sta || data_len < 0)
 465                 return RX_DROP_UNUSABLE;
 466
 467         ccmp_hdr2pn(pn, skb->data + hdrlen);
 468
 469         queue = ieee80211_is_mgmt(hdr->frame_control) ?
 470                 NUM_RX_DATA_QUEUES : rx->queue;
 471
 472         if (memcmp(pn, key->u.ccmp.rx_pn[queue], CCMP_PN_LEN) <= 0) {
 473                 key->u.ccmp.replays++;
 474                 return RX_DROP_UNUSABLE;
 475         }
 476
 477         if (!(status->flag & RX_FLAG_DECRYPTED)) {
 478                 /* hardware didn't decrypt/verify MIC */
 479                 ccmp_special_blocks(skb, pn, key->u.ccmp.rx_crypto_buf, 1);
 480
 481                 if (ieee80211_aes_ccm_decrypt(
 482                             key->u.ccmp.tfm, key->u.ccmp.rx_crypto_buf,
 483                             skb->data + hdrlen + CCMP_HDR_LEN, data_len,
 484                             skb->data + skb->len - CCMP_MIC_LEN,
 485                             skb->data + hdrlen + CCMP_HDR_LEN))
 486                         return RX_DROP_UNUSABLE;
 487         }
 488
 489         memcpy(key->u.ccmp.rx_pn[queue], pn, CCMP_PN_LEN);
 490
 491         /* Remove CCMP header and MIC */
 492         skb_trim(skb, skb->len - CCMP_MIC_LEN);
 493         memmove(skb->data + CCMP_HDR_LEN, skb->data, hdrlen);
 494         skb_pull(skb, CCMP_HDR_LEN);
 495
 496         return RX_CONTINUE;
 497 }
 498
 499
 500 static void bip_aad(struct sk_buff *skb, u8 *aad)
 501 {
 502         /* BIP AAD: FC(masked) || A1 || A2 || A3 */
 503
 504         /* FC type/subtype */
 505         aad[0] = skb->data[0];
 506         /* Mask FC Retry, PwrMgt, MoreData flags to zero */
 507         aad[1] = skb->data[1] & ~(BIT(4) | BIT(5) | BIT(6));
 508         /* A1 || A2 || A3 */
 509         memcpy(aad + 2, skb->data + 4, 3 * ETH_ALEN);
 510 }
 511
 512
 513 static inline void bip_ipn_swap(u8 *d, const u8 *s)
 514 {
 515         *d++ = s[5];
 516         *d++ = s[4];
 517         *d++ = s[3];
 518         *d++ = s[2];
 519         *d++ = s[1];
 520         *d = s[0];
 521 }
 522
 523
 524 ieee80211_tx_result
 525 ieee80211_crypto_aes_cmac_encrypt(struct ieee80211_tx_data *tx)
 526 {
 527         struct sk_buff *skb = tx->skb;
 528         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 529         struct ieee80211_key *key = tx->key;
 530         struct ieee80211_mmie *mmie;
 531         u8 *pn, aad[20];
 532         int i;
 533
 534         if (info->control.hw_key)
 535                 return 0;
 536
 537         if (WARN_ON(skb_tailroom(skb) < sizeof(*mmie)))
 538                 return TX_DROP;
 539
 540         mmie = (struct ieee80211_mmie *) skb_put(skb, sizeof(*mmie));
 541         mmie->element_id = WLAN_EID_MMIE;
 542         mmie->length = sizeof(*mmie) - 2;
 543         mmie->key_id = cpu_to_le16(key->conf.keyidx);
 544
 545         /* PN = PN + 1 */
 546         pn = key->u.aes_cmac.tx_pn;
 547
 548         for (i = sizeof(key->u.aes_cmac.tx_pn) - 1; i >= 0; i--) {
 549                 pn[i]++;
 550                 if (pn[i])
 551                         break;
 552         }
 553         bip_ipn_swap(mmie->sequence_number, pn);
 554
 555         bip_aad(skb, aad);
 556
 557         /*
 558          * MIC = AES-128-CMAC(IGTK, AAD || Management Frame Body || MMIE, 64)
 559          */
 560         ieee80211_aes_cmac(key->u.aes_cmac.tfm, key->u.aes_cmac.tx_crypto_buf,
 561                            aad, skb->data + 24, skb->len - 24, mmie->mic);
 562
 563         return TX_CONTINUE;
 564 }
 565
 566
 567 ieee80211_rx_result
 568 ieee80211_crypto_aes_cmac_decrypt(struct ieee80211_rx_data *rx)
 569 {
 570         struct sk_buff *skb = rx->skb;
 571         struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
 572         struct ieee80211_key *key = rx->key;
 573         struct ieee80211_mmie *mmie;
 574         u8 aad[20], mic[8], ipn[6];
 575         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
 576
 577         if (!ieee80211_is_mgmt(hdr->frame_control))
 578                 return RX_CONTINUE;
 579
 580         if (skb->len < 24 + sizeof(*mmie))
 581                 return RX_DROP_UNUSABLE;
 582
 583         mmie = (struct ieee80211_mmie *)
 584                 (skb->data + skb->len - sizeof(*mmie));
 585         if (mmie->element_id != WLAN_EID_MMIE ||
 586             mmie->length != sizeof(*mmie) - 2)
 587                 return RX_DROP_UNUSABLE; /* Invalid MMIE */
 588
 589         bip_ipn_swap(ipn, mmie->sequence_number);
 590
 591         if (memcmp(ipn, key->u.aes_cmac.rx_pn, 6) <= 0) {
 592                 key->u.aes_cmac.replays++;
 593                 return RX_DROP_UNUSABLE;
 594         }
 595
 596         if (!(status->flag & RX_FLAG_DECRYPTED)) {
 597                 /* hardware didn't decrypt/verify MIC */
 598                 bip_aad(skb, aad);
 599                 ieee80211_aes_cmac(key->u.aes_cmac.tfm,
 600                                    key->u.aes_cmac.rx_crypto_buf, aad,
 601                                    skb->data + 24, skb->len - 24, mic);
 602                 if (memcmp(mic, mmie->mic, sizeof(mmie->mic)) != 0) {
 603                         key->u.aes_cmac.icverrors++;
 604                         return RX_DROP_UNUSABLE;
 605                 }
 606         }
 607
 608         memcpy(key->u.aes_cmac.rx_pn, ipn, 6);
 609
 610         /* Remove MMIE */
 611         skb_trim(skb, skb->len - sizeof(*mmie));
 612
 613         return RX_CONTINUE;
 614 }