net/mac80211/key.c

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