net/mac80211/key.c

   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  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  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 <net/mac80211.h>
  19 #include "ieee80211_i.h"
  20 #include "driver-ops.h"
  21 #include "debugfs_key.h"
  22 #include "aes_ccm.h"
  23 #include "aes_cmac.h"
  24
  25
  26 /**
  27  * DOC: Key handling basics
  28  *
  29  * Key handling in mac80211 is done based on per-interface (sub_if_data)
  30  * keys and per-station keys. Since each station belongs to an interface,
  31  * each station key also belongs to that interface.
  32  *
  33  * Hardware acceleration is done on a best-effort basis for algorithms
  34  * that are implemented in software,  for each key the hardware is asked
  35  * to enable that key for offloading but if it cannot do that the key is
  36  * simply kept for software encryption (unless it is for an algorithm
  37  * that isn't implemented in software).
  38  * There is currently no way of knowing whether a key is handled in SW
  39  * or HW except by looking into debugfs.
  40  *
  41  * All key management is internally protected by a mutex. Within all
  42  * other parts of mac80211, key references are, just as STA structure
  43  * references, protected by RCU. Note, however, that some things are
  44  * unprotected, namely the key->sta dereferences within the hardware
  45  * acceleration functions. This means that sta_info_destroy() must
  46  * remove the key which waits for an RCU grace period.
  47  */
  48
  49 static const u8 bcast_addr[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
  50
  51 static void assert_key_lock(struct ieee80211_local *local)
  52 {
  53         lockdep_assert_held(&local->key_mtx);
  54 }
  55
  56 static struct ieee80211_sta *get_sta_for_key(struct ieee80211_key *key)
  57 {
  58         if (key->sta)
  59                 return &key->sta->sta;
  60
  61         return NULL;
  62 }
  63
  64 static int ieee80211_key_enable_hw_accel(struct ieee80211_key *key)
  65 {
  66         struct ieee80211_sub_if_data *sdata;
  67         struct ieee80211_sta *sta;
  68         int ret;
  69
  70         might_sleep();
  71
  72         if (!key->local->ops->set_key)
  73                 goto out_unsupported;
  74
  75         assert_key_lock(key->local);
  76
  77         sta = get_sta_for_key(key);
  78
  79         /*
  80          * If this is a per-STA GTK, check if it
  81          * is supported; if not, return.
  82          */
  83         if (sta && !(key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE) &&
  84             !(key->local->hw.flags & IEEE80211_HW_SUPPORTS_PER_STA_GTK))
  85                 goto out_unsupported;
  86
  87         sdata = key->sdata;
  88         if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
  89                 /*
  90                  * The driver doesn't know anything about VLAN interfaces.
  91                  * Hence, don't send GTKs for VLAN interfaces to the driver.
  92                  */
  93                 if (!(key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE))
  94                         goto out_unsupported;
  95                 sdata = container_of(sdata->bss,
  96                                      struct ieee80211_sub_if_data,
  97                                      u.ap);
  98         }
  99
 100         ret = drv_set_key(key->local, SET_KEY, sdata, sta, &key->conf);
 101
 102         if (!ret) {
 103                 key->flags |= KEY_FLAG_UPLOADED_TO_HARDWARE;
 104
 105                 if (!((key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_MMIC) ||
 106                       (key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_IV)))
 107                         key->local->crypto_tx_tailroom_needed_cnt--;
 108
 109                 return 0;
 110         }
 111
 112         if (ret != -ENOSPC && ret != -EOPNOTSUPP)
 113                 wiphy_err(key->local->hw.wiphy,
 114                           "failed to set key (%d, %pM) to hardware (%d)\n",
 115                           key->conf.keyidx, sta ? sta->addr : bcast_addr, ret);
 116
 117  out_unsupported:
 118         switch (key->conf.cipher) {
 119         case WLAN_CIPHER_SUITE_WEP40:
 120         case WLAN_CIPHER_SUITE_WEP104:
 121         case WLAN_CIPHER_SUITE_TKIP:
 122         case WLAN_CIPHER_SUITE_CCMP:
 123         case WLAN_CIPHER_SUITE_AES_CMAC:
 124                 /* all of these we can do in software */
 125                 return 0;
 126         default:
 127                 return -EINVAL;
 128         }
 129 }
 130
 131 static void ieee80211_key_disable_hw_accel(struct ieee80211_key *key)
 132 {
 133         struct ieee80211_sub_if_data *sdata;
 134         struct ieee80211_sta *sta;
 135         int ret;
 136
 137         might_sleep();
 138
 139         if (!key || !key->local->ops->set_key)
 140                 return;
 141
 142         assert_key_lock(key->local);
 143
 144         if (!(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
 145                 return;
 146
 147         sta = get_sta_for_key(key);
 148         sdata = key->sdata;
 149
 150         if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
 151                 sdata = container_of(sdata->bss,
 152                                      struct ieee80211_sub_if_data,
 153                                      u.ap);
 154
 155         ret = drv_set_key(key->local, DISABLE_KEY, sdata,
 156                           sta, &key->conf);
 157
 158         if (ret)
 159                 wiphy_err(key->local->hw.wiphy,
 160                           "failed to remove key (%d, %pM) from hardware (%d)\n",
 161                           key->conf.keyidx, sta ? sta->addr : bcast_addr, ret);
 162
 163         key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE;
 164
 165         if (!((key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_MMIC) ||
 166               (key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_IV)))
 167                 key->local->crypto_tx_tailroom_needed_cnt++;
 168 }
 169
 170 void ieee80211_key_removed(struct ieee80211_key_conf *key_conf)
 171 {
 172         struct ieee80211_key *key;
 173
 174         key = container_of(key_conf, struct ieee80211_key, conf);
 175
 176         might_sleep();
 177         assert_key_lock(key->local);
 178
 179         key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE;
 180
 181         /*
 182          * Flush TX path to avoid attempts to use this key
 183          * after this function returns. Until then, drivers
 184          * must be prepared to handle the key.
 185          */
 186         synchronize_rcu();
 187 }
 188 EXPORT_SYMBOL_GPL(ieee80211_key_removed);
 189
 190 static void __ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata,
 191                                         int idx, bool uni, bool multi)
 192 {
 193         struct ieee80211_key *key = NULL;
 194
 195         assert_key_lock(sdata->local);
 196
 197         if (idx >= 0 && idx < NUM_DEFAULT_KEYS)
 198                 key = sdata->keys[idx];
 199
 200         if (uni)
 201                 rcu_assign_pointer(sdata->default_unicast_key, key);
 202         if (multi)
 203                 rcu_assign_pointer(sdata->default_multicast_key, key);
 204
 205         ieee80211_debugfs_key_update_default(sdata);
 206 }
 207
 208 void ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata, int idx,
 209                                bool uni, bool multi)
 210 {
 211         mutex_lock(&sdata->local->key_mtx);
 212         __ieee80211_set_default_key(sdata, idx, uni, multi);
 213         mutex_unlock(&sdata->local->key_mtx);
 214 }
 215
 216 static void
 217 __ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata, int idx)
 218 {
 219         struct ieee80211_key *key = NULL;
 220
 221         assert_key_lock(sdata->local);
 222
 223         if (idx >= NUM_DEFAULT_KEYS &&
 224             idx < NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS)
 225                 key = sdata->keys[idx];
 226
 227         rcu_assign_pointer(sdata->default_mgmt_key, key);
 228
 229         ieee80211_debugfs_key_update_default(sdata);
 230 }
 231
 232 void ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata,
 233                                     int idx)
 234 {
 235         mutex_lock(&sdata->local->key_mtx);
 236         __ieee80211_set_default_mgmt_key(sdata, idx);
 237         mutex_unlock(&sdata->local->key_mtx);
 238 }
 239
 240
 241 static void __ieee80211_key_replace(struct ieee80211_sub_if_data *sdata,
 242                                     struct sta_info *sta,
 243                                     bool pairwise,
 244                                     struct ieee80211_key *old,
 245                                     struct ieee80211_key *new)
 246 {
 247         int idx;
 248         bool defunikey, defmultikey, defmgmtkey;
 249
 250         if (new)
 251                 list_add(&new->list, &sdata->key_list);
 252
 253         if (sta && pairwise) {
 254                 rcu_assign_pointer(sta->ptk, new);
 255         } else if (sta) {
 256                 if (old)
 257                         idx = old->conf.keyidx;
 258                 else
 259                         idx = new->conf.keyidx;
 260                 rcu_assign_pointer(sta->gtk[idx], new);
 261         } else {
 262                 WARN_ON(new && old && new->conf.keyidx != old->conf.keyidx);
 263
 264                 if (old)
 265                         idx = old->conf.keyidx;
 266                 else
 267                         idx = new->conf.keyidx;
 268
 269                 defunikey = old && sdata->default_unicast_key == old;
 270                 defmultikey = old && sdata->default_multicast_key == old;
 271                 defmgmtkey = old && sdata->default_mgmt_key == old;
 272
 273                 if (defunikey && !new)
 274                         __ieee80211_set_default_key(sdata, -1, true, false);
 275                 if (defmultikey && !new)
 276                         __ieee80211_set_default_key(sdata, -1, false, true);
 277                 if (defmgmtkey && !new)
 278                         __ieee80211_set_default_mgmt_key(sdata, -1);
 279
 280                 rcu_assign_pointer(sdata->keys[idx], new);
 281                 if (defunikey && new)
 282                         __ieee80211_set_default_key(sdata, new->conf.keyidx,
 283                                                     true, false);
 284                 if (defmultikey && new)
 285                         __ieee80211_set_default_key(sdata, new->conf.keyidx,
 286                                                     false, true);
 287                 if (defmgmtkey && new)
 288                         __ieee80211_set_default_mgmt_key(sdata,
 289                                                          new->conf.keyidx);
 290         }
 291
 292         if (old)
 293                 list_del(&old->list);
 294 }
 295
 296 struct ieee80211_key *ieee80211_key_alloc(u32 cipher, int idx, size_t key_len,
 297                                           const u8 *key_data,
 298                                           size_t seq_len, const u8 *seq)
 299 {
 300         struct ieee80211_key *key;
 301         int i, j, err;
 302
 303         BUG_ON(idx < 0 || idx >= NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS);
 304
 305         key = kzalloc(sizeof(struct ieee80211_key) + key_len, GFP_KERNEL);
 306         if (!key)
 307                 return ERR_PTR(-ENOMEM);
 308
 309         /*
 310          * Default to software encryption; we'll later upload the
 311          * key to the hardware if possible.
 312          */
 313         key->conf.flags = 0;
 314         key->flags = 0;
 315
 316         key->conf.cipher = cipher;
 317         key->conf.keyidx = idx;
 318         key->conf.keylen = key_len;
 319         switch (cipher) {
 320         case WLAN_CIPHER_SUITE_WEP40:
 321         case WLAN_CIPHER_SUITE_WEP104:
 322                 key->conf.iv_len = WEP_IV_LEN;
 323                 key->conf.icv_len = WEP_ICV_LEN;
 324                 break;
 325         case WLAN_CIPHER_SUITE_TKIP:
 326                 key->conf.iv_len = TKIP_IV_LEN;
 327                 key->conf.icv_len = TKIP_ICV_LEN;
 328                 if (seq) {
 329                         for (i = 0; i < NUM_RX_DATA_QUEUES; i++) {
 330                                 key->u.tkip.rx[i].iv32 =
 331                                         get_unaligned_le32(&seq[2]);
 332                                 key->u.tkip.rx[i].iv16 =
 333                                         get_unaligned_le16(seq);
 334                         }
 335                 }
 336                 break;
 337         case WLAN_CIPHER_SUITE_CCMP:
 338                 key->conf.iv_len = CCMP_HDR_LEN;
 339                 key->conf.icv_len = CCMP_MIC_LEN;
 340                 if (seq) {
 341                         for (i = 0; i < NUM_RX_DATA_QUEUES + 1; i++)
 342                                 for (j = 0; j < CCMP_PN_LEN; j++)
 343                                         key->u.ccmp.rx_pn[i][j] =
 344                                                 seq[CCMP_PN_LEN - j - 1];
 345                 }
 346                 /*
 347                  * Initialize AES key state here as an optimization so that
 348                  * it does not need to be initialized for every packet.
 349                  */
 350                 key->u.ccmp.tfm = ieee80211_aes_key_setup_encrypt(key_data);
 351                 if (IS_ERR(key->u.ccmp.tfm)) {
 352                         err = PTR_ERR(key->u.ccmp.tfm);
 353                         kfree(key);
 354                         return ERR_PTR(err);
 355                 }
 356                 break;
 357         case WLAN_CIPHER_SUITE_AES_CMAC:
 358                 key->conf.iv_len = 0;
 359                 key->conf.icv_len = sizeof(struct ieee80211_mmie);
 360                 if (seq)
 361                         for (j = 0; j < 6; j++)
 362                                 key->u.aes_cmac.rx_pn[j] = seq[6 - j - 1];
 363                 /*
 364                  * Initialize AES key state here as an optimization so that
 365                  * it does not need to be initialized for every packet.
 366                  */
 367                 key->u.aes_cmac.tfm =
 368                         ieee80211_aes_cmac_key_setup(key_data);
 369                 if (IS_ERR(key->u.aes_cmac.tfm)) {
 370                         err = PTR_ERR(key->u.aes_cmac.tfm);
 371                         kfree(key);
 372                         return ERR_PTR(err);
 373                 }
 374                 break;
 375         }
 376         memcpy(key->conf.key, key_data, key_len);
 377         INIT_LIST_HEAD(&key->list);
 378
 379         return key;
 380 }
 381
 382 static void __ieee80211_key_destroy(struct ieee80211_key *key)
 383 {
 384         if (!key)
 385                 return;
 386
 387         /*
 388          * Synchronize so the TX path can no longer be using
 389          * this key before we free/remove it.
 390          */
 391         synchronize_rcu();
 392
 393         if (key->local)
 394                 ieee80211_key_disable_hw_accel(key);
 395
 396         if (key->conf.cipher == WLAN_CIPHER_SUITE_CCMP)
 397                 ieee80211_aes_key_free(key->u.ccmp.tfm);
 398         if (key->conf.cipher == WLAN_CIPHER_SUITE_AES_CMAC)
 399                 ieee80211_aes_cmac_key_free(key->u.aes_cmac.tfm);
 400         if (key->local) {
 401                 ieee80211_debugfs_key_remove(key);
 402                 key->local->crypto_tx_tailroom_needed_cnt--;
 403         }
 404
 405         kfree(key);
 406 }
 407
 408 int ieee80211_key_link(struct ieee80211_key *key,
 409                        struct ieee80211_sub_if_data *sdata,
 410                        struct sta_info *sta)
 411 {
 412         struct ieee80211_key *old_key;
 413         int idx, ret;
 414         bool pairwise;
 415
 416         BUG_ON(!sdata);
 417         BUG_ON(!key);
 418
 419         pairwise = key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE;
 420         idx = key->conf.keyidx;
 421         key->local = sdata->local;
 422         key->sdata = sdata;
 423         key->sta = sta;
 424
 425         if (sta) {
 426                 /*
 427                  * some hardware cannot handle TKIP with QoS, so
 428                  * we indicate whether QoS could be in use.
 429                  */
 430                 if (test_sta_flags(sta, WLAN_STA_WME))
 431                         key->conf.flags |= IEEE80211_KEY_FLAG_WMM_STA;
 432         } else {
 433                 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
 434                         struct sta_info *ap;
 435
 436                         /*
 437                          * We're getting a sta pointer in, so must be under
 438                          * appropriate locking for sta_info_get().
 439                          */
 440
 441                         /* same here, the AP could be using QoS */
 442                         ap = sta_info_get(key->sdata, key->sdata->u.mgd.bssid);
 443                         if (ap) {
 444                                 if (test_sta_flags(ap, WLAN_STA_WME))
 445                                         key->conf.flags |=
 446                                                 IEEE80211_KEY_FLAG_WMM_STA;
 447                         }
 448                 }
 449         }
 450
 451         mutex_lock(&sdata->local->key_mtx);
 452
 453         if (sta && pairwise)
 454                 old_key = sta->ptk;
 455         else if (sta)
 456                 old_key = sta->gtk[idx];
 457         else
 458                 old_key = sdata->keys[idx];
 459
 460         __ieee80211_key_replace(sdata, sta, pairwise, old_key, key);
 461         __ieee80211_key_destroy(old_key);
 462
 463         ieee80211_debugfs_key_add(key);
 464
 465         key->local->crypto_tx_tailroom_needed_cnt++;
 466
 467         ret = ieee80211_key_enable_hw_accel(key);
 468
 469         mutex_unlock(&sdata->local->key_mtx);
 470
 471         return ret;
 472 }
 473
 474 void __ieee80211_key_free(struct ieee80211_key *key)
 475 {
 476         if (!key)
 477                 return;
 478
 479         /*
 480          * Replace key with nothingness if it was ever used.
 481          */
 482         if (key->sdata)
 483                 __ieee80211_key_replace(key->sdata, key->sta,
 484                                 key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE,
 485                                 key, NULL);
 486         __ieee80211_key_destroy(key);
 487 }
 488
 489 void ieee80211_key_free(struct ieee80211_local *local,
 490                         struct ieee80211_key *key)
 491 {
 492         mutex_lock(&local->key_mtx);
 493         __ieee80211_key_free(key);
 494         mutex_unlock(&local->key_mtx);
 495 }
 496
 497 void ieee80211_enable_keys(struct ieee80211_sub_if_data *sdata)
 498 {
 499         struct ieee80211_key *key;
 500
 501         ASSERT_RTNL();
 502
 503         if (WARN_ON(!ieee80211_sdata_running(sdata)))
 504                 return;
 505
 506         mutex_lock(&sdata->local->key_mtx);
 507
 508         sdata->local->crypto_tx_tailroom_needed_cnt = 0;
 509
 510         list_for_each_entry(key, &sdata->key_list, list) {
 511                 sdata->local->crypto_tx_tailroom_needed_cnt++;
 512                 ieee80211_key_enable_hw_accel(key);
 513         }
 514
 515         mutex_unlock(&sdata->local->key_mtx);
 516 }
 517
 518 void ieee80211_disable_keys(struct ieee80211_sub_if_data *sdata)
 519 {
 520         struct ieee80211_key *key;
 521
 522         ASSERT_RTNL();
 523
 524         mutex_lock(&sdata->local->key_mtx);
 525
 526         list_for_each_entry(key, &sdata->key_list, list)
 527                 ieee80211_key_disable_hw_accel(key);
 528
 529         mutex_unlock(&sdata->local->key_mtx);
 530 }
 531
 532 void ieee80211_free_keys(struct ieee80211_sub_if_data *sdata)
 533 {
 534         struct ieee80211_key *key, *tmp;
 535
 536         mutex_lock(&sdata->local->key_mtx);
 537
 538         ieee80211_debugfs_key_remove_mgmt_default(sdata);
 539
 540         list_for_each_entry_safe(key, tmp, &sdata->key_list, list)
 541                 __ieee80211_key_free(key);
 542
 543         ieee80211_debugfs_key_update_default(sdata);
 544
 545         mutex_unlock(&sdata->local->key_mtx);
 546 }