blob: 8c02469b7176526994fc1bb749eee30e943ef5ca [file] [log] [blame]
Johannes Berg1f5a7e42007-07-27 15:43:23 +02001/*
2 * Copyright 2002-2005, Instant802 Networks, Inc.
3 * Copyright 2005-2006, Devicescape Software, Inc.
4 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
Johannes Berg3b967662008-04-08 17:56:52 +02005 * Copyright 2007-2008 Johannes Berg <johannes@sipsolutions.net>
Johannes Berg1f5a7e42007-07-27 15:43:23 +02006 *
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
Johannes Berg11a843b2007-08-28 17:01:55 -040012#include <linux/if_ether.h>
13#include <linux/etherdevice.h>
14#include <linux/list.h>
Johannes Bergd4e46a32007-09-14 11:10:24 -040015#include <linux/rcupdate.h>
Johannes Bergdb4d1162008-02-25 16:27:45 +010016#include <linux/rtnetlink.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090017#include <linux/slab.h>
Johannes Berg1f5a7e42007-07-27 15:43:23 +020018#include <net/mac80211.h>
19#include "ieee80211_i.h"
Johannes Berg24487982009-04-23 18:52:52 +020020#include "driver-ops.h"
Johannes Berg1f5a7e42007-07-27 15:43:23 +020021#include "debugfs_key.h"
22#include "aes_ccm.h"
Jouni Malinen3cfcf6a2009-01-08 13:32:02 +020023#include "aes_cmac.h"
Johannes Berg1f5a7e42007-07-27 15:43:23 +020024
Johannes Berg11a843b2007-08-28 17:01:55 -040025
Johannes Bergdbbea672008-02-26 14:34:06 +010026/**
27 * DOC: Key handling basics
Johannes Berg11a843b2007-08-28 17:01:55 -040028 *
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 *
Johannes Bergb5c34f62011-01-03 19:51:09 +010033 * 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.
Johannes Berg11a843b2007-08-28 17:01:55 -040040 *
Johannes Bergb5c34f62011-01-03 19:51:09 +010041 * 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.
Johannes Berg11a843b2007-08-28 17:01:55 -040047 */
48
49static const u8 bcast_addr[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
Johannes Berg11a843b2007-08-28 17:01:55 -040050
Johannes Bergad0e2b52010-06-01 10:19:19 +020051static void assert_key_lock(struct ieee80211_local *local)
Johannes Berg3b967662008-04-08 17:56:52 +020052{
Johannes Berg46a5eba2010-09-15 13:28:15 +020053 lockdep_assert_held(&local->key_mtx);
Johannes Berg3b967662008-04-08 17:56:52 +020054}
55
Johannes Bergdc822b52008-12-29 12:55:09 +010056static struct ieee80211_sta *get_sta_for_key(struct ieee80211_key *key)
Johannes Berg11a843b2007-08-28 17:01:55 -040057{
Johannes Berg11a843b2007-08-28 17:01:55 -040058 if (key->sta)
Johannes Bergdc822b52008-12-29 12:55:09 +010059 return &key->sta->sta;
Johannes Berg11a843b2007-08-28 17:01:55 -040060
Johannes Bergdc822b52008-12-29 12:55:09 +010061 return NULL;
Johannes Berg11a843b2007-08-28 17:01:55 -040062}
63
Johannes Berg3ffc2a92010-08-27 14:26:52 +030064static int ieee80211_key_enable_hw_accel(struct ieee80211_key *key)
Johannes Berg11a843b2007-08-28 17:01:55 -040065{
Johannes Bergdc822b52008-12-29 12:55:09 +010066 struct ieee80211_sub_if_data *sdata;
67 struct ieee80211_sta *sta;
Johannes Berg11a843b2007-08-28 17:01:55 -040068 int ret;
69
Johannes Berg3b967662008-04-08 17:56:52 +020070 might_sleep();
71
Johannes Berge31b8212010-10-05 19:39:30 +020072 if (!key->local->ops->set_key)
Johannes Berg3ffc2a92010-08-27 14:26:52 +030073 goto out_unsupported;
Johannes Berg11a843b2007-08-28 17:01:55 -040074
Johannes Bergad0e2b52010-06-01 10:19:19 +020075 assert_key_lock(key->local);
76
Johannes Bergdc822b52008-12-29 12:55:09 +010077 sta = get_sta_for_key(key);
78
Johannes Berge31b8212010-10-05 19:39:30 +020079 /*
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
Johannes Bergdc822b52008-12-29 12:55:09 +010087 sdata = key->sdata;
Helmut Schaa18890d42010-11-19 08:11:01 +010088 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;
Johannes Bergdc822b52008-12-29 12:55:09 +010095 sdata = container_of(sdata->bss,
96 struct ieee80211_sub_if_data,
97 u.ap);
Helmut Schaa18890d42010-11-19 08:11:01 +010098 }
Johannes Berg11a843b2007-08-28 17:01:55 -040099
Johannes Berg12375ef2009-11-25 20:30:31 +0100100 ret = drv_set_key(key->local, SET_KEY, sdata, sta, &key->conf);
Johannes Berg11a843b2007-08-28 17:01:55 -0400101
Johannes Berge31b8212010-10-05 19:39:30 +0200102 if (!ret) {
Johannes Berg11a843b2007-08-28 17:01:55 -0400103 key->flags |= KEY_FLAG_UPLOADED_TO_HARDWARE;
Johannes Berge31b8212010-10-05 19:39:30 +0200104 return 0;
105 }
Johannes Berg11a843b2007-08-28 17:01:55 -0400106
Johannes Berge31b8212010-10-05 19:39:30 +0200107 if (ret != -ENOSPC && ret != -EOPNOTSUPP)
Joe Perches0fb9a9e2010-08-20 16:25:38 -0700108 wiphy_err(key->local->hw.wiphy,
109 "failed to set key (%d, %pM) to hardware (%d)\n",
110 key->conf.keyidx, sta ? sta->addr : bcast_addr, ret);
Johannes Berg3ffc2a92010-08-27 14:26:52 +0300111
Johannes Berge31b8212010-10-05 19:39:30 +0200112 out_unsupported:
113 switch (key->conf.cipher) {
114 case WLAN_CIPHER_SUITE_WEP40:
115 case WLAN_CIPHER_SUITE_WEP104:
116 case WLAN_CIPHER_SUITE_TKIP:
117 case WLAN_CIPHER_SUITE_CCMP:
118 case WLAN_CIPHER_SUITE_AES_CMAC:
119 /* all of these we can do in software */
120 return 0;
121 default:
122 return -EINVAL;
Johannes Berg3ffc2a92010-08-27 14:26:52 +0300123 }
Johannes Berg11a843b2007-08-28 17:01:55 -0400124}
125
126static void ieee80211_key_disable_hw_accel(struct ieee80211_key *key)
127{
Johannes Bergdc822b52008-12-29 12:55:09 +0100128 struct ieee80211_sub_if_data *sdata;
129 struct ieee80211_sta *sta;
Johannes Berg11a843b2007-08-28 17:01:55 -0400130 int ret;
131
Johannes Berg3b967662008-04-08 17:56:52 +0200132 might_sleep();
133
Johannes Bergdb4d1162008-02-25 16:27:45 +0100134 if (!key || !key->local->ops->set_key)
Johannes Berg11a843b2007-08-28 17:01:55 -0400135 return;
136
Johannes Bergad0e2b52010-06-01 10:19:19 +0200137 assert_key_lock(key->local);
138
139 if (!(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
Johannes Berg11a843b2007-08-28 17:01:55 -0400140 return;
141
Johannes Bergdc822b52008-12-29 12:55:09 +0100142 sta = get_sta_for_key(key);
143 sdata = key->sdata;
144
145 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
146 sdata = container_of(sdata->bss,
147 struct ieee80211_sub_if_data,
148 u.ap);
Johannes Berg11a843b2007-08-28 17:01:55 -0400149
Johannes Berg12375ef2009-11-25 20:30:31 +0100150 ret = drv_set_key(key->local, DISABLE_KEY, sdata,
Johannes Berg24487982009-04-23 18:52:52 +0200151 sta, &key->conf);
Johannes Berg11a843b2007-08-28 17:01:55 -0400152
153 if (ret)
Joe Perches0fb9a9e2010-08-20 16:25:38 -0700154 wiphy_err(key->local->hw.wiphy,
155 "failed to remove key (%d, %pM) from hardware (%d)\n",
156 key->conf.keyidx, sta ? sta->addr : bcast_addr, ret);
Johannes Berg11a843b2007-08-28 17:01:55 -0400157
Johannes Berg3b967662008-04-08 17:56:52 +0200158 key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE;
Johannes Berg3b967662008-04-08 17:56:52 +0200159}
160
Johannes Berge31b8212010-10-05 19:39:30 +0200161void ieee80211_key_removed(struct ieee80211_key_conf *key_conf)
162{
163 struct ieee80211_key *key;
164
165 key = container_of(key_conf, struct ieee80211_key, conf);
166
167 might_sleep();
168 assert_key_lock(key->local);
169
170 key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE;
171
172 /*
173 * Flush TX path to avoid attempts to use this key
174 * after this function returns. Until then, drivers
175 * must be prepared to handle the key.
176 */
177 synchronize_rcu();
178}
179EXPORT_SYMBOL_GPL(ieee80211_key_removed);
180
Johannes Berg3b967662008-04-08 17:56:52 +0200181static void __ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata,
Johannes Bergf7e01042010-12-09 19:49:02 +0100182 int idx, bool uni, bool multi)
Johannes Berg3b967662008-04-08 17:56:52 +0200183{
184 struct ieee80211_key *key = NULL;
185
Johannes Bergad0e2b52010-06-01 10:19:19 +0200186 assert_key_lock(sdata->local);
187
Johannes Berg3b967662008-04-08 17:56:52 +0200188 if (idx >= 0 && idx < NUM_DEFAULT_KEYS)
189 key = sdata->keys[idx];
190
Johannes Bergf7e01042010-12-09 19:49:02 +0100191 if (uni)
192 rcu_assign_pointer(sdata->default_unicast_key, key);
193 if (multi)
194 rcu_assign_pointer(sdata->default_multicast_key, key);
Johannes Berg3b967662008-04-08 17:56:52 +0200195
Johannes Bergf7e01042010-12-09 19:49:02 +0100196 ieee80211_debugfs_key_update_default(sdata);
Johannes Berg3b967662008-04-08 17:56:52 +0200197}
198
Johannes Bergf7e01042010-12-09 19:49:02 +0100199void ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata, int idx,
200 bool uni, bool multi)
Johannes Berg3b967662008-04-08 17:56:52 +0200201{
Johannes Bergad0e2b52010-06-01 10:19:19 +0200202 mutex_lock(&sdata->local->key_mtx);
Johannes Bergf7e01042010-12-09 19:49:02 +0100203 __ieee80211_set_default_key(sdata, idx, uni, multi);
Johannes Bergad0e2b52010-06-01 10:19:19 +0200204 mutex_unlock(&sdata->local->key_mtx);
Johannes Berg3b967662008-04-08 17:56:52 +0200205}
206
Jouni Malinen3cfcf6a2009-01-08 13:32:02 +0200207static void
208__ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata, int idx)
209{
210 struct ieee80211_key *key = NULL;
211
Johannes Bergad0e2b52010-06-01 10:19:19 +0200212 assert_key_lock(sdata->local);
213
Jouni Malinen3cfcf6a2009-01-08 13:32:02 +0200214 if (idx >= NUM_DEFAULT_KEYS &&
215 idx < NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS)
216 key = sdata->keys[idx];
217
218 rcu_assign_pointer(sdata->default_mgmt_key, key);
219
Johannes Bergf7e01042010-12-09 19:49:02 +0100220 ieee80211_debugfs_key_update_default(sdata);
Jouni Malinen3cfcf6a2009-01-08 13:32:02 +0200221}
222
223void ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata,
224 int idx)
225{
Johannes Bergad0e2b52010-06-01 10:19:19 +0200226 mutex_lock(&sdata->local->key_mtx);
Jouni Malinen3cfcf6a2009-01-08 13:32:02 +0200227 __ieee80211_set_default_mgmt_key(sdata, idx);
Johannes Bergad0e2b52010-06-01 10:19:19 +0200228 mutex_unlock(&sdata->local->key_mtx);
Jouni Malinen3cfcf6a2009-01-08 13:32:02 +0200229}
230
Johannes Berg3b967662008-04-08 17:56:52 +0200231
232static void __ieee80211_key_replace(struct ieee80211_sub_if_data *sdata,
233 struct sta_info *sta,
Johannes Berge31b8212010-10-05 19:39:30 +0200234 bool pairwise,
Johannes Berg3b967662008-04-08 17:56:52 +0200235 struct ieee80211_key *old,
236 struct ieee80211_key *new)
237{
Johannes Bergf7e01042010-12-09 19:49:02 +0100238 int idx;
239 bool defunikey, defmultikey, defmgmtkey;
Johannes Berg3b967662008-04-08 17:56:52 +0200240
241 if (new)
242 list_add(&new->list, &sdata->key_list);
243
Johannes Berge31b8212010-10-05 19:39:30 +0200244 if (sta && pairwise) {
245 rcu_assign_pointer(sta->ptk, new);
246 } else if (sta) {
247 if (old)
248 idx = old->conf.keyidx;
249 else
250 idx = new->conf.keyidx;
251 rcu_assign_pointer(sta->gtk[idx], new);
Johannes Berg3b967662008-04-08 17:56:52 +0200252 } else {
253 WARN_ON(new && old && new->conf.keyidx != old->conf.keyidx);
254
255 if (old)
256 idx = old->conf.keyidx;
257 else
258 idx = new->conf.keyidx;
259
Johannes Bergf7e01042010-12-09 19:49:02 +0100260 defunikey = old && sdata->default_unicast_key == old;
261 defmultikey = old && sdata->default_multicast_key == old;
Jouni Malinen3cfcf6a2009-01-08 13:32:02 +0200262 defmgmtkey = old && sdata->default_mgmt_key == old;
Johannes Berg3b967662008-04-08 17:56:52 +0200263
Johannes Bergf7e01042010-12-09 19:49:02 +0100264 if (defunikey && !new)
265 __ieee80211_set_default_key(sdata, -1, true, false);
266 if (defmultikey && !new)
267 __ieee80211_set_default_key(sdata, -1, false, true);
Jouni Malinen3cfcf6a2009-01-08 13:32:02 +0200268 if (defmgmtkey && !new)
269 __ieee80211_set_default_mgmt_key(sdata, -1);
Johannes Berg3b967662008-04-08 17:56:52 +0200270
271 rcu_assign_pointer(sdata->keys[idx], new);
Johannes Bergf7e01042010-12-09 19:49:02 +0100272 if (defunikey && new)
273 __ieee80211_set_default_key(sdata, new->conf.keyidx,
274 true, false);
275 if (defmultikey && new)
276 __ieee80211_set_default_key(sdata, new->conf.keyidx,
277 false, true);
Jouni Malinen3cfcf6a2009-01-08 13:32:02 +0200278 if (defmgmtkey && new)
279 __ieee80211_set_default_mgmt_key(sdata,
280 new->conf.keyidx);
Johannes Berg3b967662008-04-08 17:56:52 +0200281 }
282
Johannes Bergb5c34f62011-01-03 19:51:09 +0100283 if (old)
284 list_del(&old->list);
Johannes Berg11a843b2007-08-28 17:01:55 -0400285}
286
Johannes Berg97359d12010-08-10 09:46:38 +0200287struct ieee80211_key *ieee80211_key_alloc(u32 cipher, int idx, size_t key_len,
Jouni Malinenfaa8fdc2009-05-11 21:57:58 +0300288 const u8 *key_data,
289 size_t seq_len, const u8 *seq)
Johannes Berg1f5a7e42007-07-27 15:43:23 +0200290{
291 struct ieee80211_key *key;
Ben Hutchings1ac62ba2010-08-01 17:37:03 +0100292 int i, j, err;
Johannes Berg1f5a7e42007-07-27 15:43:23 +0200293
Jouni Malinen3cfcf6a2009-01-08 13:32:02 +0200294 BUG_ON(idx < 0 || idx >= NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS);
Johannes Berg11a843b2007-08-28 17:01:55 -0400295
296 key = kzalloc(sizeof(struct ieee80211_key) + key_len, GFP_KERNEL);
Johannes Berg1f5a7e42007-07-27 15:43:23 +0200297 if (!key)
Ben Hutchings1ac62ba2010-08-01 17:37:03 +0100298 return ERR_PTR(-ENOMEM);
Johannes Berg11a843b2007-08-28 17:01:55 -0400299
300 /*
301 * Default to software encryption; we'll later upload the
302 * key to the hardware if possible.
303 */
Johannes Berg11a843b2007-08-28 17:01:55 -0400304 key->conf.flags = 0;
305 key->flags = 0;
306
Johannes Berg97359d12010-08-10 09:46:38 +0200307 key->conf.cipher = cipher;
Johannes Berg11a843b2007-08-28 17:01:55 -0400308 key->conf.keyidx = idx;
309 key->conf.keylen = key_len;
Johannes Berg97359d12010-08-10 09:46:38 +0200310 switch (cipher) {
311 case WLAN_CIPHER_SUITE_WEP40:
312 case WLAN_CIPHER_SUITE_WEP104:
Felix Fietkau76708de2008-10-05 18:02:48 +0200313 key->conf.iv_len = WEP_IV_LEN;
314 key->conf.icv_len = WEP_ICV_LEN;
315 break;
Johannes Berg97359d12010-08-10 09:46:38 +0200316 case WLAN_CIPHER_SUITE_TKIP:
Felix Fietkau76708de2008-10-05 18:02:48 +0200317 key->conf.iv_len = TKIP_IV_LEN;
318 key->conf.icv_len = TKIP_ICV_LEN;
Jouni Malinen9f26a952009-05-15 12:38:32 +0300319 if (seq) {
Jouni Malinenfaa8fdc2009-05-11 21:57:58 +0300320 for (i = 0; i < NUM_RX_DATA_QUEUES; i++) {
321 key->u.tkip.rx[i].iv32 =
322 get_unaligned_le32(&seq[2]);
323 key->u.tkip.rx[i].iv16 =
324 get_unaligned_le16(seq);
325 }
326 }
Felix Fietkau76708de2008-10-05 18:02:48 +0200327 break;
Johannes Berg97359d12010-08-10 09:46:38 +0200328 case WLAN_CIPHER_SUITE_CCMP:
Felix Fietkau76708de2008-10-05 18:02:48 +0200329 key->conf.iv_len = CCMP_HDR_LEN;
330 key->conf.icv_len = CCMP_MIC_LEN;
Jouni Malinen9f26a952009-05-15 12:38:32 +0300331 if (seq) {
Jouni Malinen91902522010-06-11 10:27:33 -0700332 for (i = 0; i < NUM_RX_DATA_QUEUES + 1; i++)
Jouni Malinenfaa8fdc2009-05-11 21:57:58 +0300333 for (j = 0; j < CCMP_PN_LEN; j++)
334 key->u.ccmp.rx_pn[i][j] =
335 seq[CCMP_PN_LEN - j - 1];
336 }
Johannes Berg11a843b2007-08-28 17:01:55 -0400337 /*
338 * Initialize AES key state here as an optimization so that
339 * it does not need to be initialized for every packet.
340 */
341 key->u.ccmp.tfm = ieee80211_aes_key_setup_encrypt(key_data);
Ben Hutchings1ac62ba2010-08-01 17:37:03 +0100342 if (IS_ERR(key->u.ccmp.tfm)) {
343 err = PTR_ERR(key->u.ccmp.tfm);
Johannes Berg3b967662008-04-08 17:56:52 +0200344 kfree(key);
Ben Hutchings1ac62ba2010-08-01 17:37:03 +0100345 key = ERR_PTR(err);
Johannes Berg11a843b2007-08-28 17:01:55 -0400346 }
Johannes Berg60ae0f22010-08-10 09:46:39 +0200347 break;
348 case WLAN_CIPHER_SUITE_AES_CMAC:
349 key->conf.iv_len = 0;
350 key->conf.icv_len = sizeof(struct ieee80211_mmie);
351 if (seq)
352 for (j = 0; j < 6; j++)
353 key->u.aes_cmac.rx_pn[j] = seq[6 - j - 1];
Jouni Malinen3cfcf6a2009-01-08 13:32:02 +0200354 /*
355 * Initialize AES key state here as an optimization so that
356 * it does not need to be initialized for every packet.
357 */
358 key->u.aes_cmac.tfm =
359 ieee80211_aes_cmac_key_setup(key_data);
Ben Hutchings1ac62ba2010-08-01 17:37:03 +0100360 if (IS_ERR(key->u.aes_cmac.tfm)) {
361 err = PTR_ERR(key->u.aes_cmac.tfm);
Jouni Malinen3cfcf6a2009-01-08 13:32:02 +0200362 kfree(key);
Ben Hutchings1ac62ba2010-08-01 17:37:03 +0100363 key = ERR_PTR(err);
Jouni Malinen3cfcf6a2009-01-08 13:32:02 +0200364 }
Johannes Berg60ae0f22010-08-10 09:46:39 +0200365 break;
Jouni Malinen3cfcf6a2009-01-08 13:32:02 +0200366 }
Johannes Berg60ae0f22010-08-10 09:46:39 +0200367 memcpy(key->conf.key, key_data, key_len);
368 INIT_LIST_HEAD(&key->list);
Jouni Malinen3cfcf6a2009-01-08 13:32:02 +0200369
Johannes Bergdb4d1162008-02-25 16:27:45 +0100370 return key;
371}
Johannes Berg11a843b2007-08-28 17:01:55 -0400372
Johannes Bergad0e2b52010-06-01 10:19:19 +0200373static void __ieee80211_key_destroy(struct ieee80211_key *key)
374{
375 if (!key)
376 return;
377
Johannes Bergd2460f42011-01-03 19:42:24 +0100378 /*
379 * Synchronize so the TX path can no longer be using
380 * this key before we free/remove it.
381 */
382 synchronize_rcu();
383
Jouni Malinen32162a42010-07-26 15:52:03 -0700384 if (key->local)
385 ieee80211_key_disable_hw_accel(key);
Johannes Bergad0e2b52010-06-01 10:19:19 +0200386
Johannes Berg97359d12010-08-10 09:46:38 +0200387 if (key->conf.cipher == WLAN_CIPHER_SUITE_CCMP)
Johannes Bergad0e2b52010-06-01 10:19:19 +0200388 ieee80211_aes_key_free(key->u.ccmp.tfm);
Johannes Berg97359d12010-08-10 09:46:38 +0200389 if (key->conf.cipher == WLAN_CIPHER_SUITE_AES_CMAC)
Johannes Bergad0e2b52010-06-01 10:19:19 +0200390 ieee80211_aes_cmac_key_free(key->u.aes_cmac.tfm);
Jouni Malinen32162a42010-07-26 15:52:03 -0700391 if (key->local)
392 ieee80211_debugfs_key_remove(key);
Johannes Bergad0e2b52010-06-01 10:19:19 +0200393
394 kfree(key);
395}
396
Johannes Berg3ffc2a92010-08-27 14:26:52 +0300397int ieee80211_key_link(struct ieee80211_key *key,
398 struct ieee80211_sub_if_data *sdata,
399 struct sta_info *sta)
Johannes Bergdb4d1162008-02-25 16:27:45 +0100400{
401 struct ieee80211_key *old_key;
Johannes Berg3ffc2a92010-08-27 14:26:52 +0300402 int idx, ret;
Johannes Berge31b8212010-10-05 19:39:30 +0200403 bool pairwise = key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE;
Johannes Bergdb4d1162008-02-25 16:27:45 +0100404
Johannes Bergdb4d1162008-02-25 16:27:45 +0100405 BUG_ON(!sdata);
406 BUG_ON(!key);
407
408 idx = key->conf.keyidx;
409 key->local = sdata->local;
410 key->sdata = sdata;
411 key->sta = sta;
412
Johannes Berg11a843b2007-08-28 17:01:55 -0400413 if (sta) {
Johannes Berg11a843b2007-08-28 17:01:55 -0400414 /*
415 * some hardware cannot handle TKIP with QoS, so
416 * we indicate whether QoS could be in use.
417 */
Johannes Berg07346f812008-05-03 01:02:02 +0200418 if (test_sta_flags(sta, WLAN_STA_WME))
Johannes Berg11a843b2007-08-28 17:01:55 -0400419 key->conf.flags |= IEEE80211_KEY_FLAG_WMM_STA;
420 } else {
Johannes Berg05c914f2008-09-11 00:01:58 +0200421 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
Johannes Berg11a843b2007-08-28 17:01:55 -0400422 struct sta_info *ap;
423
Johannes Berg3b967662008-04-08 17:56:52 +0200424 /*
Johannes Bergb5c34f62011-01-03 19:51:09 +0100425 * We're getting a sta pointer in, so must be under
426 * appropriate locking for sta_info_get().
Johannes Berg3b967662008-04-08 17:56:52 +0200427 */
Johannes Bergd0709a62008-02-25 16:27:46 +0100428
Johannes Berg11a843b2007-08-28 17:01:55 -0400429 /* same here, the AP could be using QoS */
Johannes Bergabe60632009-11-25 17:46:18 +0100430 ap = sta_info_get(key->sdata, key->sdata->u.mgd.bssid);
Johannes Berg11a843b2007-08-28 17:01:55 -0400431 if (ap) {
Johannes Berg07346f812008-05-03 01:02:02 +0200432 if (test_sta_flags(ap, WLAN_STA_WME))
Johannes Berg11a843b2007-08-28 17:01:55 -0400433 key->conf.flags |=
434 IEEE80211_KEY_FLAG_WMM_STA;
Johannes Berg11a843b2007-08-28 17:01:55 -0400435 }
436 }
Johannes Berg11a843b2007-08-28 17:01:55 -0400437 }
438
Johannes Bergad0e2b52010-06-01 10:19:19 +0200439 mutex_lock(&sdata->local->key_mtx);
Johannes Berg3b967662008-04-08 17:56:52 +0200440
Johannes Berge31b8212010-10-05 19:39:30 +0200441 if (sta && pairwise)
442 old_key = sta->ptk;
443 else if (sta)
444 old_key = sta->gtk[idx];
Johannes Bergd4e46a32007-09-14 11:10:24 -0400445 else
Johannes Bergdb4d1162008-02-25 16:27:45 +0100446 old_key = sdata->keys[idx];
447
Johannes Berge31b8212010-10-05 19:39:30 +0200448 __ieee80211_key_replace(sdata, sta, pairwise, old_key, key);
Johannes Bergad0e2b52010-06-01 10:19:19 +0200449 __ieee80211_key_destroy(old_key);
Johannes Bergd4e46a32007-09-14 11:10:24 -0400450
Johannes Bergad0e2b52010-06-01 10:19:19 +0200451 ieee80211_debugfs_key_add(key);
Johannes Berg3b967662008-04-08 17:56:52 +0200452
Johannes Berg3ffc2a92010-08-27 14:26:52 +0300453 ret = ieee80211_key_enable_hw_accel(key);
Johannes Berg523d2f62009-07-01 21:26:43 +0200454
Johannes Bergad0e2b52010-06-01 10:19:19 +0200455 mutex_unlock(&sdata->local->key_mtx);
Johannes Berg3ffc2a92010-08-27 14:26:52 +0300456
457 return ret;
Johannes Berg3a245762008-04-09 16:45:37 +0200458}
459
460static void __ieee80211_key_free(struct ieee80211_key *key)
461{
462 /*
463 * Replace key with nothingness if it was ever used.
464 */
465 if (key->sdata)
466 __ieee80211_key_replace(key->sdata, key->sta,
Johannes Berge31b8212010-10-05 19:39:30 +0200467 key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE,
468 key, NULL);
Johannes Bergad0e2b52010-06-01 10:19:19 +0200469 __ieee80211_key_destroy(key);
Johannes Berg1f5a7e42007-07-27 15:43:23 +0200470}
471
Jouni Malinen32162a42010-07-26 15:52:03 -0700472void ieee80211_key_free(struct ieee80211_local *local,
473 struct ieee80211_key *key)
Johannes Berg1f5a7e42007-07-27 15:43:23 +0200474{
Johannes Berg8f371712007-08-28 17:01:54 -0400475 if (!key)
476 return;
477
Johannes Bergad0e2b52010-06-01 10:19:19 +0200478 mutex_lock(&local->key_mtx);
Johannes Berg3a245762008-04-09 16:45:37 +0200479 __ieee80211_key_free(key);
Johannes Bergad0e2b52010-06-01 10:19:19 +0200480 mutex_unlock(&local->key_mtx);
Johannes Berg3b967662008-04-08 17:56:52 +0200481}
482
483void ieee80211_enable_keys(struct ieee80211_sub_if_data *sdata)
484{
Johannes Bergad0e2b52010-06-01 10:19:19 +0200485 struct ieee80211_key *key;
486
Johannes Berg3a245762008-04-09 16:45:37 +0200487 ASSERT_RTNL();
Johannes Berg3b967662008-04-08 17:56:52 +0200488
Johannes Berg9607e6b2009-12-23 13:15:31 +0100489 if (WARN_ON(!ieee80211_sdata_running(sdata)))
Johannes Berg3b967662008-04-08 17:56:52 +0200490 return;
491
Johannes Bergad0e2b52010-06-01 10:19:19 +0200492 mutex_lock(&sdata->local->key_mtx);
493
494 list_for_each_entry(key, &sdata->key_list, list)
495 ieee80211_key_enable_hw_accel(key);
496
497 mutex_unlock(&sdata->local->key_mtx);
Johannes Berg3b967662008-04-08 17:56:52 +0200498}
499
500void ieee80211_disable_keys(struct ieee80211_sub_if_data *sdata)
501{
Johannes Bergad0e2b52010-06-01 10:19:19 +0200502 struct ieee80211_key *key;
503
Johannes Berg3a245762008-04-09 16:45:37 +0200504 ASSERT_RTNL();
Johannes Berg3b967662008-04-08 17:56:52 +0200505
Johannes Bergad0e2b52010-06-01 10:19:19 +0200506 mutex_lock(&sdata->local->key_mtx);
Johannes Berg3b967662008-04-08 17:56:52 +0200507
Johannes Bergad0e2b52010-06-01 10:19:19 +0200508 list_for_each_entry(key, &sdata->key_list, list)
509 ieee80211_key_disable_hw_accel(key);
Johannes Berg3b967662008-04-08 17:56:52 +0200510
Johannes Bergad0e2b52010-06-01 10:19:19 +0200511 mutex_unlock(&sdata->local->key_mtx);
Johannes Berg11a843b2007-08-28 17:01:55 -0400512}
513
514void ieee80211_free_keys(struct ieee80211_sub_if_data *sdata)
515{
516 struct ieee80211_key *key, *tmp;
Johannes Bergdb4d1162008-02-25 16:27:45 +0100517
Johannes Bergad0e2b52010-06-01 10:19:19 +0200518 mutex_lock(&sdata->local->key_mtx);
Johannes Berg3b967662008-04-08 17:56:52 +0200519
Jouni Malinen3cfcf6a2009-01-08 13:32:02 +0200520 ieee80211_debugfs_key_remove_mgmt_default(sdata);
Johannes Berg11a843b2007-08-28 17:01:55 -0400521
522 list_for_each_entry_safe(key, tmp, &sdata->key_list, list)
Johannes Berg3a245762008-04-09 16:45:37 +0200523 __ieee80211_key_free(key);
Johannes Berg11a843b2007-08-28 17:01:55 -0400524
Johannes Bergf7e01042010-12-09 19:49:02 +0100525 ieee80211_debugfs_key_update_default(sdata);
526
Johannes Bergad0e2b52010-06-01 10:19:19 +0200527 mutex_unlock(&sdata->local->key_mtx);
Johannes Berg11a843b2007-08-28 17:01:55 -0400528}