1 /* 2 * Copyright 2002-2004, Instant802 Networks, Inc. 3 * Copyright 2008, Jouni Malinen <j@w1.fi> 4 * Copyright (C) 2016 Intel Deutschland GmbH 5 * 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. 9 */ 10 11 #include <linux/netdevice.h> 12 #include <linux/types.h> 13 #include <linux/skbuff.h> 14 #include <linux/compiler.h> 15 #include <linux/ieee80211.h> 16 #include <linux/gfp.h> 17 #include <asm/unaligned.h> 18 #include <net/mac80211.h> 19 #include <crypto/aes.h> 20 21 #include "ieee80211_i.h" 22 #include "michael.h" 23 #include "tkip.h" 24 #include "aes_ccm.h" 25 #include "aes_cmac.h" 26 #include "aes_gmac.h" 27 #include "aes_gcm.h" 28 #include "wpa.h" 29 30 ieee80211_tx_result 31 ieee80211_tx_h_michael_mic_add(struct ieee80211_tx_data *tx) 32 { 33 u8 *data, *key, *mic; 34 size_t data_len; 35 unsigned int hdrlen; 36 struct ieee80211_hdr *hdr; 37 struct sk_buff *skb = tx->skb; 38 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 39 int tail; 40 41 hdr = (struct ieee80211_hdr *)skb->data; 42 if (!tx->key || tx->key->conf.cipher != WLAN_CIPHER_SUITE_TKIP || 43 skb->len < 24 || !ieee80211_is_data_present(hdr->frame_control)) 44 return TX_CONTINUE; 45 46 hdrlen = ieee80211_hdrlen(hdr->frame_control); 47 if (skb->len < hdrlen) 48 return TX_DROP; 49 50 data = skb->data + hdrlen; 51 data_len = skb->len - hdrlen; 52 53 if (unlikely(info->flags & IEEE80211_TX_INTFL_TKIP_MIC_FAILURE)) { 54 /* Need to use software crypto for the test */ 55 info->control.hw_key = NULL; 56 } 57 58 if (info->control.hw_key && 59 (info->flags & IEEE80211_TX_CTL_DONTFRAG || 60 tx->local->ops->set_frag_threshold) && 61 !(tx->key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_MMIC)) { 62 /* hwaccel - with no need for SW-generated MMIC */ 63 return TX_CONTINUE; 64 } 65 66 tail = MICHAEL_MIC_LEN; 67 if (!info->control.hw_key) 68 tail += IEEE80211_TKIP_ICV_LEN; 69 70 if (WARN(skb_tailroom(skb) < tail || 71 skb_headroom(skb) < IEEE80211_TKIP_IV_LEN, 72 "mmic: not enough head/tail (%d/%d,%d/%d)\n", 73 skb_headroom(skb), IEEE80211_TKIP_IV_LEN, 74 skb_tailroom(skb), tail)) 75 return TX_DROP; 76 77 key = &tx->key->conf.key[NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY]; 78 mic = skb_put(skb, MICHAEL_MIC_LEN); 79 michael_mic(key, hdr, data, data_len, mic); 80 if (unlikely(info->flags & IEEE80211_TX_INTFL_TKIP_MIC_FAILURE)) 81 mic[0]++; 82 83 return TX_CONTINUE; 84 } 85 86 87 ieee80211_rx_result 88 ieee80211_rx_h_michael_mic_verify(struct ieee80211_rx_data *rx) 89 { 90 u8 *data, *key = NULL; 91 size_t data_len; 92 unsigned int hdrlen; 93 u8 mic[MICHAEL_MIC_LEN]; 94 struct sk_buff *skb = rx->skb; 95 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb); 96 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 97 98 /* 99 * it makes no sense to check for MIC errors on anything other 100 * than data frames. 101 */ 102 if (!ieee80211_is_data_present(hdr->frame_control)) 103 return RX_CONTINUE; 104 105 /* 106 * No way to verify the MIC if the hardware stripped it or 107 * the IV with the key index. In this case we have solely rely 108 * on the driver to set RX_FLAG_MMIC_ERROR in the event of a 109 * MIC failure report. 110 */ 111 if (status->flag & (RX_FLAG_MMIC_STRIPPED | RX_FLAG_IV_STRIPPED)) { 112 if (status->flag & RX_FLAG_MMIC_ERROR) 113 goto mic_fail_no_key; 114 115 if (!(status->flag & RX_FLAG_IV_STRIPPED) && rx->key && 116 rx->key->conf.cipher == WLAN_CIPHER_SUITE_TKIP) 117 goto update_iv; 118 119 return RX_CONTINUE; 120 } 121 122 /* 123 * Some hardware seems to generate Michael MIC failure reports; even 124 * though, the frame was not encrypted with TKIP and therefore has no 125 * MIC. Ignore the flag them to avoid triggering countermeasures. 126 */ 127 if (!rx->key || rx->key->conf.cipher != WLAN_CIPHER_SUITE_TKIP || 128 !(status->flag & RX_FLAG_DECRYPTED)) 129 return RX_CONTINUE; 130 131 if (rx->sdata->vif.type == NL80211_IFTYPE_AP && rx->key->conf.keyidx) { 132 /* 133 * APs with pairwise keys should never receive Michael MIC 134 * errors for non-zero keyidx because these are reserved for 135 * group keys and only the AP is sending real multicast 136 * frames in the BSS. 137 */ 138 return RX_DROP_UNUSABLE; 139 } 140 141 if (status->flag & RX_FLAG_MMIC_ERROR) 142 goto mic_fail; 143 144 hdrlen = ieee80211_hdrlen(hdr->frame_control); 145 if (skb->len < hdrlen + MICHAEL_MIC_LEN) 146 return RX_DROP_UNUSABLE; 147 148 if (skb_linearize(rx->skb)) 149 return RX_DROP_UNUSABLE; 150 hdr = (void *)skb->data; 151 152 data = skb->data + hdrlen; 153 data_len = skb->len - hdrlen - MICHAEL_MIC_LEN; 154 key = &rx->key->conf.key[NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY]; 155 michael_mic(key, hdr, data, data_len, mic); 156 if (memcmp(mic, data + data_len, MICHAEL_MIC_LEN) != 0) 157 goto mic_fail; 158 159 /* remove Michael MIC from payload */ 160 skb_trim(skb, skb->len - MICHAEL_MIC_LEN); 161 162 update_iv: 163 /* update IV in key information to be able to detect replays */ 164 rx->key->u.tkip.rx[rx->security_idx].iv32 = rx->tkip_iv32; 165 rx->key->u.tkip.rx[rx->security_idx].iv16 = rx->tkip_iv16; 166 167 return RX_CONTINUE; 168 169 mic_fail: 170 rx->key->u.tkip.mic_failures++; 171 172 mic_fail_no_key: 173 /* 174 * In some cases the key can be unset - e.g. a multicast packet, in 175 * a driver that supports HW encryption. Send up the key idx only if 176 * the key is set. 177 */ 178 cfg80211_michael_mic_failure(rx->sdata->dev, hdr->addr2, 179 is_multicast_ether_addr(hdr->addr1) ? 180 NL80211_KEYTYPE_GROUP : 181 NL80211_KEYTYPE_PAIRWISE, 182 rx->key ? rx->key->conf.keyidx : -1, 183 NULL, GFP_ATOMIC); 184 return RX_DROP_UNUSABLE; 185 } 186 187 static int tkip_encrypt_skb(struct ieee80211_tx_data *tx, struct sk_buff *skb) 188 { 189 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; 190 struct ieee80211_key *key = tx->key; 191 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 192 unsigned int hdrlen; 193 int len, tail; 194 u64 pn; 195 u8 *pos; 196 197 if (info->control.hw_key && 198 !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_GENERATE_IV) && 199 !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE)) { 200 /* hwaccel - with no need for software-generated IV */ 201 return 0; 202 } 203 204 hdrlen = ieee80211_hdrlen(hdr->frame_control); 205 len = skb->len - hdrlen; 206 207 if (info->control.hw_key) 208 tail = 0; 209 else 210 tail = IEEE80211_TKIP_ICV_LEN; 211 212 if (WARN_ON(skb_tailroom(skb) < tail || 213 skb_headroom(skb) < IEEE80211_TKIP_IV_LEN)) 214 return -1; 215 216 pos = skb_push(skb, IEEE80211_TKIP_IV_LEN); 217 memmove(pos, pos + IEEE80211_TKIP_IV_LEN, hdrlen); 218 pos += hdrlen; 219 220 /* the HW only needs room for the IV, but not the actual IV */ 221 if (info->control.hw_key && 222 (info->control.hw_key->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE)) 223 return 0; 224 225 /* Increase IV for the frame */ 226 pn = atomic64_inc_return(&key->conf.tx_pn); 227 pos = ieee80211_tkip_add_iv(pos, &key->conf, pn); 228 229 /* hwaccel - with software IV */ 230 if (info->control.hw_key) 231 return 0; 232 233 /* Add room for ICV */ 234 skb_put(skb, IEEE80211_TKIP_ICV_LEN); 235 236 return ieee80211_tkip_encrypt_data(tx->local->wep_tx_tfm, 237 key, skb, pos, len); 238 } 239 240 241 ieee80211_tx_result 242 ieee80211_crypto_tkip_encrypt(struct ieee80211_tx_data *tx) 243 { 244 struct sk_buff *skb; 245 246 ieee80211_tx_set_protected(tx); 247 248 skb_queue_walk(&tx->skbs, skb) { 249 if (tkip_encrypt_skb(tx, skb) < 0) 250 return TX_DROP; 251 } 252 253 return TX_CONTINUE; 254 } 255 256 257 ieee80211_rx_result 258 ieee80211_crypto_tkip_decrypt(struct ieee80211_rx_data *rx) 259 { 260 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) rx->skb->data; 261 int hdrlen, res, hwaccel = 0; 262 struct ieee80211_key *key = rx->key; 263 struct sk_buff *skb = rx->skb; 264 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb); 265 266 hdrlen = ieee80211_hdrlen(hdr->frame_control); 267 268 if (!ieee80211_is_data(hdr->frame_control)) 269 return RX_CONTINUE; 270 271 if (!rx->sta || skb->len - hdrlen < 12) 272 return RX_DROP_UNUSABLE; 273 274 /* it may be possible to optimize this a bit more */ 275 if (skb_linearize(rx->skb)) 276 return RX_DROP_UNUSABLE; 277 hdr = (void *)skb->data; 278 279 /* 280 * Let TKIP code verify IV, but skip decryption. 281 * In the case where hardware checks the IV as well, 282 * we don't even get here, see ieee80211_rx_h_decrypt() 283 */ 284 if (status->flag & RX_FLAG_DECRYPTED) 285 hwaccel = 1; 286 287 res = ieee80211_tkip_decrypt_data(rx->local->wep_rx_tfm, 288 key, skb->data + hdrlen, 289 skb->len - hdrlen, rx->sta->sta.addr, 290 hdr->addr1, hwaccel, rx->security_idx, 291 &rx->tkip_iv32, 292 &rx->tkip_iv16); 293 if (res != TKIP_DECRYPT_OK) 294 return RX_DROP_UNUSABLE; 295 296 /* Trim ICV */ 297 skb_trim(skb, skb->len - IEEE80211_TKIP_ICV_LEN); 298 299 /* Remove IV */ 300 memmove(skb->data + IEEE80211_TKIP_IV_LEN, skb->data, hdrlen); 301 skb_pull(skb, IEEE80211_TKIP_IV_LEN); 302 303 return RX_CONTINUE; 304 } 305 306 307 static void ccmp_special_blocks(struct sk_buff *skb, u8 *pn, u8 *b_0, u8 *aad) 308 { 309 __le16 mask_fc; 310 int a4_included, mgmt; 311 u8 qos_tid; 312 u16 len_a; 313 unsigned int hdrlen; 314 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 315 316 /* 317 * Mask FC: zero subtype b4 b5 b6 (if not mgmt) 318 * Retry, PwrMgt, MoreData; set Protected 319 */ 320 mgmt = ieee80211_is_mgmt(hdr->frame_control); 321 mask_fc = hdr->frame_control; 322 mask_fc &= ~cpu_to_le16(IEEE80211_FCTL_RETRY | 323 IEEE80211_FCTL_PM | IEEE80211_FCTL_MOREDATA); 324 if (!mgmt) 325 mask_fc &= ~cpu_to_le16(0x0070); 326 mask_fc |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); 327 328 hdrlen = ieee80211_hdrlen(hdr->frame_control); 329 len_a = hdrlen - 2; 330 a4_included = ieee80211_has_a4(hdr->frame_control); 331 332 if (ieee80211_is_data_qos(hdr->frame_control)) 333 qos_tid = *ieee80211_get_qos_ctl(hdr) & IEEE80211_QOS_CTL_TID_MASK; 334 else 335 qos_tid = 0; 336 337 /* In CCM, the initial vectors (IV) used for CTR mode encryption and CBC 338 * mode authentication are not allowed to collide, yet both are derived 339 * from this vector b_0. We only set L := 1 here to indicate that the 340 * data size can be represented in (L+1) bytes. The CCM layer will take 341 * care of storing the data length in the top (L+1) bytes and setting 342 * and clearing the other bits as is required to derive the two IVs. 343 */ 344 b_0[0] = 0x1; 345 346 /* Nonce: Nonce Flags | A2 | PN 347 * Nonce Flags: Priority (b0..b3) | Management (b4) | Reserved (b5..b7) 348 */ 349 b_0[1] = qos_tid | (mgmt << 4); 350 memcpy(&b_0[2], hdr->addr2, ETH_ALEN); 351 memcpy(&b_0[8], pn, IEEE80211_CCMP_PN_LEN); 352 353 /* AAD (extra authenticate-only data) / masked 802.11 header 354 * FC | A1 | A2 | A3 | SC | [A4] | [QC] */ 355 put_unaligned_be16(len_a, &aad[0]); 356 put_unaligned(mask_fc, (__le16 *)&aad[2]); 357 memcpy(&aad[4], &hdr->addr1, 3 * ETH_ALEN); 358 359 /* Mask Seq#, leave Frag# */ 360 aad[22] = *((u8 *) &hdr->seq_ctrl) & 0x0f; 361 aad[23] = 0; 362 363 if (a4_included) { 364 memcpy(&aad[24], hdr->addr4, ETH_ALEN); 365 aad[30] = qos_tid; 366 aad[31] = 0; 367 } else { 368 memset(&aad[24], 0, ETH_ALEN + IEEE80211_QOS_CTL_LEN); 369 aad[24] = qos_tid; 370 } 371 } 372 373 374 static inline void ccmp_pn2hdr(u8 *hdr, u8 *pn, int key_id) 375 { 376 hdr[0] = pn[5]; 377 hdr[1] = pn[4]; 378 hdr[2] = 0; 379 hdr[3] = 0x20 | (key_id << 6); 380 hdr[4] = pn[3]; 381 hdr[5] = pn[2]; 382 hdr[6] = pn[1]; 383 hdr[7] = pn[0]; 384 } 385 386 387 static inline void ccmp_hdr2pn(u8 *pn, u8 *hdr) 388 { 389 pn[0] = hdr[7]; 390 pn[1] = hdr[6]; 391 pn[2] = hdr[5]; 392 pn[3] = hdr[4]; 393 pn[4] = hdr[1]; 394 pn[5] = hdr[0]; 395 } 396 397 398 static int ccmp_encrypt_skb(struct ieee80211_tx_data *tx, struct sk_buff *skb, 399 unsigned int mic_len) 400 { 401 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; 402 struct ieee80211_key *key = tx->key; 403 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 404 int hdrlen, len, tail; 405 u8 *pos; 406 u8 pn[6]; 407 u64 pn64; 408 u8 aad[2 * AES_BLOCK_SIZE]; 409 u8 b_0[AES_BLOCK_SIZE]; 410 411 if (info->control.hw_key && 412 !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_GENERATE_IV) && 413 !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE) && 414 !((info->control.hw_key->flags & 415 IEEE80211_KEY_FLAG_GENERATE_IV_MGMT) && 416 ieee80211_is_mgmt(hdr->frame_control))) { 417 /* 418 * hwaccel has no need for preallocated room for CCMP 419 * header or MIC fields 420 */ 421 return 0; 422 } 423 424 hdrlen = ieee80211_hdrlen(hdr->frame_control); 425 len = skb->len - hdrlen; 426 427 if (info->control.hw_key) 428 tail = 0; 429 else 430 tail = mic_len; 431 432 if (WARN_ON(skb_tailroom(skb) < tail || 433 skb_headroom(skb) < IEEE80211_CCMP_HDR_LEN)) 434 return -1; 435 436 pos = skb_push(skb, IEEE80211_CCMP_HDR_LEN); 437 memmove(pos, pos + IEEE80211_CCMP_HDR_LEN, hdrlen); 438 439 /* the HW only needs room for the IV, but not the actual IV */ 440 if (info->control.hw_key && 441 (info->control.hw_key->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE)) 442 return 0; 443 444 hdr = (struct ieee80211_hdr *) pos; 445 pos += hdrlen; 446 447 pn64 = atomic64_inc_return(&key->conf.tx_pn); 448 449 pn[5] = pn64; 450 pn[4] = pn64 >> 8; 451 pn[3] = pn64 >> 16; 452 pn[2] = pn64 >> 24; 453 pn[1] = pn64 >> 32; 454 pn[0] = pn64 >> 40; 455 456 ccmp_pn2hdr(pos, pn, key->conf.keyidx); 457 458 /* hwaccel - with software CCMP header */ 459 if (info->control.hw_key) 460 return 0; 461 462 pos += IEEE80211_CCMP_HDR_LEN; 463 ccmp_special_blocks(skb, pn, b_0, aad); 464 ieee80211_aes_ccm_encrypt(key->u.ccmp.tfm, b_0, aad, pos, len, 465 skb_put(skb, mic_len), mic_len); 466 467 return 0; 468 } 469 470 471 ieee80211_tx_result 472 ieee80211_crypto_ccmp_encrypt(struct ieee80211_tx_data *tx, 473 unsigned int mic_len) 474 { 475 struct sk_buff *skb; 476 477 ieee80211_tx_set_protected(tx); 478 479 skb_queue_walk(&tx->skbs, skb) { 480 if (ccmp_encrypt_skb(tx, skb, mic_len) < 0) 481 return TX_DROP; 482 } 483 484 return TX_CONTINUE; 485 } 486 487 488 ieee80211_rx_result 489 ieee80211_crypto_ccmp_decrypt(struct ieee80211_rx_data *rx, 490 unsigned int mic_len) 491 { 492 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data; 493 int hdrlen; 494 struct ieee80211_key *key = rx->key; 495 struct sk_buff *skb = rx->skb; 496 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb); 497 u8 pn[IEEE80211_CCMP_PN_LEN]; 498 int data_len; 499 int queue; 500 501 hdrlen = ieee80211_hdrlen(hdr->frame_control); 502 503 if (!ieee80211_is_data(hdr->frame_control) && 504 !ieee80211_is_robust_mgmt_frame(skb)) 505 return RX_CONTINUE; 506 507 if (status->flag & RX_FLAG_DECRYPTED) { 508 if (!pskb_may_pull(rx->skb, hdrlen + IEEE80211_CCMP_HDR_LEN)) 509 return RX_DROP_UNUSABLE; 510 if (status->flag & RX_FLAG_MIC_STRIPPED) 511 mic_len = 0; 512 } else { 513 if (skb_linearize(rx->skb)) 514 return RX_DROP_UNUSABLE; 515 } 516 517 data_len = skb->len - hdrlen - IEEE80211_CCMP_HDR_LEN - mic_len; 518 if (!rx->sta || data_len < 0) 519 return RX_DROP_UNUSABLE; 520 521 if (!(status->flag & RX_FLAG_PN_VALIDATED)) { 522 ccmp_hdr2pn(pn, skb->data + hdrlen); 523 524 queue = rx->security_idx; 525 526 if (memcmp(pn, key->u.ccmp.rx_pn[queue], 527 IEEE80211_CCMP_PN_LEN) <= 0) { 528 key->u.ccmp.replays++; 529 return RX_DROP_UNUSABLE; 530 } 531 532 if (!(status->flag & RX_FLAG_DECRYPTED)) { 533 u8 aad[2 * AES_BLOCK_SIZE]; 534 u8 b_0[AES_BLOCK_SIZE]; 535 /* hardware didn't decrypt/verify MIC */ 536 ccmp_special_blocks(skb, pn, b_0, aad); 537 538 if (ieee80211_aes_ccm_decrypt( 539 key->u.ccmp.tfm, b_0, aad, 540 skb->data + hdrlen + IEEE80211_CCMP_HDR_LEN, 541 data_len, 542 skb->data + skb->len - mic_len, mic_len)) 543 return RX_DROP_UNUSABLE; 544 } 545 546 memcpy(key->u.ccmp.rx_pn[queue], pn, IEEE80211_CCMP_PN_LEN); 547 } 548 549 /* Remove CCMP header and MIC */ 550 if (pskb_trim(skb, skb->len - mic_len)) 551 return RX_DROP_UNUSABLE; 552 memmove(skb->data + IEEE80211_CCMP_HDR_LEN, skb->data, hdrlen); 553 skb_pull(skb, IEEE80211_CCMP_HDR_LEN); 554 555 return RX_CONTINUE; 556 } 557 558 static void gcmp_special_blocks(struct sk_buff *skb, u8 *pn, u8 *j_0, u8 *aad) 559 { 560 __le16 mask_fc; 561 u8 qos_tid; 562 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 563 564 memcpy(j_0, hdr->addr2, ETH_ALEN); 565 memcpy(&j_0[ETH_ALEN], pn, IEEE80211_GCMP_PN_LEN); 566 j_0[13] = 0; 567 j_0[14] = 0; 568 j_0[AES_BLOCK_SIZE - 1] = 0x01; 569 570 /* AAD (extra authenticate-only data) / masked 802.11 header 571 * FC | A1 | A2 | A3 | SC | [A4] | [QC] 572 */ 573 put_unaligned_be16(ieee80211_hdrlen(hdr->frame_control) - 2, &aad[0]); 574 /* Mask FC: zero subtype b4 b5 b6 (if not mgmt) 575 * Retry, PwrMgt, MoreData; set Protected 576 */ 577 mask_fc = hdr->frame_control; 578 mask_fc &= ~cpu_to_le16(IEEE80211_FCTL_RETRY | 579 IEEE80211_FCTL_PM | IEEE80211_FCTL_MOREDATA); 580 if (!ieee80211_is_mgmt(hdr->frame_control)) 581 mask_fc &= ~cpu_to_le16(0x0070); 582 mask_fc |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); 583 584 put_unaligned(mask_fc, (__le16 *)&aad[2]); 585 memcpy(&aad[4], &hdr->addr1, 3 * ETH_ALEN); 586 587 /* Mask Seq#, leave Frag# */ 588 aad[22] = *((u8 *)&hdr->seq_ctrl) & 0x0f; 589 aad[23] = 0; 590 591 if (ieee80211_is_data_qos(hdr->frame_control)) 592 qos_tid = *ieee80211_get_qos_ctl(hdr) & 593 IEEE80211_QOS_CTL_TID_MASK; 594 else 595 qos_tid = 0; 596 597 if (ieee80211_has_a4(hdr->frame_control)) { 598 memcpy(&aad[24], hdr->addr4, ETH_ALEN); 599 aad[30] = qos_tid; 600 aad[31] = 0; 601 } else { 602 memset(&aad[24], 0, ETH_ALEN + IEEE80211_QOS_CTL_LEN); 603 aad[24] = qos_tid; 604 } 605 } 606 607 static inline void gcmp_pn2hdr(u8 *hdr, const u8 *pn, int key_id) 608 { 609 hdr[0] = pn[5]; 610 hdr[1] = pn[4]; 611 hdr[2] = 0; 612 hdr[3] = 0x20 | (key_id << 6); 613 hdr[4] = pn[3]; 614 hdr[5] = pn[2]; 615 hdr[6] = pn[1]; 616 hdr[7] = pn[0]; 617 } 618 619 static inline void gcmp_hdr2pn(u8 *pn, const u8 *hdr) 620 { 621 pn[0] = hdr[7]; 622 pn[1] = hdr[6]; 623 pn[2] = hdr[5]; 624 pn[3] = hdr[4]; 625 pn[4] = hdr[1]; 626 pn[5] = hdr[0]; 627 } 628 629 static int gcmp_encrypt_skb(struct ieee80211_tx_data *tx, struct sk_buff *skb) 630 { 631 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 632 struct ieee80211_key *key = tx->key; 633 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 634 int hdrlen, len, tail; 635 u8 *pos; 636 u8 pn[6]; 637 u64 pn64; 638 u8 aad[2 * AES_BLOCK_SIZE]; 639 u8 j_0[AES_BLOCK_SIZE]; 640 641 if (info->control.hw_key && 642 !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_GENERATE_IV) && 643 !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE) && 644 !((info->control.hw_key->flags & 645 IEEE80211_KEY_FLAG_GENERATE_IV_MGMT) && 646 ieee80211_is_mgmt(hdr->frame_control))) { 647 /* hwaccel has no need for preallocated room for GCMP 648 * header or MIC fields 649 */ 650 return 0; 651 } 652 653 hdrlen = ieee80211_hdrlen(hdr->frame_control); 654 len = skb->len - hdrlen; 655 656 if (info->control.hw_key) 657 tail = 0; 658 else 659 tail = IEEE80211_GCMP_MIC_LEN; 660 661 if (WARN_ON(skb_tailroom(skb) < tail || 662 skb_headroom(skb) < IEEE80211_GCMP_HDR_LEN)) 663 return -1; 664 665 pos = skb_push(skb, IEEE80211_GCMP_HDR_LEN); 666 memmove(pos, pos + IEEE80211_GCMP_HDR_LEN, hdrlen); 667 skb_set_network_header(skb, skb_network_offset(skb) + 668 IEEE80211_GCMP_HDR_LEN); 669 670 /* the HW only needs room for the IV, but not the actual IV */ 671 if (info->control.hw_key && 672 (info->control.hw_key->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE)) 673 return 0; 674 675 hdr = (struct ieee80211_hdr *)pos; 676 pos += hdrlen; 677 678 pn64 = atomic64_inc_return(&key->conf.tx_pn); 679 680 pn[5] = pn64; 681 pn[4] = pn64 >> 8; 682 pn[3] = pn64 >> 16; 683 pn[2] = pn64 >> 24; 684 pn[1] = pn64 >> 32; 685 pn[0] = pn64 >> 40; 686 687 gcmp_pn2hdr(pos, pn, key->conf.keyidx); 688 689 /* hwaccel - with software GCMP header */ 690 if (info->control.hw_key) 691 return 0; 692 693 pos += IEEE80211_GCMP_HDR_LEN; 694 gcmp_special_blocks(skb, pn, j_0, aad); 695 ieee80211_aes_gcm_encrypt(key->u.gcmp.tfm, j_0, aad, pos, len, 696 skb_put(skb, IEEE80211_GCMP_MIC_LEN)); 697 698 return 0; 699 } 700 701 ieee80211_tx_result 702 ieee80211_crypto_gcmp_encrypt(struct ieee80211_tx_data *tx) 703 { 704 struct sk_buff *skb; 705 706 ieee80211_tx_set_protected(tx); 707 708 skb_queue_walk(&tx->skbs, skb) { 709 if (gcmp_encrypt_skb(tx, skb) < 0) 710 return TX_DROP; 711 } 712 713 return TX_CONTINUE; 714 } 715 716 ieee80211_rx_result 717 ieee80211_crypto_gcmp_decrypt(struct ieee80211_rx_data *rx) 718 { 719 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data; 720 int hdrlen; 721 struct ieee80211_key *key = rx->key; 722 struct sk_buff *skb = rx->skb; 723 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb); 724 u8 pn[IEEE80211_GCMP_PN_LEN]; 725 int data_len, queue, mic_len = IEEE80211_GCMP_MIC_LEN; 726 727 hdrlen = ieee80211_hdrlen(hdr->frame_control); 728 729 if (!ieee80211_is_data(hdr->frame_control) && 730 !ieee80211_is_robust_mgmt_frame(skb)) 731 return RX_CONTINUE; 732 733 if (status->flag & RX_FLAG_DECRYPTED) { 734 if (!pskb_may_pull(rx->skb, hdrlen + IEEE80211_GCMP_HDR_LEN)) 735 return RX_DROP_UNUSABLE; 736 if (status->flag & RX_FLAG_MIC_STRIPPED) 737 mic_len = 0; 738 } else { 739 if (skb_linearize(rx->skb)) 740 return RX_DROP_UNUSABLE; 741 } 742 743 data_len = skb->len - hdrlen - IEEE80211_GCMP_HDR_LEN - mic_len; 744 if (!rx->sta || data_len < 0) 745 return RX_DROP_UNUSABLE; 746 747 if (!(status->flag & RX_FLAG_PN_VALIDATED)) { 748 gcmp_hdr2pn(pn, skb->data + hdrlen); 749 750 queue = rx->security_idx; 751 752 if (memcmp(pn, key->u.gcmp.rx_pn[queue], 753 IEEE80211_GCMP_PN_LEN) <= 0) { 754 key->u.gcmp.replays++; 755 return RX_DROP_UNUSABLE; 756 } 757 758 if (!(status->flag & RX_FLAG_DECRYPTED)) { 759 u8 aad[2 * AES_BLOCK_SIZE]; 760 u8 j_0[AES_BLOCK_SIZE]; 761 /* hardware didn't decrypt/verify MIC */ 762 gcmp_special_blocks(skb, pn, j_0, aad); 763 764 if (ieee80211_aes_gcm_decrypt( 765 key->u.gcmp.tfm, j_0, aad, 766 skb->data + hdrlen + IEEE80211_GCMP_HDR_LEN, 767 data_len, 768 skb->data + skb->len - 769 IEEE80211_GCMP_MIC_LEN)) 770 return RX_DROP_UNUSABLE; 771 } 772 773 memcpy(key->u.gcmp.rx_pn[queue], pn, IEEE80211_GCMP_PN_LEN); 774 } 775 776 /* Remove GCMP header and MIC */ 777 if (pskb_trim(skb, skb->len - mic_len)) 778 return RX_DROP_UNUSABLE; 779 memmove(skb->data + IEEE80211_GCMP_HDR_LEN, skb->data, hdrlen); 780 skb_pull(skb, IEEE80211_GCMP_HDR_LEN); 781 782 return RX_CONTINUE; 783 } 784 785 static ieee80211_tx_result 786 ieee80211_crypto_cs_encrypt(struct ieee80211_tx_data *tx, 787 struct sk_buff *skb) 788 { 789 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 790 struct ieee80211_key *key = tx->key; 791 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 792 int hdrlen; 793 u8 *pos, iv_len = key->conf.iv_len; 794 795 if (info->control.hw_key && 796 !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE)) { 797 /* hwaccel has no need for preallocated head room */ 798 return TX_CONTINUE; 799 } 800 801 if (unlikely(skb_headroom(skb) < iv_len && 802 pskb_expand_head(skb, iv_len, 0, GFP_ATOMIC))) 803 return TX_DROP; 804 805 hdrlen = ieee80211_hdrlen(hdr->frame_control); 806 807 pos = skb_push(skb, iv_len); 808 memmove(pos, pos + iv_len, hdrlen); 809 810 return TX_CONTINUE; 811 } 812 813 static inline int ieee80211_crypto_cs_pn_compare(u8 *pn1, u8 *pn2, int len) 814 { 815 int i; 816 817 /* pn is little endian */ 818 for (i = len - 1; i >= 0; i--) { 819 if (pn1[i] < pn2[i]) 820 return -1; 821 else if (pn1[i] > pn2[i]) 822 return 1; 823 } 824 825 return 0; 826 } 827 828 static ieee80211_rx_result 829 ieee80211_crypto_cs_decrypt(struct ieee80211_rx_data *rx) 830 { 831 struct ieee80211_key *key = rx->key; 832 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data; 833 const struct ieee80211_cipher_scheme *cs = NULL; 834 int hdrlen = ieee80211_hdrlen(hdr->frame_control); 835 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb); 836 int data_len; 837 u8 *rx_pn; 838 u8 *skb_pn; 839 u8 qos_tid; 840 841 if (!rx->sta || !rx->sta->cipher_scheme || 842 !(status->flag & RX_FLAG_DECRYPTED)) 843 return RX_DROP_UNUSABLE; 844 845 if (!ieee80211_is_data(hdr->frame_control)) 846 return RX_CONTINUE; 847 848 cs = rx->sta->cipher_scheme; 849 850 data_len = rx->skb->len - hdrlen - cs->hdr_len; 851 852 if (data_len < 0) 853 return RX_DROP_UNUSABLE; 854 855 if (ieee80211_is_data_qos(hdr->frame_control)) 856 qos_tid = *ieee80211_get_qos_ctl(hdr) & 857 IEEE80211_QOS_CTL_TID_MASK; 858 else 859 qos_tid = 0; 860 861 if (skb_linearize(rx->skb)) 862 return RX_DROP_UNUSABLE; 863 864 hdr = (struct ieee80211_hdr *)rx->skb->data; 865 866 rx_pn = key->u.gen.rx_pn[qos_tid]; 867 skb_pn = rx->skb->data + hdrlen + cs->pn_off; 868 869 if (ieee80211_crypto_cs_pn_compare(skb_pn, rx_pn, cs->pn_len) <= 0) 870 return RX_DROP_UNUSABLE; 871 872 memcpy(rx_pn, skb_pn, cs->pn_len); 873 874 /* remove security header and MIC */ 875 if (pskb_trim(rx->skb, rx->skb->len - cs->mic_len)) 876 return RX_DROP_UNUSABLE; 877 878 memmove(rx->skb->data + cs->hdr_len, rx->skb->data, hdrlen); 879 skb_pull(rx->skb, cs->hdr_len); 880 881 return RX_CONTINUE; 882 } 883 884 static void bip_aad(struct sk_buff *skb, u8 *aad) 885 { 886 __le16 mask_fc; 887 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; 888 889 /* BIP AAD: FC(masked) || A1 || A2 || A3 */ 890 891 /* FC type/subtype */ 892 /* Mask FC Retry, PwrMgt, MoreData flags to zero */ 893 mask_fc = hdr->frame_control; 894 mask_fc &= ~cpu_to_le16(IEEE80211_FCTL_RETRY | IEEE80211_FCTL_PM | 895 IEEE80211_FCTL_MOREDATA); 896 put_unaligned(mask_fc, (__le16 *) &aad[0]); 897 /* A1 || A2 || A3 */ 898 memcpy(aad + 2, &hdr->addr1, 3 * ETH_ALEN); 899 } 900 901 902 static inline void bip_ipn_set64(u8 *d, u64 pn) 903 { 904 *d++ = pn; 905 *d++ = pn >> 8; 906 *d++ = pn >> 16; 907 *d++ = pn >> 24; 908 *d++ = pn >> 32; 909 *d = pn >> 40; 910 } 911 912 static inline void bip_ipn_swap(u8 *d, const u8 *s) 913 { 914 *d++ = s[5]; 915 *d++ = s[4]; 916 *d++ = s[3]; 917 *d++ = s[2]; 918 *d++ = s[1]; 919 *d = s[0]; 920 } 921 922 923 ieee80211_tx_result 924 ieee80211_crypto_aes_cmac_encrypt(struct ieee80211_tx_data *tx) 925 { 926 struct sk_buff *skb; 927 struct ieee80211_tx_info *info; 928 struct ieee80211_key *key = tx->key; 929 struct ieee80211_mmie *mmie; 930 u8 aad[20]; 931 u64 pn64; 932 933 if (WARN_ON(skb_queue_len(&tx->skbs) != 1)) 934 return TX_DROP; 935 936 skb = skb_peek(&tx->skbs); 937 938 info = IEEE80211_SKB_CB(skb); 939 940 if (info->control.hw_key) 941 return TX_CONTINUE; 942 943 if (WARN_ON(skb_tailroom(skb) < sizeof(*mmie))) 944 return TX_DROP; 945 946 mmie = (struct ieee80211_mmie *) skb_put(skb, sizeof(*mmie)); 947 mmie->element_id = WLAN_EID_MMIE; 948 mmie->length = sizeof(*mmie) - 2; 949 mmie->key_id = cpu_to_le16(key->conf.keyidx); 950 951 /* PN = PN + 1 */ 952 pn64 = atomic64_inc_return(&key->conf.tx_pn); 953 954 bip_ipn_set64(mmie->sequence_number, pn64); 955 956 bip_aad(skb, aad); 957 958 /* 959 * MIC = AES-128-CMAC(IGTK, AAD || Management Frame Body || MMIE, 64) 960 */ 961 ieee80211_aes_cmac(key->u.aes_cmac.tfm, aad, 962 skb->data + 24, skb->len - 24, mmie->mic); 963 964 return TX_CONTINUE; 965 } 966 967 ieee80211_tx_result 968 ieee80211_crypto_aes_cmac_256_encrypt(struct ieee80211_tx_data *tx) 969 { 970 struct sk_buff *skb; 971 struct ieee80211_tx_info *info; 972 struct ieee80211_key *key = tx->key; 973 struct ieee80211_mmie_16 *mmie; 974 u8 aad[20]; 975 u64 pn64; 976 977 if (WARN_ON(skb_queue_len(&tx->skbs) != 1)) 978 return TX_DROP; 979 980 skb = skb_peek(&tx->skbs); 981 982 info = IEEE80211_SKB_CB(skb); 983 984 if (info->control.hw_key) 985 return TX_CONTINUE; 986 987 if (WARN_ON(skb_tailroom(skb) < sizeof(*mmie))) 988 return TX_DROP; 989 990 mmie = (struct ieee80211_mmie_16 *)skb_put(skb, sizeof(*mmie)); 991 mmie->element_id = WLAN_EID_MMIE; 992 mmie->length = sizeof(*mmie) - 2; 993 mmie->key_id = cpu_to_le16(key->conf.keyidx); 994 995 /* PN = PN + 1 */ 996 pn64 = atomic64_inc_return(&key->conf.tx_pn); 997 998 bip_ipn_set64(mmie->sequence_number, pn64); 999 1000 bip_aad(skb, aad); 1001 1002 /* MIC = AES-256-CMAC(IGTK, AAD || Management Frame Body || MMIE, 128) 1003 */ 1004 ieee80211_aes_cmac_256(key->u.aes_cmac.tfm, aad, 1005 skb->data + 24, skb->len - 24, mmie->mic); 1006 1007 return TX_CONTINUE; 1008 } 1009 1010 ieee80211_rx_result 1011 ieee80211_crypto_aes_cmac_decrypt(struct ieee80211_rx_data *rx) 1012 { 1013 struct sk_buff *skb = rx->skb; 1014 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb); 1015 struct ieee80211_key *key = rx->key; 1016 struct ieee80211_mmie *mmie; 1017 u8 aad[20], mic[8], ipn[6]; 1018 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; 1019 1020 if (!ieee80211_is_mgmt(hdr->frame_control)) 1021 return RX_CONTINUE; 1022 1023 /* management frames are already linear */ 1024 1025 if (skb->len < 24 + sizeof(*mmie)) 1026 return RX_DROP_UNUSABLE; 1027 1028 mmie = (struct ieee80211_mmie *) 1029 (skb->data + skb->len - sizeof(*mmie)); 1030 if (mmie->element_id != WLAN_EID_MMIE || 1031 mmie->length != sizeof(*mmie) - 2) 1032 return RX_DROP_UNUSABLE; /* Invalid MMIE */ 1033 1034 bip_ipn_swap(ipn, mmie->sequence_number); 1035 1036 if (memcmp(ipn, key->u.aes_cmac.rx_pn, 6) <= 0) { 1037 key->u.aes_cmac.replays++; 1038 return RX_DROP_UNUSABLE; 1039 } 1040 1041 if (!(status->flag & RX_FLAG_DECRYPTED)) { 1042 /* hardware didn't decrypt/verify MIC */ 1043 bip_aad(skb, aad); 1044 ieee80211_aes_cmac(key->u.aes_cmac.tfm, aad, 1045 skb->data + 24, skb->len - 24, mic); 1046 if (memcmp(mic, mmie->mic, sizeof(mmie->mic)) != 0) { 1047 key->u.aes_cmac.icverrors++; 1048 return RX_DROP_UNUSABLE; 1049 } 1050 } 1051 1052 memcpy(key->u.aes_cmac.rx_pn, ipn, 6); 1053 1054 /* Remove MMIE */ 1055 skb_trim(skb, skb->len - sizeof(*mmie)); 1056 1057 return RX_CONTINUE; 1058 } 1059 1060 ieee80211_rx_result 1061 ieee80211_crypto_aes_cmac_256_decrypt(struct ieee80211_rx_data *rx) 1062 { 1063 struct sk_buff *skb = rx->skb; 1064 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb); 1065 struct ieee80211_key *key = rx->key; 1066 struct ieee80211_mmie_16 *mmie; 1067 u8 aad[20], mic[16], ipn[6]; 1068 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 1069 1070 if (!ieee80211_is_mgmt(hdr->frame_control)) 1071 return RX_CONTINUE; 1072 1073 /* management frames are already linear */ 1074 1075 if (skb->len < 24 + sizeof(*mmie)) 1076 return RX_DROP_UNUSABLE; 1077 1078 mmie = (struct ieee80211_mmie_16 *) 1079 (skb->data + skb->len - sizeof(*mmie)); 1080 if (mmie->element_id != WLAN_EID_MMIE || 1081 mmie->length != sizeof(*mmie) - 2) 1082 return RX_DROP_UNUSABLE; /* Invalid MMIE */ 1083 1084 bip_ipn_swap(ipn, mmie->sequence_number); 1085 1086 if (memcmp(ipn, key->u.aes_cmac.rx_pn, 6) <= 0) { 1087 key->u.aes_cmac.replays++; 1088 return RX_DROP_UNUSABLE; 1089 } 1090 1091 if (!(status->flag & RX_FLAG_DECRYPTED)) { 1092 /* hardware didn't decrypt/verify MIC */ 1093 bip_aad(skb, aad); 1094 ieee80211_aes_cmac_256(key->u.aes_cmac.tfm, aad, 1095 skb->data + 24, skb->len - 24, mic); 1096 if (memcmp(mic, mmie->mic, sizeof(mmie->mic)) != 0) { 1097 key->u.aes_cmac.icverrors++; 1098 return RX_DROP_UNUSABLE; 1099 } 1100 } 1101 1102 memcpy(key->u.aes_cmac.rx_pn, ipn, 6); 1103 1104 /* Remove MMIE */ 1105 skb_trim(skb, skb->len - sizeof(*mmie)); 1106 1107 return RX_CONTINUE; 1108 } 1109 1110 ieee80211_tx_result 1111 ieee80211_crypto_aes_gmac_encrypt(struct ieee80211_tx_data *tx) 1112 { 1113 struct sk_buff *skb; 1114 struct ieee80211_tx_info *info; 1115 struct ieee80211_key *key = tx->key; 1116 struct ieee80211_mmie_16 *mmie; 1117 struct ieee80211_hdr *hdr; 1118 u8 aad[20]; 1119 u64 pn64; 1120 u8 nonce[12]; 1121 1122 if (WARN_ON(skb_queue_len(&tx->skbs) != 1)) 1123 return TX_DROP; 1124 1125 skb = skb_peek(&tx->skbs); 1126 1127 info = IEEE80211_SKB_CB(skb); 1128 1129 if (info->control.hw_key) 1130 return TX_CONTINUE; 1131 1132 if (WARN_ON(skb_tailroom(skb) < sizeof(*mmie))) 1133 return TX_DROP; 1134 1135 mmie = (struct ieee80211_mmie_16 *)skb_put(skb, sizeof(*mmie)); 1136 mmie->element_id = WLAN_EID_MMIE; 1137 mmie->length = sizeof(*mmie) - 2; 1138 mmie->key_id = cpu_to_le16(key->conf.keyidx); 1139 1140 /* PN = PN + 1 */ 1141 pn64 = atomic64_inc_return(&key->conf.tx_pn); 1142 1143 bip_ipn_set64(mmie->sequence_number, pn64); 1144 1145 bip_aad(skb, aad); 1146 1147 hdr = (struct ieee80211_hdr *)skb->data; 1148 memcpy(nonce, hdr->addr2, ETH_ALEN); 1149 bip_ipn_swap(nonce + ETH_ALEN, mmie->sequence_number); 1150 1151 /* MIC = AES-GMAC(IGTK, AAD || Management Frame Body || MMIE, 128) */ 1152 if (ieee80211_aes_gmac(key->u.aes_gmac.tfm, aad, nonce, 1153 skb->data + 24, skb->len - 24, mmie->mic) < 0) 1154 return TX_DROP; 1155 1156 return TX_CONTINUE; 1157 } 1158 1159 ieee80211_rx_result 1160 ieee80211_crypto_aes_gmac_decrypt(struct ieee80211_rx_data *rx) 1161 { 1162 struct sk_buff *skb = rx->skb; 1163 struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb); 1164 struct ieee80211_key *key = rx->key; 1165 struct ieee80211_mmie_16 *mmie; 1166 u8 aad[20], mic[16], ipn[6], nonce[12]; 1167 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 1168 1169 if (!ieee80211_is_mgmt(hdr->frame_control)) 1170 return RX_CONTINUE; 1171 1172 /* management frames are already linear */ 1173 1174 if (skb->len < 24 + sizeof(*mmie)) 1175 return RX_DROP_UNUSABLE; 1176 1177 mmie = (struct ieee80211_mmie_16 *) 1178 (skb->data + skb->len - sizeof(*mmie)); 1179 if (mmie->element_id != WLAN_EID_MMIE || 1180 mmie->length != sizeof(*mmie) - 2) 1181 return RX_DROP_UNUSABLE; /* Invalid MMIE */ 1182 1183 bip_ipn_swap(ipn, mmie->sequence_number); 1184 1185 if (memcmp(ipn, key->u.aes_gmac.rx_pn, 6) <= 0) { 1186 key->u.aes_gmac.replays++; 1187 return RX_DROP_UNUSABLE; 1188 } 1189 1190 if (!(status->flag & RX_FLAG_DECRYPTED)) { 1191 /* hardware didn't decrypt/verify MIC */ 1192 bip_aad(skb, aad); 1193 1194 memcpy(nonce, hdr->addr2, ETH_ALEN); 1195 memcpy(nonce + ETH_ALEN, ipn, 6); 1196 1197 if (ieee80211_aes_gmac(key->u.aes_gmac.tfm, aad, nonce, 1198 skb->data + 24, skb->len - 24, 1199 mic) < 0 || 1200 memcmp(mic, mmie->mic, sizeof(mmie->mic)) != 0) { 1201 key->u.aes_gmac.icverrors++; 1202 return RX_DROP_UNUSABLE; 1203 } 1204 } 1205 1206 memcpy(key->u.aes_gmac.rx_pn, ipn, 6); 1207 1208 /* Remove MMIE */ 1209 skb_trim(skb, skb->len - sizeof(*mmie)); 1210 1211 return RX_CONTINUE; 1212 } 1213 1214 ieee80211_tx_result 1215 ieee80211_crypto_hw_encrypt(struct ieee80211_tx_data *tx) 1216 { 1217 struct sk_buff *skb; 1218 struct ieee80211_tx_info *info = NULL; 1219 ieee80211_tx_result res; 1220 1221 skb_queue_walk(&tx->skbs, skb) { 1222 info = IEEE80211_SKB_CB(skb); 1223 1224 /* handle hw-only algorithm */ 1225 if (!info->control.hw_key) 1226 return TX_DROP; 1227 1228 if (tx->key->flags & KEY_FLAG_CIPHER_SCHEME) { 1229 res = ieee80211_crypto_cs_encrypt(tx, skb); 1230 if (res != TX_CONTINUE) 1231 return res; 1232 } 1233 } 1234 1235 ieee80211_tx_set_protected(tx); 1236 1237 return TX_CONTINUE; 1238 } 1239 1240 ieee80211_rx_result 1241 ieee80211_crypto_hw_decrypt(struct ieee80211_rx_data *rx) 1242 { 1243 if (rx->sta && rx->sta->cipher_scheme) 1244 return ieee80211_crypto_cs_decrypt(rx); 1245 1246 return RX_DROP_UNUSABLE; 1247 } 1248