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