1 /* 2 * Copyright 2002-2005, Instant802 Networks, Inc. 3 * Copyright 2005-2006, Devicescape Software, Inc. 4 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz> 5 * Copyright 2007-2008 Johannes Berg <johannes@sipsolutions.net> 6 * Copyright 2013-2014 Intel Mobile Communications GmbH 7 * Copyright 2015-2017 Intel Deutschland GmbH 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 as 11 * published by the Free Software Foundation. 12 */ 13 14 #include <linux/if_ether.h> 15 #include <linux/etherdevice.h> 16 #include <linux/list.h> 17 #include <linux/rcupdate.h> 18 #include <linux/rtnetlink.h> 19 #include <linux/slab.h> 20 #include <linux/export.h> 21 #include <net/mac80211.h> 22 #include <crypto/algapi.h> 23 #include <asm/unaligned.h> 24 #include "ieee80211_i.h" 25 #include "driver-ops.h" 26 #include "debugfs_key.h" 27 #include "aes_ccm.h" 28 #include "aes_cmac.h" 29 #include "aes_gmac.h" 30 #include "aes_gcm.h" 31 32 33 /** 34 * DOC: Key handling basics 35 * 36 * Key handling in mac80211 is done based on per-interface (sub_if_data) 37 * keys and per-station keys. Since each station belongs to an interface, 38 * each station key also belongs to that interface. 39 * 40 * Hardware acceleration is done on a best-effort basis for algorithms 41 * that are implemented in software, for each key the hardware is asked 42 * to enable that key for offloading but if it cannot do that the key is 43 * simply kept for software encryption (unless it is for an algorithm 44 * that isn't implemented in software). 45 * There is currently no way of knowing whether a key is handled in SW 46 * or HW except by looking into debugfs. 47 * 48 * All key management is internally protected by a mutex. Within all 49 * other parts of mac80211, key references are, just as STA structure 50 * references, protected by RCU. Note, however, that some things are 51 * unprotected, namely the key->sta dereferences within the hardware 52 * acceleration functions. This means that sta_info_destroy() must 53 * remove the key which waits for an RCU grace period. 54 */ 55 56 static const u8 bcast_addr[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; 57 58 static void assert_key_lock(struct ieee80211_local *local) 59 { 60 lockdep_assert_held(&local->key_mtx); 61 } 62 63 static void 64 update_vlan_tailroom_need_count(struct ieee80211_sub_if_data *sdata, int delta) 65 { 66 struct ieee80211_sub_if_data *vlan; 67 68 if (sdata->vif.type != NL80211_IFTYPE_AP) 69 return; 70 71 /* crypto_tx_tailroom_needed_cnt is protected by this */ 72 assert_key_lock(sdata->local); 73 74 rcu_read_lock(); 75 76 list_for_each_entry_rcu(vlan, &sdata->u.ap.vlans, u.vlan.list) 77 vlan->crypto_tx_tailroom_needed_cnt += delta; 78 79 rcu_read_unlock(); 80 } 81 82 static void increment_tailroom_need_count(struct ieee80211_sub_if_data *sdata) 83 { 84 /* 85 * When this count is zero, SKB resizing for allocating tailroom 86 * for IV or MMIC is skipped. But, this check has created two race 87 * cases in xmit path while transiting from zero count to one: 88 * 89 * 1. SKB resize was skipped because no key was added but just before 90 * the xmit key is added and SW encryption kicks off. 91 * 92 * 2. SKB resize was skipped because all the keys were hw planted but 93 * just before xmit one of the key is deleted and SW encryption kicks 94 * off. 95 * 96 * In both the above case SW encryption will find not enough space for 97 * tailroom and exits with WARN_ON. (See WARN_ONs at wpa.c) 98 * 99 * Solution has been explained at 100 * http://mid.gmane.org/1308590980.4322.19.camel@jlt3.sipsolutions.net 101 */ 102 103 assert_key_lock(sdata->local); 104 105 update_vlan_tailroom_need_count(sdata, 1); 106 107 if (!sdata->crypto_tx_tailroom_needed_cnt++) { 108 /* 109 * Flush all XMIT packets currently using HW encryption or no 110 * encryption at all if the count transition is from 0 -> 1. 111 */ 112 synchronize_net(); 113 } 114 } 115 116 static void decrease_tailroom_need_count(struct ieee80211_sub_if_data *sdata, 117 int delta) 118 { 119 assert_key_lock(sdata->local); 120 121 WARN_ON_ONCE(sdata->crypto_tx_tailroom_needed_cnt < delta); 122 123 update_vlan_tailroom_need_count(sdata, -delta); 124 sdata->crypto_tx_tailroom_needed_cnt -= delta; 125 } 126 127 static int ieee80211_key_enable_hw_accel(struct ieee80211_key *key) 128 { 129 struct ieee80211_sub_if_data *sdata = key->sdata; 130 struct sta_info *sta; 131 int ret = -EOPNOTSUPP; 132 133 might_sleep(); 134 135 if (key->flags & KEY_FLAG_TAINTED) { 136 /* If we get here, it's during resume and the key is 137 * tainted so shouldn't be used/programmed any more. 138 * However, its flags may still indicate that it was 139 * programmed into the device (since we're in resume) 140 * so clear that flag now to avoid trying to remove 141 * it again later. 142 */ 143 key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE; 144 return -EINVAL; 145 } 146 147 if (!key->local->ops->set_key) 148 goto out_unsupported; 149 150 assert_key_lock(key->local); 151 152 sta = key->sta; 153 154 /* 155 * If this is a per-STA GTK, check if it 156 * is supported; if not, return. 157 */ 158 if (sta && !(key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE) && 159 !ieee80211_hw_check(&key->local->hw, SUPPORTS_PER_STA_GTK)) 160 goto out_unsupported; 161 162 if (sta && !sta->uploaded) 163 goto out_unsupported; 164 165 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) { 166 /* 167 * The driver doesn't know anything about VLAN interfaces. 168 * Hence, don't send GTKs for VLAN interfaces to the driver. 169 */ 170 if (!(key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE)) 171 goto out_unsupported; 172 } 173 174 ret = drv_set_key(key->local, SET_KEY, sdata, 175 sta ? &sta->sta : NULL, &key->conf); 176 177 if (!ret) { 178 key->flags |= KEY_FLAG_UPLOADED_TO_HARDWARE; 179 180 if (!((key->conf.flags & (IEEE80211_KEY_FLAG_GENERATE_MMIC | 181 IEEE80211_KEY_FLAG_PUT_MIC_SPACE)) || 182 (key->conf.flags & IEEE80211_KEY_FLAG_RESERVE_TAILROOM))) 183 decrease_tailroom_need_count(sdata, 1); 184 185 WARN_ON((key->conf.flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE) && 186 (key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_IV)); 187 188 WARN_ON((key->conf.flags & IEEE80211_KEY_FLAG_PUT_MIC_SPACE) && 189 (key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_MMIC)); 190 191 return 0; 192 } 193 194 if (ret != -ENOSPC && ret != -EOPNOTSUPP && ret != 1) 195 sdata_err(sdata, 196 "failed to set key (%d, %pM) to hardware (%d)\n", 197 key->conf.keyidx, 198 sta ? sta->sta.addr : bcast_addr, ret); 199 200 out_unsupported: 201 switch (key->conf.cipher) { 202 case WLAN_CIPHER_SUITE_WEP40: 203 case WLAN_CIPHER_SUITE_WEP104: 204 case WLAN_CIPHER_SUITE_TKIP: 205 case WLAN_CIPHER_SUITE_CCMP: 206 case WLAN_CIPHER_SUITE_CCMP_256: 207 case WLAN_CIPHER_SUITE_AES_CMAC: 208 case WLAN_CIPHER_SUITE_BIP_CMAC_256: 209 case WLAN_CIPHER_SUITE_BIP_GMAC_128: 210 case WLAN_CIPHER_SUITE_BIP_GMAC_256: 211 case WLAN_CIPHER_SUITE_GCMP: 212 case WLAN_CIPHER_SUITE_GCMP_256: 213 /* all of these we can do in software - if driver can */ 214 if (ret == 1) 215 return 0; 216 if (ieee80211_hw_check(&key->local->hw, SW_CRYPTO_CONTROL)) { 217 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) 218 return 0; 219 return -EINVAL; 220 } 221 return 0; 222 default: 223 return -EINVAL; 224 } 225 } 226 227 static void ieee80211_key_disable_hw_accel(struct ieee80211_key *key) 228 { 229 struct ieee80211_sub_if_data *sdata; 230 struct sta_info *sta; 231 int ret; 232 233 might_sleep(); 234 235 if (!key || !key->local->ops->set_key) 236 return; 237 238 assert_key_lock(key->local); 239 240 if (!(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)) 241 return; 242 243 sta = key->sta; 244 sdata = key->sdata; 245 246 if (!((key->conf.flags & (IEEE80211_KEY_FLAG_GENERATE_MMIC | 247 IEEE80211_KEY_FLAG_PUT_MIC_SPACE)) || 248 (key->conf.flags & IEEE80211_KEY_FLAG_RESERVE_TAILROOM))) 249 increment_tailroom_need_count(sdata); 250 251 key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE; 252 ret = drv_set_key(key->local, DISABLE_KEY, sdata, 253 sta ? &sta->sta : NULL, &key->conf); 254 255 if (ret) 256 sdata_err(sdata, 257 "failed to remove key (%d, %pM) from hardware (%d)\n", 258 key->conf.keyidx, 259 sta ? sta->sta.addr : bcast_addr, ret); 260 } 261 262 static int ieee80211_hw_key_replace(struct ieee80211_key *old_key, 263 struct ieee80211_key *new_key, 264 bool ptk0rekey) 265 { 266 struct ieee80211_sub_if_data *sdata; 267 struct ieee80211_local *local; 268 struct sta_info *sta; 269 int ret; 270 271 /* Aggregation sessions are OK when running on SW crypto. 272 * A broken remote STA may cause issues not observed with HW 273 * crypto, though. 274 */ 275 if (!(old_key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)) 276 return 0; 277 278 assert_key_lock(old_key->local); 279 sta = old_key->sta; 280 281 /* PTK only using key ID 0 needs special handling on rekey */ 282 if (new_key && sta && ptk0rekey) { 283 local = old_key->local; 284 sdata = old_key->sdata; 285 286 /* Stop TX till we are on the new key */ 287 old_key->flags |= KEY_FLAG_TAINTED; 288 ieee80211_clear_fast_xmit(sta); 289 290 /* Aggregation sessions during rekey are complicated due to the 291 * reorder buffer and retransmits. Side step that by blocking 292 * aggregation during rekey and tear down running sessions. 293 */ 294 if (ieee80211_hw_check(&local->hw, AMPDU_AGGREGATION)) { 295 set_sta_flag(sta, WLAN_STA_BLOCK_BA); 296 ieee80211_sta_tear_down_BA_sessions(sta, 297 AGG_STOP_LOCAL_REQUEST); 298 } 299 300 if (!wiphy_ext_feature_isset(local->hw.wiphy, 301 NL80211_EXT_FEATURE_CAN_REPLACE_PTK0)) { 302 pr_warn_ratelimited("Rekeying PTK for STA %pM but driver can't safely do that.", 303 sta->sta.addr); 304 /* Flushing the driver queues *may* help prevent 305 * the clear text leaks and freezes. 306 */ 307 ieee80211_flush_queues(local, sdata, false); 308 } 309 } 310 311 ieee80211_key_disable_hw_accel(old_key); 312 313 if (new_key) 314 ret = ieee80211_key_enable_hw_accel(new_key); 315 else 316 ret = 0; 317 318 return ret; 319 } 320 321 static void __ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata, 322 int idx, bool uni, bool multi) 323 { 324 struct ieee80211_key *key = NULL; 325 326 assert_key_lock(sdata->local); 327 328 if (idx >= 0 && idx < NUM_DEFAULT_KEYS) 329 key = key_mtx_dereference(sdata->local, sdata->keys[idx]); 330 331 if (uni) { 332 rcu_assign_pointer(sdata->default_unicast_key, key); 333 ieee80211_check_fast_xmit_iface(sdata); 334 if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN) 335 drv_set_default_unicast_key(sdata->local, sdata, idx); 336 } 337 338 if (multi) 339 rcu_assign_pointer(sdata->default_multicast_key, key); 340 341 ieee80211_debugfs_key_update_default(sdata); 342 } 343 344 void ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata, int idx, 345 bool uni, bool multi) 346 { 347 mutex_lock(&sdata->local->key_mtx); 348 __ieee80211_set_default_key(sdata, idx, uni, multi); 349 mutex_unlock(&sdata->local->key_mtx); 350 } 351 352 static void 353 __ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata, int idx) 354 { 355 struct ieee80211_key *key = NULL; 356 357 assert_key_lock(sdata->local); 358 359 if (idx >= NUM_DEFAULT_KEYS && 360 idx < NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS) 361 key = key_mtx_dereference(sdata->local, sdata->keys[idx]); 362 363 rcu_assign_pointer(sdata->default_mgmt_key, key); 364 365 ieee80211_debugfs_key_update_default(sdata); 366 } 367 368 void ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata, 369 int idx) 370 { 371 mutex_lock(&sdata->local->key_mtx); 372 __ieee80211_set_default_mgmt_key(sdata, idx); 373 mutex_unlock(&sdata->local->key_mtx); 374 } 375 376 377 static int ieee80211_key_replace(struct ieee80211_sub_if_data *sdata, 378 struct sta_info *sta, 379 bool pairwise, 380 struct ieee80211_key *old, 381 struct ieee80211_key *new) 382 { 383 int idx; 384 int ret; 385 bool defunikey, defmultikey, defmgmtkey; 386 387 /* caller must provide at least one old/new */ 388 if (WARN_ON(!new && !old)) 389 return 0; 390 391 if (new) 392 list_add_tail_rcu(&new->list, &sdata->key_list); 393 394 WARN_ON(new && old && new->conf.keyidx != old->conf.keyidx); 395 396 if (old) { 397 idx = old->conf.keyidx; 398 /* TODO: proper implement and test "Extended Key ID for 399 * Individually Addressed Frames" from IEEE 802.11-2016. 400 * Till then always assume only key ID 0 is used for 401 * pairwise keys.*/ 402 ret = ieee80211_hw_key_replace(old, new, pairwise); 403 } else { 404 /* new must be provided in case old is not */ 405 idx = new->conf.keyidx; 406 if (!new->local->wowlan) 407 ret = ieee80211_key_enable_hw_accel(new); 408 else 409 ret = 0; 410 } 411 412 if (ret) 413 return ret; 414 415 if (sta) { 416 if (pairwise) { 417 rcu_assign_pointer(sta->ptk[idx], new); 418 sta->ptk_idx = idx; 419 if (new) { 420 clear_sta_flag(sta, WLAN_STA_BLOCK_BA); 421 ieee80211_check_fast_xmit(sta); 422 } 423 } else { 424 rcu_assign_pointer(sta->gtk[idx], new); 425 } 426 if (new) 427 ieee80211_check_fast_rx(sta); 428 } else { 429 defunikey = old && 430 old == key_mtx_dereference(sdata->local, 431 sdata->default_unicast_key); 432 defmultikey = old && 433 old == key_mtx_dereference(sdata->local, 434 sdata->default_multicast_key); 435 defmgmtkey = old && 436 old == key_mtx_dereference(sdata->local, 437 sdata->default_mgmt_key); 438 439 if (defunikey && !new) 440 __ieee80211_set_default_key(sdata, -1, true, false); 441 if (defmultikey && !new) 442 __ieee80211_set_default_key(sdata, -1, false, true); 443 if (defmgmtkey && !new) 444 __ieee80211_set_default_mgmt_key(sdata, -1); 445 446 rcu_assign_pointer(sdata->keys[idx], new); 447 if (defunikey && new) 448 __ieee80211_set_default_key(sdata, new->conf.keyidx, 449 true, false); 450 if (defmultikey && new) 451 __ieee80211_set_default_key(sdata, new->conf.keyidx, 452 false, true); 453 if (defmgmtkey && new) 454 __ieee80211_set_default_mgmt_key(sdata, 455 new->conf.keyidx); 456 } 457 458 if (old) 459 list_del_rcu(&old->list); 460 461 return 0; 462 } 463 464 struct ieee80211_key * 465 ieee80211_key_alloc(u32 cipher, int idx, size_t key_len, 466 const u8 *key_data, 467 size_t seq_len, const u8 *seq, 468 const struct ieee80211_cipher_scheme *cs) 469 { 470 struct ieee80211_key *key; 471 int i, j, err; 472 473 if (WARN_ON(idx < 0 || idx >= NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS)) 474 return ERR_PTR(-EINVAL); 475 476 key = kzalloc(sizeof(struct ieee80211_key) + key_len, GFP_KERNEL); 477 if (!key) 478 return ERR_PTR(-ENOMEM); 479 480 /* 481 * Default to software encryption; we'll later upload the 482 * key to the hardware if possible. 483 */ 484 key->conf.flags = 0; 485 key->flags = 0; 486 487 key->conf.cipher = cipher; 488 key->conf.keyidx = idx; 489 key->conf.keylen = key_len; 490 switch (cipher) { 491 case WLAN_CIPHER_SUITE_WEP40: 492 case WLAN_CIPHER_SUITE_WEP104: 493 key->conf.iv_len = IEEE80211_WEP_IV_LEN; 494 key->conf.icv_len = IEEE80211_WEP_ICV_LEN; 495 break; 496 case WLAN_CIPHER_SUITE_TKIP: 497 key->conf.iv_len = IEEE80211_TKIP_IV_LEN; 498 key->conf.icv_len = IEEE80211_TKIP_ICV_LEN; 499 if (seq) { 500 for (i = 0; i < IEEE80211_NUM_TIDS; i++) { 501 key->u.tkip.rx[i].iv32 = 502 get_unaligned_le32(&seq[2]); 503 key->u.tkip.rx[i].iv16 = 504 get_unaligned_le16(seq); 505 } 506 } 507 spin_lock_init(&key->u.tkip.txlock); 508 break; 509 case WLAN_CIPHER_SUITE_CCMP: 510 key->conf.iv_len = IEEE80211_CCMP_HDR_LEN; 511 key->conf.icv_len = IEEE80211_CCMP_MIC_LEN; 512 if (seq) { 513 for (i = 0; i < IEEE80211_NUM_TIDS + 1; i++) 514 for (j = 0; j < IEEE80211_CCMP_PN_LEN; j++) 515 key->u.ccmp.rx_pn[i][j] = 516 seq[IEEE80211_CCMP_PN_LEN - j - 1]; 517 } 518 /* 519 * Initialize AES key state here as an optimization so that 520 * it does not need to be initialized for every packet. 521 */ 522 key->u.ccmp.tfm = ieee80211_aes_key_setup_encrypt( 523 key_data, key_len, IEEE80211_CCMP_MIC_LEN); 524 if (IS_ERR(key->u.ccmp.tfm)) { 525 err = PTR_ERR(key->u.ccmp.tfm); 526 kfree(key); 527 return ERR_PTR(err); 528 } 529 break; 530 case WLAN_CIPHER_SUITE_CCMP_256: 531 key->conf.iv_len = IEEE80211_CCMP_256_HDR_LEN; 532 key->conf.icv_len = IEEE80211_CCMP_256_MIC_LEN; 533 for (i = 0; seq && i < IEEE80211_NUM_TIDS + 1; i++) 534 for (j = 0; j < IEEE80211_CCMP_256_PN_LEN; j++) 535 key->u.ccmp.rx_pn[i][j] = 536 seq[IEEE80211_CCMP_256_PN_LEN - j - 1]; 537 /* Initialize AES key state here as an optimization so that 538 * it does not need to be initialized for every packet. 539 */ 540 key->u.ccmp.tfm = ieee80211_aes_key_setup_encrypt( 541 key_data, key_len, IEEE80211_CCMP_256_MIC_LEN); 542 if (IS_ERR(key->u.ccmp.tfm)) { 543 err = PTR_ERR(key->u.ccmp.tfm); 544 kfree(key); 545 return ERR_PTR(err); 546 } 547 break; 548 case WLAN_CIPHER_SUITE_AES_CMAC: 549 case WLAN_CIPHER_SUITE_BIP_CMAC_256: 550 key->conf.iv_len = 0; 551 if (cipher == WLAN_CIPHER_SUITE_AES_CMAC) 552 key->conf.icv_len = sizeof(struct ieee80211_mmie); 553 else 554 key->conf.icv_len = sizeof(struct ieee80211_mmie_16); 555 if (seq) 556 for (j = 0; j < IEEE80211_CMAC_PN_LEN; j++) 557 key->u.aes_cmac.rx_pn[j] = 558 seq[IEEE80211_CMAC_PN_LEN - j - 1]; 559 /* 560 * Initialize AES key state here as an optimization so that 561 * it does not need to be initialized for every packet. 562 */ 563 key->u.aes_cmac.tfm = 564 ieee80211_aes_cmac_key_setup(key_data, key_len); 565 if (IS_ERR(key->u.aes_cmac.tfm)) { 566 err = PTR_ERR(key->u.aes_cmac.tfm); 567 kfree(key); 568 return ERR_PTR(err); 569 } 570 break; 571 case WLAN_CIPHER_SUITE_BIP_GMAC_128: 572 case WLAN_CIPHER_SUITE_BIP_GMAC_256: 573 key->conf.iv_len = 0; 574 key->conf.icv_len = sizeof(struct ieee80211_mmie_16); 575 if (seq) 576 for (j = 0; j < IEEE80211_GMAC_PN_LEN; j++) 577 key->u.aes_gmac.rx_pn[j] = 578 seq[IEEE80211_GMAC_PN_LEN - j - 1]; 579 /* Initialize AES key state here as an optimization so that 580 * it does not need to be initialized for every packet. 581 */ 582 key->u.aes_gmac.tfm = 583 ieee80211_aes_gmac_key_setup(key_data, key_len); 584 if (IS_ERR(key->u.aes_gmac.tfm)) { 585 err = PTR_ERR(key->u.aes_gmac.tfm); 586 kfree(key); 587 return ERR_PTR(err); 588 } 589 break; 590 case WLAN_CIPHER_SUITE_GCMP: 591 case WLAN_CIPHER_SUITE_GCMP_256: 592 key->conf.iv_len = IEEE80211_GCMP_HDR_LEN; 593 key->conf.icv_len = IEEE80211_GCMP_MIC_LEN; 594 for (i = 0; seq && i < IEEE80211_NUM_TIDS + 1; i++) 595 for (j = 0; j < IEEE80211_GCMP_PN_LEN; j++) 596 key->u.gcmp.rx_pn[i][j] = 597 seq[IEEE80211_GCMP_PN_LEN - j - 1]; 598 /* Initialize AES key state here as an optimization so that 599 * it does not need to be initialized for every packet. 600 */ 601 key->u.gcmp.tfm = ieee80211_aes_gcm_key_setup_encrypt(key_data, 602 key_len); 603 if (IS_ERR(key->u.gcmp.tfm)) { 604 err = PTR_ERR(key->u.gcmp.tfm); 605 kfree(key); 606 return ERR_PTR(err); 607 } 608 break; 609 default: 610 if (cs) { 611 if (seq_len && seq_len != cs->pn_len) { 612 kfree(key); 613 return ERR_PTR(-EINVAL); 614 } 615 616 key->conf.iv_len = cs->hdr_len; 617 key->conf.icv_len = cs->mic_len; 618 for (i = 0; i < IEEE80211_NUM_TIDS + 1; i++) 619 for (j = 0; j < seq_len; j++) 620 key->u.gen.rx_pn[i][j] = 621 seq[seq_len - j - 1]; 622 key->flags |= KEY_FLAG_CIPHER_SCHEME; 623 } 624 } 625 memcpy(key->conf.key, key_data, key_len); 626 INIT_LIST_HEAD(&key->list); 627 628 return key; 629 } 630 631 static void ieee80211_key_free_common(struct ieee80211_key *key) 632 { 633 switch (key->conf.cipher) { 634 case WLAN_CIPHER_SUITE_CCMP: 635 case WLAN_CIPHER_SUITE_CCMP_256: 636 ieee80211_aes_key_free(key->u.ccmp.tfm); 637 break; 638 case WLAN_CIPHER_SUITE_AES_CMAC: 639 case WLAN_CIPHER_SUITE_BIP_CMAC_256: 640 ieee80211_aes_cmac_key_free(key->u.aes_cmac.tfm); 641 break; 642 case WLAN_CIPHER_SUITE_BIP_GMAC_128: 643 case WLAN_CIPHER_SUITE_BIP_GMAC_256: 644 ieee80211_aes_gmac_key_free(key->u.aes_gmac.tfm); 645 break; 646 case WLAN_CIPHER_SUITE_GCMP: 647 case WLAN_CIPHER_SUITE_GCMP_256: 648 ieee80211_aes_gcm_key_free(key->u.gcmp.tfm); 649 break; 650 } 651 kzfree(key); 652 } 653 654 static void __ieee80211_key_destroy(struct ieee80211_key *key, 655 bool delay_tailroom) 656 { 657 if (key->local) { 658 struct ieee80211_sub_if_data *sdata = key->sdata; 659 660 ieee80211_debugfs_key_remove(key); 661 662 if (delay_tailroom) { 663 /* see ieee80211_delayed_tailroom_dec */ 664 sdata->crypto_tx_tailroom_pending_dec++; 665 schedule_delayed_work(&sdata->dec_tailroom_needed_wk, 666 HZ/2); 667 } else { 668 decrease_tailroom_need_count(sdata, 1); 669 } 670 } 671 672 ieee80211_key_free_common(key); 673 } 674 675 static void ieee80211_key_destroy(struct ieee80211_key *key, 676 bool delay_tailroom) 677 { 678 if (!key) 679 return; 680 681 /* 682 * Synchronize so the TX path and rcu key iterators 683 * can no longer be using this key before we free/remove it. 684 */ 685 synchronize_net(); 686 687 __ieee80211_key_destroy(key, delay_tailroom); 688 } 689 690 void ieee80211_key_free_unused(struct ieee80211_key *key) 691 { 692 WARN_ON(key->sdata || key->local); 693 ieee80211_key_free_common(key); 694 } 695 696 static bool ieee80211_key_identical(struct ieee80211_sub_if_data *sdata, 697 struct ieee80211_key *old, 698 struct ieee80211_key *new) 699 { 700 u8 tkip_old[WLAN_KEY_LEN_TKIP], tkip_new[WLAN_KEY_LEN_TKIP]; 701 u8 *tk_old, *tk_new; 702 703 if (!old || new->conf.keylen != old->conf.keylen) 704 return false; 705 706 tk_old = old->conf.key; 707 tk_new = new->conf.key; 708 709 /* 710 * In station mode, don't compare the TX MIC key, as it's never used 711 * and offloaded rekeying may not care to send it to the host. This 712 * is the case in iwlwifi, for example. 713 */ 714 if (sdata->vif.type == NL80211_IFTYPE_STATION && 715 new->conf.cipher == WLAN_CIPHER_SUITE_TKIP && 716 new->conf.keylen == WLAN_KEY_LEN_TKIP && 717 !(new->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE)) { 718 memcpy(tkip_old, tk_old, WLAN_KEY_LEN_TKIP); 719 memcpy(tkip_new, tk_new, WLAN_KEY_LEN_TKIP); 720 memset(tkip_old + NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY, 0, 8); 721 memset(tkip_new + NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY, 0, 8); 722 tk_old = tkip_old; 723 tk_new = tkip_new; 724 } 725 726 return !crypto_memneq(tk_old, tk_new, new->conf.keylen); 727 } 728 729 int ieee80211_key_link(struct ieee80211_key *key, 730 struct ieee80211_sub_if_data *sdata, 731 struct sta_info *sta) 732 { 733 struct ieee80211_key *old_key; 734 int idx = key->conf.keyidx; 735 bool pairwise = key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE; 736 /* 737 * We want to delay tailroom updates only for station - in that 738 * case it helps roaming speed, but in other cases it hurts and 739 * can cause warnings to appear. 740 */ 741 bool delay_tailroom = sdata->vif.type == NL80211_IFTYPE_STATION; 742 int ret; 743 744 mutex_lock(&sdata->local->key_mtx); 745 746 if (sta && pairwise) 747 old_key = key_mtx_dereference(sdata->local, sta->ptk[idx]); 748 else if (sta) 749 old_key = key_mtx_dereference(sdata->local, sta->gtk[idx]); 750 else 751 old_key = key_mtx_dereference(sdata->local, sdata->keys[idx]); 752 753 /* 754 * Silently accept key re-installation without really installing the 755 * new version of the key to avoid nonce reuse or replay issues. 756 */ 757 if (ieee80211_key_identical(sdata, old_key, key)) { 758 ieee80211_key_free_unused(key); 759 ret = 0; 760 goto out; 761 } 762 763 key->local = sdata->local; 764 key->sdata = sdata; 765 key->sta = sta; 766 767 increment_tailroom_need_count(sdata); 768 769 ret = ieee80211_key_replace(sdata, sta, pairwise, old_key, key); 770 771 if (!ret) { 772 ieee80211_debugfs_key_add(key); 773 ieee80211_key_destroy(old_key, delay_tailroom); 774 } else { 775 ieee80211_key_free(key, delay_tailroom); 776 } 777 778 out: 779 mutex_unlock(&sdata->local->key_mtx); 780 781 return ret; 782 } 783 784 void ieee80211_key_free(struct ieee80211_key *key, bool delay_tailroom) 785 { 786 if (!key) 787 return; 788 789 /* 790 * Replace key with nothingness if it was ever used. 791 */ 792 if (key->sdata) 793 ieee80211_key_replace(key->sdata, key->sta, 794 key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE, 795 key, NULL); 796 ieee80211_key_destroy(key, delay_tailroom); 797 } 798 799 void ieee80211_enable_keys(struct ieee80211_sub_if_data *sdata) 800 { 801 struct ieee80211_key *key; 802 struct ieee80211_sub_if_data *vlan; 803 804 ASSERT_RTNL(); 805 806 if (WARN_ON(!ieee80211_sdata_running(sdata))) 807 return; 808 809 mutex_lock(&sdata->local->key_mtx); 810 811 WARN_ON_ONCE(sdata->crypto_tx_tailroom_needed_cnt || 812 sdata->crypto_tx_tailroom_pending_dec); 813 814 if (sdata->vif.type == NL80211_IFTYPE_AP) { 815 list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list) 816 WARN_ON_ONCE(vlan->crypto_tx_tailroom_needed_cnt || 817 vlan->crypto_tx_tailroom_pending_dec); 818 } 819 820 list_for_each_entry(key, &sdata->key_list, list) { 821 increment_tailroom_need_count(sdata); 822 ieee80211_key_enable_hw_accel(key); 823 } 824 825 mutex_unlock(&sdata->local->key_mtx); 826 } 827 828 void ieee80211_reset_crypto_tx_tailroom(struct ieee80211_sub_if_data *sdata) 829 { 830 struct ieee80211_sub_if_data *vlan; 831 832 mutex_lock(&sdata->local->key_mtx); 833 834 sdata->crypto_tx_tailroom_needed_cnt = 0; 835 836 if (sdata->vif.type == NL80211_IFTYPE_AP) { 837 list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list) 838 vlan->crypto_tx_tailroom_needed_cnt = 0; 839 } 840 841 mutex_unlock(&sdata->local->key_mtx); 842 } 843 844 void ieee80211_iter_keys(struct ieee80211_hw *hw, 845 struct ieee80211_vif *vif, 846 void (*iter)(struct ieee80211_hw *hw, 847 struct ieee80211_vif *vif, 848 struct ieee80211_sta *sta, 849 struct ieee80211_key_conf *key, 850 void *data), 851 void *iter_data) 852 { 853 struct ieee80211_local *local = hw_to_local(hw); 854 struct ieee80211_key *key, *tmp; 855 struct ieee80211_sub_if_data *sdata; 856 857 ASSERT_RTNL(); 858 859 mutex_lock(&local->key_mtx); 860 if (vif) { 861 sdata = vif_to_sdata(vif); 862 list_for_each_entry_safe(key, tmp, &sdata->key_list, list) 863 iter(hw, &sdata->vif, 864 key->sta ? &key->sta->sta : NULL, 865 &key->conf, iter_data); 866 } else { 867 list_for_each_entry(sdata, &local->interfaces, list) 868 list_for_each_entry_safe(key, tmp, 869 &sdata->key_list, list) 870 iter(hw, &sdata->vif, 871 key->sta ? &key->sta->sta : NULL, 872 &key->conf, iter_data); 873 } 874 mutex_unlock(&local->key_mtx); 875 } 876 EXPORT_SYMBOL(ieee80211_iter_keys); 877 878 static void 879 _ieee80211_iter_keys_rcu(struct ieee80211_hw *hw, 880 struct ieee80211_sub_if_data *sdata, 881 void (*iter)(struct ieee80211_hw *hw, 882 struct ieee80211_vif *vif, 883 struct ieee80211_sta *sta, 884 struct ieee80211_key_conf *key, 885 void *data), 886 void *iter_data) 887 { 888 struct ieee80211_key *key; 889 890 list_for_each_entry_rcu(key, &sdata->key_list, list) { 891 /* skip keys of station in removal process */ 892 if (key->sta && key->sta->removed) 893 continue; 894 if (!(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)) 895 continue; 896 897 iter(hw, &sdata->vif, 898 key->sta ? &key->sta->sta : NULL, 899 &key->conf, iter_data); 900 } 901 } 902 903 void ieee80211_iter_keys_rcu(struct ieee80211_hw *hw, 904 struct ieee80211_vif *vif, 905 void (*iter)(struct ieee80211_hw *hw, 906 struct ieee80211_vif *vif, 907 struct ieee80211_sta *sta, 908 struct ieee80211_key_conf *key, 909 void *data), 910 void *iter_data) 911 { 912 struct ieee80211_local *local = hw_to_local(hw); 913 struct ieee80211_sub_if_data *sdata; 914 915 if (vif) { 916 sdata = vif_to_sdata(vif); 917 _ieee80211_iter_keys_rcu(hw, sdata, iter, iter_data); 918 } else { 919 list_for_each_entry_rcu(sdata, &local->interfaces, list) 920 _ieee80211_iter_keys_rcu(hw, sdata, iter, iter_data); 921 } 922 } 923 EXPORT_SYMBOL(ieee80211_iter_keys_rcu); 924 925 static void ieee80211_free_keys_iface(struct ieee80211_sub_if_data *sdata, 926 struct list_head *keys) 927 { 928 struct ieee80211_key *key, *tmp; 929 930 decrease_tailroom_need_count(sdata, 931 sdata->crypto_tx_tailroom_pending_dec); 932 sdata->crypto_tx_tailroom_pending_dec = 0; 933 934 ieee80211_debugfs_key_remove_mgmt_default(sdata); 935 936 list_for_each_entry_safe(key, tmp, &sdata->key_list, list) { 937 ieee80211_key_replace(key->sdata, key->sta, 938 key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE, 939 key, NULL); 940 list_add_tail(&key->list, keys); 941 } 942 943 ieee80211_debugfs_key_update_default(sdata); 944 } 945 946 void ieee80211_free_keys(struct ieee80211_sub_if_data *sdata, 947 bool force_synchronize) 948 { 949 struct ieee80211_local *local = sdata->local; 950 struct ieee80211_sub_if_data *vlan; 951 struct ieee80211_sub_if_data *master; 952 struct ieee80211_key *key, *tmp; 953 LIST_HEAD(keys); 954 955 cancel_delayed_work_sync(&sdata->dec_tailroom_needed_wk); 956 957 mutex_lock(&local->key_mtx); 958 959 ieee80211_free_keys_iface(sdata, &keys); 960 961 if (sdata->vif.type == NL80211_IFTYPE_AP) { 962 list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list) 963 ieee80211_free_keys_iface(vlan, &keys); 964 } 965 966 if (!list_empty(&keys) || force_synchronize) 967 synchronize_net(); 968 list_for_each_entry_safe(key, tmp, &keys, list) 969 __ieee80211_key_destroy(key, false); 970 971 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) { 972 if (sdata->bss) { 973 master = container_of(sdata->bss, 974 struct ieee80211_sub_if_data, 975 u.ap); 976 977 WARN_ON_ONCE(sdata->crypto_tx_tailroom_needed_cnt != 978 master->crypto_tx_tailroom_needed_cnt); 979 } 980 } else { 981 WARN_ON_ONCE(sdata->crypto_tx_tailroom_needed_cnt || 982 sdata->crypto_tx_tailroom_pending_dec); 983 } 984 985 if (sdata->vif.type == NL80211_IFTYPE_AP) { 986 list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list) 987 WARN_ON_ONCE(vlan->crypto_tx_tailroom_needed_cnt || 988 vlan->crypto_tx_tailroom_pending_dec); 989 } 990 991 mutex_unlock(&local->key_mtx); 992 } 993 994 void ieee80211_free_sta_keys(struct ieee80211_local *local, 995 struct sta_info *sta) 996 { 997 struct ieee80211_key *key; 998 int i; 999 1000 mutex_lock(&local->key_mtx); 1001 for (i = 0; i < ARRAY_SIZE(sta->gtk); i++) { 1002 key = key_mtx_dereference(local, sta->gtk[i]); 1003 if (!key) 1004 continue; 1005 ieee80211_key_replace(key->sdata, key->sta, 1006 key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE, 1007 key, NULL); 1008 __ieee80211_key_destroy(key, key->sdata->vif.type == 1009 NL80211_IFTYPE_STATION); 1010 } 1011 1012 for (i = 0; i < NUM_DEFAULT_KEYS; i++) { 1013 key = key_mtx_dereference(local, sta->ptk[i]); 1014 if (!key) 1015 continue; 1016 ieee80211_key_replace(key->sdata, key->sta, 1017 key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE, 1018 key, NULL); 1019 __ieee80211_key_destroy(key, key->sdata->vif.type == 1020 NL80211_IFTYPE_STATION); 1021 } 1022 1023 mutex_unlock(&local->key_mtx); 1024 } 1025 1026 void ieee80211_delayed_tailroom_dec(struct work_struct *wk) 1027 { 1028 struct ieee80211_sub_if_data *sdata; 1029 1030 sdata = container_of(wk, struct ieee80211_sub_if_data, 1031 dec_tailroom_needed_wk.work); 1032 1033 /* 1034 * The reason for the delayed tailroom needed decrementing is to 1035 * make roaming faster: during roaming, all keys are first deleted 1036 * and then new keys are installed. The first new key causes the 1037 * crypto_tx_tailroom_needed_cnt to go from 0 to 1, which invokes 1038 * the cost of synchronize_net() (which can be slow). Avoid this 1039 * by deferring the crypto_tx_tailroom_needed_cnt decrementing on 1040 * key removal for a while, so if we roam the value is larger than 1041 * zero and no 0->1 transition happens. 1042 * 1043 * The cost is that if the AP switching was from an AP with keys 1044 * to one without, we still allocate tailroom while it would no 1045 * longer be needed. However, in the typical (fast) roaming case 1046 * within an ESS this usually won't happen. 1047 */ 1048 1049 mutex_lock(&sdata->local->key_mtx); 1050 decrease_tailroom_need_count(sdata, 1051 sdata->crypto_tx_tailroom_pending_dec); 1052 sdata->crypto_tx_tailroom_pending_dec = 0; 1053 mutex_unlock(&sdata->local->key_mtx); 1054 } 1055 1056 void ieee80211_gtk_rekey_notify(struct ieee80211_vif *vif, const u8 *bssid, 1057 const u8 *replay_ctr, gfp_t gfp) 1058 { 1059 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 1060 1061 trace_api_gtk_rekey_notify(sdata, bssid, replay_ctr); 1062 1063 cfg80211_gtk_rekey_notify(sdata->dev, bssid, replay_ctr, gfp); 1064 } 1065 EXPORT_SYMBOL_GPL(ieee80211_gtk_rekey_notify); 1066 1067 void ieee80211_get_key_rx_seq(struct ieee80211_key_conf *keyconf, 1068 int tid, struct ieee80211_key_seq *seq) 1069 { 1070 struct ieee80211_key *key; 1071 const u8 *pn; 1072 1073 key = container_of(keyconf, struct ieee80211_key, conf); 1074 1075 switch (key->conf.cipher) { 1076 case WLAN_CIPHER_SUITE_TKIP: 1077 if (WARN_ON(tid < 0 || tid >= IEEE80211_NUM_TIDS)) 1078 return; 1079 seq->tkip.iv32 = key->u.tkip.rx[tid].iv32; 1080 seq->tkip.iv16 = key->u.tkip.rx[tid].iv16; 1081 break; 1082 case WLAN_CIPHER_SUITE_CCMP: 1083 case WLAN_CIPHER_SUITE_CCMP_256: 1084 if (WARN_ON(tid < -1 || tid >= IEEE80211_NUM_TIDS)) 1085 return; 1086 if (tid < 0) 1087 pn = key->u.ccmp.rx_pn[IEEE80211_NUM_TIDS]; 1088 else 1089 pn = key->u.ccmp.rx_pn[tid]; 1090 memcpy(seq->ccmp.pn, pn, IEEE80211_CCMP_PN_LEN); 1091 break; 1092 case WLAN_CIPHER_SUITE_AES_CMAC: 1093 case WLAN_CIPHER_SUITE_BIP_CMAC_256: 1094 if (WARN_ON(tid != 0)) 1095 return; 1096 pn = key->u.aes_cmac.rx_pn; 1097 memcpy(seq->aes_cmac.pn, pn, IEEE80211_CMAC_PN_LEN); 1098 break; 1099 case WLAN_CIPHER_SUITE_BIP_GMAC_128: 1100 case WLAN_CIPHER_SUITE_BIP_GMAC_256: 1101 if (WARN_ON(tid != 0)) 1102 return; 1103 pn = key->u.aes_gmac.rx_pn; 1104 memcpy(seq->aes_gmac.pn, pn, IEEE80211_GMAC_PN_LEN); 1105 break; 1106 case WLAN_CIPHER_SUITE_GCMP: 1107 case WLAN_CIPHER_SUITE_GCMP_256: 1108 if (WARN_ON(tid < -1 || tid >= IEEE80211_NUM_TIDS)) 1109 return; 1110 if (tid < 0) 1111 pn = key->u.gcmp.rx_pn[IEEE80211_NUM_TIDS]; 1112 else 1113 pn = key->u.gcmp.rx_pn[tid]; 1114 memcpy(seq->gcmp.pn, pn, IEEE80211_GCMP_PN_LEN); 1115 break; 1116 } 1117 } 1118 EXPORT_SYMBOL(ieee80211_get_key_rx_seq); 1119 1120 void ieee80211_set_key_rx_seq(struct ieee80211_key_conf *keyconf, 1121 int tid, struct ieee80211_key_seq *seq) 1122 { 1123 struct ieee80211_key *key; 1124 u8 *pn; 1125 1126 key = container_of(keyconf, struct ieee80211_key, conf); 1127 1128 switch (key->conf.cipher) { 1129 case WLAN_CIPHER_SUITE_TKIP: 1130 if (WARN_ON(tid < 0 || tid >= IEEE80211_NUM_TIDS)) 1131 return; 1132 key->u.tkip.rx[tid].iv32 = seq->tkip.iv32; 1133 key->u.tkip.rx[tid].iv16 = seq->tkip.iv16; 1134 break; 1135 case WLAN_CIPHER_SUITE_CCMP: 1136 case WLAN_CIPHER_SUITE_CCMP_256: 1137 if (WARN_ON(tid < -1 || tid >= IEEE80211_NUM_TIDS)) 1138 return; 1139 if (tid < 0) 1140 pn = key->u.ccmp.rx_pn[IEEE80211_NUM_TIDS]; 1141 else 1142 pn = key->u.ccmp.rx_pn[tid]; 1143 memcpy(pn, seq->ccmp.pn, IEEE80211_CCMP_PN_LEN); 1144 break; 1145 case WLAN_CIPHER_SUITE_AES_CMAC: 1146 case WLAN_CIPHER_SUITE_BIP_CMAC_256: 1147 if (WARN_ON(tid != 0)) 1148 return; 1149 pn = key->u.aes_cmac.rx_pn; 1150 memcpy(pn, seq->aes_cmac.pn, IEEE80211_CMAC_PN_LEN); 1151 break; 1152 case WLAN_CIPHER_SUITE_BIP_GMAC_128: 1153 case WLAN_CIPHER_SUITE_BIP_GMAC_256: 1154 if (WARN_ON(tid != 0)) 1155 return; 1156 pn = key->u.aes_gmac.rx_pn; 1157 memcpy(pn, seq->aes_gmac.pn, IEEE80211_GMAC_PN_LEN); 1158 break; 1159 case WLAN_CIPHER_SUITE_GCMP: 1160 case WLAN_CIPHER_SUITE_GCMP_256: 1161 if (WARN_ON(tid < -1 || tid >= IEEE80211_NUM_TIDS)) 1162 return; 1163 if (tid < 0) 1164 pn = key->u.gcmp.rx_pn[IEEE80211_NUM_TIDS]; 1165 else 1166 pn = key->u.gcmp.rx_pn[tid]; 1167 memcpy(pn, seq->gcmp.pn, IEEE80211_GCMP_PN_LEN); 1168 break; 1169 default: 1170 WARN_ON(1); 1171 break; 1172 } 1173 } 1174 EXPORT_SYMBOL_GPL(ieee80211_set_key_rx_seq); 1175 1176 void ieee80211_remove_key(struct ieee80211_key_conf *keyconf) 1177 { 1178 struct ieee80211_key *key; 1179 1180 key = container_of(keyconf, struct ieee80211_key, conf); 1181 1182 assert_key_lock(key->local); 1183 1184 /* 1185 * if key was uploaded, we assume the driver will/has remove(d) 1186 * it, so adjust bookkeeping accordingly 1187 */ 1188 if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE) { 1189 key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE; 1190 1191 if (!((key->conf.flags & (IEEE80211_KEY_FLAG_GENERATE_MMIC | 1192 IEEE80211_KEY_FLAG_PUT_MIC_SPACE)) || 1193 (key->conf.flags & IEEE80211_KEY_FLAG_RESERVE_TAILROOM))) 1194 increment_tailroom_need_count(key->sdata); 1195 } 1196 1197 ieee80211_key_free(key, false); 1198 } 1199 EXPORT_SYMBOL_GPL(ieee80211_remove_key); 1200 1201 struct ieee80211_key_conf * 1202 ieee80211_gtk_rekey_add(struct ieee80211_vif *vif, 1203 struct ieee80211_key_conf *keyconf) 1204 { 1205 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 1206 struct ieee80211_local *local = sdata->local; 1207 struct ieee80211_key *key; 1208 int err; 1209 1210 if (WARN_ON(!local->wowlan)) 1211 return ERR_PTR(-EINVAL); 1212 1213 if (WARN_ON(vif->type != NL80211_IFTYPE_STATION)) 1214 return ERR_PTR(-EINVAL); 1215 1216 key = ieee80211_key_alloc(keyconf->cipher, keyconf->keyidx, 1217 keyconf->keylen, keyconf->key, 1218 0, NULL, NULL); 1219 if (IS_ERR(key)) 1220 return ERR_CAST(key); 1221 1222 if (sdata->u.mgd.mfp != IEEE80211_MFP_DISABLED) 1223 key->conf.flags |= IEEE80211_KEY_FLAG_RX_MGMT; 1224 1225 err = ieee80211_key_link(key, sdata, NULL); 1226 if (err) 1227 return ERR_PTR(err); 1228 1229 return &key->conf; 1230 } 1231 EXPORT_SYMBOL_GPL(ieee80211_gtk_rekey_add); 1232