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 = key_mtx_dereference(sdata->local, 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 = key_mtx_dereference(sdata->local, 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 &&
 270                         old == key_mtx_dereference(sdata->local,
 271                                                 sdata->default_unicast_key);
 272                 defmultikey = old &&
 273                         old == key_mtx_dereference(sdata->local,
 274                                                 sdata->default_multicast_key);
 275                 defmgmtkey = old &&
 276                         old == key_mtx_dereference(sdata->local,
 277                                                 sdata->default_mgmt_key);
 278
 279                 if (defunikey && !new)
 280                         __ieee80211_set_default_key(sdata, -1, true, false);
 281                 if (defmultikey && !new)
 282                         __ieee80211_set_default_key(sdata, -1, false, true);
 283                 if (defmgmtkey && !new)
 284                         __ieee80211_set_default_mgmt_key(sdata, -1);
 285
 286                 rcu_assign_pointer(sdata->keys[idx], new);
 287                 if (defunikey && new)
 288                         __ieee80211_set_default_key(sdata, new->conf.keyidx,
 289                                                     true, false);
 290                 if (defmultikey && new)
 291                         __ieee80211_set_default_key(sdata, new->conf.keyidx,
 292                                                     false, true);
 293                 if (defmgmtkey && new)
 294                         __ieee80211_set_default_mgmt_key(sdata,
 295                                                          new->conf.keyidx);
 296         }
 297
 298         if (old)
 299                 list_del(&old->list);
 300 }
 301
 302 struct ieee80211_key *ieee80211_key_alloc(u32 cipher, int idx, size_t key_len,
 303                                           const u8 *key_data,
 304                                           size_t seq_len, const u8 *seq)
 305 {
 306         struct ieee80211_key *key;
 307         int i, j, err;
 308
 309         BUG_ON(idx < 0 || idx >= NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS);
 310
 311         key = kzalloc(sizeof(struct ieee80211_key) + key_len, GFP_KERNEL);
 312         if (!key)
 313                 return ERR_PTR(-ENOMEM);
 314
 315         /*
 316          * Default to software encryption; we'll later upload the
 317          * key to the hardware if possible.
 318          */
 319         key->conf.flags = 0;
 320         key->flags = 0;
 321
 322         key->conf.cipher = cipher;
 323         key->conf.keyidx = idx;
 324         key->conf.keylen = key_len;
 325         switch (cipher) {
 326         case WLAN_CIPHER_SUITE_WEP40:
 327         case WLAN_CIPHER_SUITE_WEP104:
 328                 key->conf.iv_len = WEP_IV_LEN;
 329                 key->conf.icv_len = WEP_ICV_LEN;
 330                 break;
 331         case WLAN_CIPHER_SUITE_TKIP:
 332                 key->conf.iv_len = TKIP_IV_LEN;
 333                 key->conf.icv_len = TKIP_ICV_LEN;
 334                 if (seq) {
 335                         for (i = 0; i < NUM_RX_DATA_QUEUES; i++) {
 336                                 key->u.tkip.rx[i].iv32 =
 337                                         get_unaligned_le32(&seq[2]);
 338                                 key->u.tkip.rx[i].iv16 =
 339                                         get_unaligned_le16(seq);
 340                         }
 341                 }
 342                 break;
 343         case WLAN_CIPHER_SUITE_CCMP:
 344                 key->conf.iv_len = CCMP_HDR_LEN;
 345                 key->conf.icv_len = CCMP_MIC_LEN;
 346                 if (seq) {
 347                         for (i = 0; i < NUM_RX_DATA_QUEUES + 1; i++)
 348                                 for (j = 0; j < CCMP_PN_LEN; j++)
 349                                         key->u.ccmp.rx_pn[i][j] =
 350                                                 seq[CCMP_PN_LEN - j - 1];
 351                 }
 352                 /*
 353                  * Initialize AES key state here as an optimization so that
 354                  * it does not need to be initialized for every packet.
 355                  */
 356                 key->u.ccmp.tfm = ieee80211_aes_key_setup_encrypt(key_data);
 357                 if (IS_ERR(key->u.ccmp.tfm)) {
 358                         err = PTR_ERR(key->u.ccmp.tfm);
 359                         kfree(key);
 360                         return ERR_PTR(err);
 361                 }
 362                 break;
 363         case WLAN_CIPHER_SUITE_AES_CMAC:
 364                 key->conf.iv_len = 0;
 365                 key->conf.icv_len = sizeof(struct ieee80211_mmie);
 366                 if (seq)
 367                         for (j = 0; j < 6; j++)
 368                                 key->u.aes_cmac.rx_pn[j] = seq[6 - j - 1];
 369                 /*
 370                  * Initialize AES key state here as an optimization so that
 371                  * it does not need to be initialized for every packet.
 372                  */
 373                 key->u.aes_cmac.tfm =
 374                         ieee80211_aes_cmac_key_setup(key_data);
 375                 if (IS_ERR(key->u.aes_cmac.tfm)) {
 376                         err = PTR_ERR(key->u.aes_cmac.tfm);
 377                         kfree(key);
 378                         return ERR_PTR(err);
 379                 }
 380                 break;
 381         }
 382         memcpy(key->conf.key, key_data, key_len);
 383         INIT_LIST_HEAD(&key->list);
 384
 385         return key;
 386 }
 387
 388 static void __ieee80211_key_destroy(struct ieee80211_key *key)
 389 {
 390         if (!key)
 391                 return;
 392
 393         /*
 394          * Synchronize so the TX path can no longer be using
 395          * this key before we free/remove it.
 396          */
 397         synchronize_rcu();
 398
 399         if (key->local)
 400                 ieee80211_key_disable_hw_accel(key);
 401
 402         if (key->conf.cipher == WLAN_CIPHER_SUITE_CCMP)
 403                 ieee80211_aes_key_free(key->u.ccmp.tfm);
 404         if (key->conf.cipher == WLAN_CIPHER_SUITE_AES_CMAC)
 405                 ieee80211_aes_cmac_key_free(key->u.aes_cmac.tfm);
 406         if (key->local) {
 407                 ieee80211_debugfs_key_remove(key);
 408                 key->local->crypto_tx_tailroom_needed_cnt--;
 409         }
 410
 411         kfree(key);
 412 }
 413
 414 int ieee80211_key_link(struct ieee80211_key *key,
 415                        struct ieee80211_sub_if_data *sdata,
 416                        struct sta_info *sta)
 417 {
 418         struct ieee80211_key *old_key;
 419         int idx, ret;
 420         bool pairwise;
 421
 422         BUG_ON(!sdata);
 423         BUG_ON(!key);
 424
 425         pairwise = key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE;
 426         idx = key->conf.keyidx;
 427         key->local = sdata->local;
 428         key->sdata = sdata;
 429         key->sta = sta;
 430
 431         if (sta) {
 432                 /*
 433                  * some hardware cannot handle TKIP with QoS, so
 434                  * we indicate whether QoS could be in use.
 435                  */
 436                 if (test_sta_flags(sta, WLAN_STA_WME))
 437                         key->conf.flags |= IEEE80211_KEY_FLAG_WMM_STA;
 438         } else {
 439                 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
 440                         struct sta_info *ap;
 441
 442                         /*
 443                          * We're getting a sta pointer in, so must be under
 444                          * appropriate locking for sta_info_get().
 445                          */
 446
 447                         /* same here, the AP could be using QoS */
 448                         ap = sta_info_get(key->sdata, key->sdata->u.mgd.bssid);
 449                         if (ap) {
 450                                 if (test_sta_flags(ap, WLAN_STA_WME))
 451                                         key->conf.flags |=
 452                                                 IEEE80211_KEY_FLAG_WMM_STA;
 453                         }
 454                 }
 455         }
 456
 457         mutex_lock(&sdata->local->key_mtx);
 458
 459         if (sta && pairwise)
 460                 old_key = key_mtx_dereference(sdata->local, sta->ptk);
 461         else if (sta)
 462                 old_key = key_mtx_dereference(sdata->local, sta->gtk[idx]);
 463         else
 464                 old_key = key_mtx_dereference(sdata->local, sdata->keys[idx]);
 465
 466         __ieee80211_key_replace(sdata, sta, pairwise, old_key, key);
 467         __ieee80211_key_destroy(old_key);
 468
 469         ieee80211_debugfs_key_add(key);
 470
 471         key->local->crypto_tx_tailroom_needed_cnt++;
 472
 473         ret = ieee80211_key_enable_hw_accel(key);
 474
 475         mutex_unlock(&sdata->local->key_mtx);
 476
 477         return ret;
 478 }
 479
 480 void __ieee80211_key_free(struct ieee80211_key *key)
 481 {
 482         if (!key)
 483                 return;
 484
 485         /*
 486          * Replace key with nothingness if it was ever used.
 487          */
 488         if (key->sdata)
 489                 __ieee80211_key_replace(key->sdata, key->sta,
 490                                 key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE,
 491                                 key, NULL);
 492         __ieee80211_key_destroy(key);
 493 }
 494
 495 void ieee80211_key_free(struct ieee80211_local *local,
 496                         struct ieee80211_key *key)
 497 {
 498         mutex_lock(&local->key_mtx);
 499         __ieee80211_key_free(key);
 500         mutex_unlock(&local->key_mtx);
 501 }
 502
 503 void ieee80211_enable_keys(struct ieee80211_sub_if_data *sdata)
 504 {
 505         struct ieee80211_key *key;
 506
 507         ASSERT_RTNL();
 508
 509         if (WARN_ON(!ieee80211_sdata_running(sdata)))
 510                 return;
 511
 512         mutex_lock(&sdata->local->key_mtx);
 513
 514         sdata->local->crypto_tx_tailroom_needed_cnt = 0;
 515
 516         list_for_each_entry(key, &sdata->key_list, list) {
 517                 sdata->local->crypto_tx_tailroom_needed_cnt++;
 518                 ieee80211_key_enable_hw_accel(key);
 519         }
 520
 521         mutex_unlock(&sdata->local->key_mtx);
 522 }
 523
 524 void ieee80211_disable_keys(struct ieee80211_sub_if_data *sdata)
 525 {
 526         struct ieee80211_key *key;
 527
 528         ASSERT_RTNL();
 529
 530         mutex_lock(&sdata->local->key_mtx);
 531
 532         list_for_each_entry(key, &sdata->key_list, list)
 533                 ieee80211_key_disable_hw_accel(key);
 534
 535         mutex_unlock(&sdata->local->key_mtx);
 536 }
 537
 538 void ieee80211_free_keys(struct ieee80211_sub_if_data *sdata)
 539 {
 540         struct ieee80211_key *key, *tmp;
 541
 542         mutex_lock(&sdata->local->key_mtx);
 543
 544         ieee80211_debugfs_key_remove_mgmt_default(sdata);
 545
 546         list_for_each_entry_safe(key, tmp, &sdata->key_list, list)
 547                 __ieee80211_key_free(key);
 548
 549         ieee80211_debugfs_key_update_default(sdata);
 550
 551         mutex_unlock(&sdata->local->key_mtx);
 552 }