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 each key
  34  * that is eligible the hardware is asked to enable that key but if
  35  * it cannot do that they key is simply kept for software encryption.
  36  * There is currently no way of knowing this except by looking into
  37  * debugfs.
  38  *
  39  * All key operations are protected internally.
  40  *
  41  * Within mac80211, key references are, just as STA structure references,
  42  * protected by RCU. Note, however, that some things are unprotected,
  43  * namely the key->sta dereferences within the hardware acceleration
  44  * functions. This means that sta_info_destroy() must remove the key
  45  * which waits for an RCU grace period.
  46  */
  47
  48 static const u8 bcast_addr[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
  49
  50 static void assert_key_lock(struct ieee80211_local *local)
  51 {
  52         WARN_ON(!mutex_is_locked(&local->key_mtx));
  53 }
  54
  55 static struct ieee80211_sta *get_sta_for_key(struct ieee80211_key *key)
  56 {
  57         if (key->sta)
  58                 return &key->sta->sta;
  59
  60         return NULL;
  61 }
  62
  63 static void ieee80211_key_enable_hw_accel(struct ieee80211_key *key)
  64 {
  65         struct ieee80211_sub_if_data *sdata;
  66         struct ieee80211_sta *sta;
  67         int ret;
  68
  69         might_sleep();
  70
  71         if (!key->local->ops->set_key)
  72                 return;
  73
  74         assert_key_lock(key->local);
  75
  76         sta = get_sta_for_key(key);
  77
  78         sdata = key->sdata;
  79         if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
  80                 sdata = container_of(sdata->bss,
  81                                      struct ieee80211_sub_if_data,
  82                                      u.ap);
  83
  84         ret = drv_set_key(key->local, SET_KEY, sdata, sta, &key->conf);
  85
  86         if (!ret)
  87                 key->flags |= KEY_FLAG_UPLOADED_TO_HARDWARE;
  88
  89         if (ret && ret != -ENOSPC && ret != -EOPNOTSUPP)
  90                 printk(KERN_ERR "mac80211-%s: failed to set key "
  91                        "(%d, %pM) to hardware (%d)\n",
  92                        wiphy_name(key->local->hw.wiphy),
  93                        key->conf.keyidx, sta ? sta->addr : bcast_addr, ret);
  94 }
  95
  96 static void ieee80211_key_disable_hw_accel(struct ieee80211_key *key)
  97 {
  98         struct ieee80211_sub_if_data *sdata;
  99         struct ieee80211_sta *sta;
 100         int ret;
 101
 102         might_sleep();
 103
 104         if (!key || !key->local->ops->set_key)
 105                 return;
 106
 107         assert_key_lock(key->local);
 108
 109         if (!(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
 110                 return;
 111
 112         sta = get_sta_for_key(key);
 113         sdata = key->sdata;
 114
 115         if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
 116                 sdata = container_of(sdata->bss,
 117                                      struct ieee80211_sub_if_data,
 118                                      u.ap);
 119
 120         ret = drv_set_key(key->local, DISABLE_KEY, sdata,
 121                           sta, &key->conf);
 122
 123         if (ret)
 124                 printk(KERN_ERR "mac80211-%s: failed to remove key "
 125                        "(%d, %pM) from hardware (%d)\n",
 126                        wiphy_name(key->local->hw.wiphy),
 127                        key->conf.keyidx, sta ? sta->addr : bcast_addr, ret);
 128
 129         key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE;
 130 }
 131
 132 static void __ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata,
 133                                         int idx)
 134 {
 135         struct ieee80211_key *key = NULL;
 136
 137         assert_key_lock(sdata->local);
 138
 139         if (idx >= 0 && idx < NUM_DEFAULT_KEYS)
 140                 key = sdata->keys[idx];
 141
 142         rcu_assign_pointer(sdata->default_key, key);
 143
 144         if (key) {
 145                 ieee80211_debugfs_key_remove_default(key->sdata);
 146                 ieee80211_debugfs_key_add_default(key->sdata);
 147         }
 148 }
 149
 150 void ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata, int idx)
 151 {
 152         mutex_lock(&sdata->local->key_mtx);
 153         __ieee80211_set_default_key(sdata, idx);
 154         mutex_unlock(&sdata->local->key_mtx);
 155 }
 156
 157 static void
 158 __ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata, int idx)
 159 {
 160         struct ieee80211_key *key = NULL;
 161
 162         assert_key_lock(sdata->local);
 163
 164         if (idx >= NUM_DEFAULT_KEYS &&
 165             idx < NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS)
 166                 key = sdata->keys[idx];
 167
 168         rcu_assign_pointer(sdata->default_mgmt_key, key);
 169
 170         if (key) {
 171                 ieee80211_debugfs_key_remove_mgmt_default(key->sdata);
 172                 ieee80211_debugfs_key_add_mgmt_default(key->sdata);
 173         }
 174 }
 175
 176 void ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata,
 177                                     int idx)
 178 {
 179         mutex_lock(&sdata->local->key_mtx);
 180         __ieee80211_set_default_mgmt_key(sdata, idx);
 181         mutex_unlock(&sdata->local->key_mtx);
 182 }
 183
 184
 185 static void __ieee80211_key_replace(struct ieee80211_sub_if_data *sdata,
 186                                     struct sta_info *sta,
 187                                     struct ieee80211_key *old,
 188                                     struct ieee80211_key *new)
 189 {
 190         int idx, defkey, defmgmtkey;
 191
 192         if (new)
 193                 list_add(&new->list, &sdata->key_list);
 194
 195         if (sta) {
 196                 rcu_assign_pointer(sta->key, new);
 197         } else {
 198                 WARN_ON(new && old && new->conf.keyidx != old->conf.keyidx);
 199
 200                 if (old)
 201                         idx = old->conf.keyidx;
 202                 else
 203                         idx = new->conf.keyidx;
 204
 205                 defkey = old && sdata->default_key == old;
 206                 defmgmtkey = old && sdata->default_mgmt_key == old;
 207
 208                 if (defkey && !new)
 209                         __ieee80211_set_default_key(sdata, -1);
 210                 if (defmgmtkey && !new)
 211                         __ieee80211_set_default_mgmt_key(sdata, -1);
 212
 213                 rcu_assign_pointer(sdata->keys[idx], new);
 214                 if (defkey && new)
 215                         __ieee80211_set_default_key(sdata, new->conf.keyidx);
 216                 if (defmgmtkey && new)
 217                         __ieee80211_set_default_mgmt_key(sdata,
 218                                                          new->conf.keyidx);
 219         }
 220
 221         if (old) {
 222                 /*
 223                  * We'll use an empty list to indicate that the key
 224                  * has already been removed.
 225                  */
 226                 list_del_init(&old->list);
 227         }
 228 }
 229
 230 struct ieee80211_key *ieee80211_key_alloc(u32 cipher, int idx, size_t key_len,
 231                                           const u8 *key_data,
 232                                           size_t seq_len, const u8 *seq)
 233 {
 234         struct ieee80211_key *key;
 235         int i, j, err;
 236
 237         BUG_ON(idx < 0 || idx >= NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS);
 238
 239         key = kzalloc(sizeof(struct ieee80211_key) + key_len, GFP_KERNEL);
 240         if (!key)
 241                 return ERR_PTR(-ENOMEM);
 242
 243         /*
 244          * Default to software encryption; we'll later upload the
 245          * key to the hardware if possible.
 246          */
 247         key->conf.flags = 0;
 248         key->flags = 0;
 249
 250         key->conf.cipher = cipher;
 251         key->conf.keyidx = idx;
 252         key->conf.keylen = key_len;
 253         switch (cipher) {
 254         case WLAN_CIPHER_SUITE_WEP40:
 255         case WLAN_CIPHER_SUITE_WEP104:
 256                 key->conf.iv_len = WEP_IV_LEN;
 257                 key->conf.icv_len = WEP_ICV_LEN;
 258                 break;
 259         case WLAN_CIPHER_SUITE_TKIP:
 260                 key->conf.iv_len = TKIP_IV_LEN;
 261                 key->conf.icv_len = TKIP_ICV_LEN;
 262                 if (seq) {
 263                         for (i = 0; i < NUM_RX_DATA_QUEUES; i++) {
 264                                 key->u.tkip.rx[i].iv32 =
 265                                         get_unaligned_le32(&seq[2]);
 266                                 key->u.tkip.rx[i].iv16 =
 267                                         get_unaligned_le16(seq);
 268                         }
 269                 }
 270                 break;
 271         case WLAN_CIPHER_SUITE_CCMP:
 272                 key->conf.iv_len = CCMP_HDR_LEN;
 273                 key->conf.icv_len = CCMP_MIC_LEN;
 274                 if (seq) {
 275                         for (i = 0; i < NUM_RX_DATA_QUEUES + 1; i++)
 276                                 for (j = 0; j < CCMP_PN_LEN; j++)
 277                                         key->u.ccmp.rx_pn[i][j] =
 278                                                 seq[CCMP_PN_LEN - j - 1];
 279                 }
 280                 /*
 281                  * Initialize AES key state here as an optimization so that
 282                  * it does not need to be initialized for every packet.
 283                  */
 284                 key->u.ccmp.tfm = ieee80211_aes_key_setup_encrypt(key_data);
 285                 if (IS_ERR(key->u.ccmp.tfm)) {
 286                         err = PTR_ERR(key->u.ccmp.tfm);
 287                         kfree(key);
 288                         key = ERR_PTR(err);
 289                 }
 290                 break;
 291         case WLAN_CIPHER_SUITE_AES_CMAC:
 292                 key->conf.iv_len = 0;
 293                 key->conf.icv_len = sizeof(struct ieee80211_mmie);
 294                 if (seq)
 295                         for (j = 0; j < 6; j++)
 296                                 key->u.aes_cmac.rx_pn[j] = seq[6 - j - 1];
 297                 /*
 298                  * Initialize AES key state here as an optimization so that
 299                  * it does not need to be initialized for every packet.
 300                  */
 301                 key->u.aes_cmac.tfm =
 302                         ieee80211_aes_cmac_key_setup(key_data);
 303                 if (IS_ERR(key->u.aes_cmac.tfm)) {
 304                         err = PTR_ERR(key->u.aes_cmac.tfm);
 305                         kfree(key);
 306                         key = ERR_PTR(err);
 307                 }
 308                 break;
 309         }
 310         memcpy(key->conf.key, key_data, key_len);
 311         INIT_LIST_HEAD(&key->list);
 312
 313         return key;
 314 }
 315
 316 static void __ieee80211_key_destroy(struct ieee80211_key *key)
 317 {
 318         if (!key)
 319                 return;
 320
 321         if (key->local)
 322                 ieee80211_key_disable_hw_accel(key);
 323
 324         if (key->conf.cipher == WLAN_CIPHER_SUITE_CCMP)
 325                 ieee80211_aes_key_free(key->u.ccmp.tfm);
 326         if (key->conf.cipher == WLAN_CIPHER_SUITE_AES_CMAC)
 327                 ieee80211_aes_cmac_key_free(key->u.aes_cmac.tfm);
 328         if (key->local)
 329                 ieee80211_debugfs_key_remove(key);
 330
 331         kfree(key);
 332 }
 333
 334 void ieee80211_key_link(struct ieee80211_key *key,
 335                         struct ieee80211_sub_if_data *sdata,
 336                         struct sta_info *sta)
 337 {
 338         struct ieee80211_key *old_key;
 339         int idx;
 340
 341         BUG_ON(!sdata);
 342         BUG_ON(!key);
 343
 344         idx = key->conf.keyidx;
 345         key->local = sdata->local;
 346         key->sdata = sdata;
 347         key->sta = sta;
 348
 349         if (sta) {
 350                 /*
 351                  * some hardware cannot handle TKIP with QoS, so
 352                  * we indicate whether QoS could be in use.
 353                  */
 354                 if (test_sta_flags(sta, WLAN_STA_WME))
 355                         key->conf.flags |= IEEE80211_KEY_FLAG_WMM_STA;
 356
 357                 /*
 358                  * This key is for a specific sta interface,
 359                  * inform the driver that it should try to store
 360                  * this key as pairwise key.
 361                  */
 362                 key->conf.flags |= IEEE80211_KEY_FLAG_PAIRWISE;
 363         } else {
 364                 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
 365                         struct sta_info *ap;
 366
 367                         /*
 368                          * We're getting a sta pointer in,
 369                          * so must be under RCU read lock.
 370                          */
 371
 372                         /* same here, the AP could be using QoS */
 373                         ap = sta_info_get(key->sdata, key->sdata->u.mgd.bssid);
 374                         if (ap) {
 375                                 if (test_sta_flags(ap, WLAN_STA_WME))
 376                                         key->conf.flags |=
 377                                                 IEEE80211_KEY_FLAG_WMM_STA;
 378                         }
 379                 }
 380         }
 381
 382         mutex_lock(&sdata->local->key_mtx);
 383
 384         if (sta)
 385                 old_key = sta->key;
 386         else
 387                 old_key = sdata->keys[idx];
 388
 389         __ieee80211_key_replace(sdata, sta, old_key, key);
 390         __ieee80211_key_destroy(old_key);
 391
 392         ieee80211_debugfs_key_add(key);
 393
 394         ieee80211_key_enable_hw_accel(key);
 395
 396         mutex_unlock(&sdata->local->key_mtx);
 397 }
 398
 399 static void __ieee80211_key_free(struct ieee80211_key *key)
 400 {
 401         /*
 402          * Replace key with nothingness if it was ever used.
 403          */
 404         if (key->sdata)
 405                 __ieee80211_key_replace(key->sdata, key->sta,
 406                                         key, NULL);
 407         __ieee80211_key_destroy(key);
 408 }
 409
 410 void ieee80211_key_free(struct ieee80211_local *local,
 411                         struct ieee80211_key *key)
 412 {
 413         if (!key)
 414                 return;
 415
 416         mutex_lock(&local->key_mtx);
 417         __ieee80211_key_free(key);
 418         mutex_unlock(&local->key_mtx);
 419 }
 420
 421 void ieee80211_enable_keys(struct ieee80211_sub_if_data *sdata)
 422 {
 423         struct ieee80211_key *key;
 424
 425         ASSERT_RTNL();
 426
 427         if (WARN_ON(!ieee80211_sdata_running(sdata)))
 428                 return;
 429
 430         mutex_lock(&sdata->local->key_mtx);
 431
 432         list_for_each_entry(key, &sdata->key_list, list)
 433                 ieee80211_key_enable_hw_accel(key);
 434
 435         mutex_unlock(&sdata->local->key_mtx);
 436 }
 437
 438 void ieee80211_disable_keys(struct ieee80211_sub_if_data *sdata)
 439 {
 440         struct ieee80211_key *key;
 441
 442         ASSERT_RTNL();
 443
 444         mutex_lock(&sdata->local->key_mtx);
 445
 446         list_for_each_entry(key, &sdata->key_list, list)
 447                 ieee80211_key_disable_hw_accel(key);
 448
 449         mutex_unlock(&sdata->local->key_mtx);
 450 }
 451
 452 void ieee80211_free_keys(struct ieee80211_sub_if_data *sdata)
 453 {
 454         struct ieee80211_key *key, *tmp;
 455
 456         mutex_lock(&sdata->local->key_mtx);
 457
 458         ieee80211_debugfs_key_remove_default(sdata);
 459         ieee80211_debugfs_key_remove_mgmt_default(sdata);
 460
 461         list_for_each_entry_safe(key, tmp, &sdata->key_list, list)
 462                 __ieee80211_key_free(key);
 463
 464         mutex_unlock(&sdata->local->key_mtx);
 465 }