blob: 44388d6a1d8e628f4324f64e95c9de675e861830 [file] [log] [blame]
Johannes Berg1f5a7e472007-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 Bergd98ad832014-09-03 15:24:57 +03006 * Copyright 2013-2014 Intel Mobile Communications GmbH
Johannes Berg1f5a7e472007-07-27 15:43:23 +02007 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 */
12
Johannes Berg11a843b2007-08-28 17:01:55 -040013#include <linux/if_ether.h>
14#include <linux/etherdevice.h>
15#include <linux/list.h>
Johannes Bergd4e46a32007-09-14 11:10:24 -040016#include <linux/rcupdate.h>
Johannes Bergdb4d1162008-02-25 16:27:45 +010017#include <linux/rtnetlink.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090018#include <linux/slab.h>
Paul Gortmakerbc3b2d72011-07-15 11:47:34 -040019#include <linux/export.h>
Johannes Berg1f5a7e472007-07-27 15:43:23 +020020#include <net/mac80211.h>
Johannes Bergd26ad372012-02-20 11:38:41 +010021#include <asm/unaligned.h>
Johannes Berg1f5a7e472007-07-27 15:43:23 +020022#include "ieee80211_i.h"
Johannes Berg24487982009-04-23 18:52:52 +020023#include "driver-ops.h"
Johannes Berg1f5a7e472007-07-27 15:43:23 +020024#include "debugfs_key.h"
25#include "aes_ccm.h"
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +020026#include "aes_cmac.h"
Jouni Malinen8ade5382015-01-24 19:52:09 +020027#include "aes_gmac.h"
Jouni Malinen00b9cfa2015-01-24 19:52:06 +020028#include "aes_gcm.h"
Johannes Berg1f5a7e472007-07-27 15:43:23 +020029
Johannes Berg11a843b2007-08-28 17:01:55 -040030
Johannes Bergdbbea672008-02-26 14:34:06 +010031/**
32 * DOC: Key handling basics
Johannes Berg11a843b2007-08-28 17:01:55 -040033 *
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 *
Johannes Bergb5c34f62011-01-03 19:51:09 +010038 * 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.
Johannes Berg11a843b2007-08-28 17:01:55 -040045 *
Johannes Bergb5c34f62011-01-03 19:51:09 +010046 * 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.
Johannes Berg11a843b2007-08-28 17:01:55 -040052 */
53
54static const u8 bcast_addr[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
Johannes Berg11a843b2007-08-28 17:01:55 -040055
Johannes Bergad0e2b52010-06-01 10:19:19 +020056static void assert_key_lock(struct ieee80211_local *local)
Johannes Berg3b967662008-04-08 17:56:52 +020057{
Johannes Berg46a5eba2010-09-15 13:28:15 +020058 lockdep_assert_held(&local->key_mtx);
Johannes Berg3b967662008-04-08 17:56:52 +020059}
60
Michal Kaziorf9dca802015-05-13 09:16:48 +000061static void
62update_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
Johannes Berg51f458d2015-06-17 13:54:54 +020069 /* crypto_tx_tailroom_needed_cnt is protected by this */
70 assert_key_lock(sdata->local);
Michal Kaziorf9dca802015-05-13 09:16:48 +000071
Johannes Berg51f458d2015-06-17 13:54:54 +020072 rcu_read_lock();
73
74 list_for_each_entry_rcu(vlan, &sdata->u.ap.vlans, u.vlan.list)
Michal Kaziorf9dca802015-05-13 09:16:48 +000075 vlan->crypto_tx_tailroom_needed_cnt += delta;
76
Johannes Berg51f458d2015-06-17 13:54:54 +020077 rcu_read_unlock();
Michal Kaziorf9dca802015-05-13 09:16:48 +000078}
79
Yogesh Ashok Powar3bff1862011-06-28 18:41:37 +053080static 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/1308590980.4322.19.camel@jlt3.sipsolutions.net
99 */
100
Johannes Berg51f458d2015-06-17 13:54:54 +0200101 assert_key_lock(sdata->local);
102
Michal Kaziorf9dca802015-05-13 09:16:48 +0000103 update_vlan_tailroom_need_count(sdata, 1);
104
Yogesh Ashok Powar3bff1862011-06-28 18:41:37 +0530105 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
Michal Kaziorf9dca802015-05-13 09:16:48 +0000114static void decrease_tailroom_need_count(struct ieee80211_sub_if_data *sdata,
115 int delta)
116{
Johannes Berg51f458d2015-06-17 13:54:54 +0200117 assert_key_lock(sdata->local);
118
Michal Kaziorf9dca802015-05-13 09:16:48 +0000119 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
Johannes Berg3ffc2a92010-08-27 14:26:52 +0300125static int ieee80211_key_enable_hw_accel(struct ieee80211_key *key)
Johannes Berg11a843b2007-08-28 17:01:55 -0400126{
Johannes Bergdc822b52008-12-29 12:55:09 +0100127 struct ieee80211_sub_if_data *sdata;
Johannes Berg89c91ca2012-01-20 13:55:19 +0100128 struct sta_info *sta;
Johannes Bergfa7e1fb2015-01-22 18:44:19 +0100129 int ret = -EOPNOTSUPP;
Johannes Berg11a843b2007-08-28 17:01:55 -0400130
Johannes Berg3b967662008-04-08 17:56:52 +0200131 might_sleep();
132
Johannes Berg46191942014-10-13 13:43:29 +0200133 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 key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE;
Johannes Berg27b3eb92013-08-07 20:11:55 +0200142 return -EINVAL;
Johannes Berg46191942014-10-13 13:43:29 +0200143 }
Johannes Berg27b3eb92013-08-07 20:11:55 +0200144
Johannes Berge31b8212010-10-05 19:39:30 +0200145 if (!key->local->ops->set_key)
Johannes Berg3ffc2a92010-08-27 14:26:52 +0300146 goto out_unsupported;
Johannes Berg11a843b2007-08-28 17:01:55 -0400147
Johannes Bergad0e2b52010-06-01 10:19:19 +0200148 assert_key_lock(key->local);
149
Johannes Berg89c91ca2012-01-20 13:55:19 +0100150 sta = key->sta;
Johannes Bergdc822b52008-12-29 12:55:09 +0100151
Johannes Berge31b8212010-10-05 19:39:30 +0200152 /*
153 * If this is a per-STA GTK, check if it
154 * is supported; if not, return.
155 */
156 if (sta && !(key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE) &&
Johannes Berg30686bf2015-06-02 21:39:54 +0200157 !ieee80211_hw_check(&key->local->hw, SUPPORTS_PER_STA_GTK))
Johannes Berge31b8212010-10-05 19:39:30 +0200158 goto out_unsupported;
159
Johannes Berg89c91ca2012-01-20 13:55:19 +0100160 if (sta && !sta->uploaded)
161 goto out_unsupported;
162
Johannes Bergdc822b52008-12-29 12:55:09 +0100163 sdata = key->sdata;
Helmut Schaa18890d42010-11-19 08:11:01 +0100164 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
165 /*
166 * The driver doesn't know anything about VLAN interfaces.
167 * Hence, don't send GTKs for VLAN interfaces to the driver.
168 */
169 if (!(key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE))
170 goto out_unsupported;
Helmut Schaa18890d42010-11-19 08:11:01 +0100171 }
Johannes Berg11a843b2007-08-28 17:01:55 -0400172
Johannes Berg89c91ca2012-01-20 13:55:19 +0100173 ret = drv_set_key(key->local, SET_KEY, sdata,
174 sta ? &sta->sta : NULL, &key->conf);
Johannes Berg11a843b2007-08-28 17:01:55 -0400175
Johannes Berge31b8212010-10-05 19:39:30 +0200176 if (!ret) {
Johannes Berg11a843b2007-08-28 17:01:55 -0400177 key->flags |= KEY_FLAG_UPLOADED_TO_HARDWARE;
Yogesh Ashok Powar3bff1862011-06-28 18:41:37 +0530178
Johannes Berg1e359a52015-01-05 10:28:49 +0100179 if (!((key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_MMIC) ||
Ido Yarivdb128472015-01-06 08:39:02 -0500180 (key->conf.flags & IEEE80211_KEY_FLAG_RESERVE_TAILROOM)))
Michal Kaziorf9dca802015-05-13 09:16:48 +0000181 decrease_tailroom_need_count(sdata, 1);
Yogesh Ashok Powar3bff1862011-06-28 18:41:37 +0530182
Arik Nemtsov077a9152011-10-23 08:21:41 +0200183 WARN_ON((key->conf.flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE) &&
184 (key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_IV));
185
Johannes Berge31b8212010-10-05 19:39:30 +0200186 return 0;
187 }
Johannes Berg11a843b2007-08-28 17:01:55 -0400188
Johannes Bergfa7e1fb2015-01-22 18:44:19 +0100189 if (ret != -ENOSPC && ret != -EOPNOTSUPP && ret != 1)
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200190 sdata_err(sdata,
Joe Perches0fb9a9e2010-08-20 16:25:38 -0700191 "failed to set key (%d, %pM) to hardware (%d)\n",
Johannes Berg89c91ca2012-01-20 13:55:19 +0100192 key->conf.keyidx,
193 sta ? sta->sta.addr : bcast_addr, ret);
Johannes Berg3ffc2a92010-08-27 14:26:52 +0300194
Johannes Berge31b8212010-10-05 19:39:30 +0200195 out_unsupported:
196 switch (key->conf.cipher) {
197 case WLAN_CIPHER_SUITE_WEP40:
198 case WLAN_CIPHER_SUITE_WEP104:
199 case WLAN_CIPHER_SUITE_TKIP:
200 case WLAN_CIPHER_SUITE_CCMP:
Jouni Malinen2b2ba0d2015-01-24 19:52:07 +0200201 case WLAN_CIPHER_SUITE_CCMP_256:
Johannes Berge31b8212010-10-05 19:39:30 +0200202 case WLAN_CIPHER_SUITE_AES_CMAC:
Jouni Malinen56c52da2015-01-24 19:52:08 +0200203 case WLAN_CIPHER_SUITE_BIP_CMAC_256:
Jouni Malinen8ade5382015-01-24 19:52:09 +0200204 case WLAN_CIPHER_SUITE_BIP_GMAC_128:
205 case WLAN_CIPHER_SUITE_BIP_GMAC_256:
Jouni Malinen00b9cfa2015-01-24 19:52:06 +0200206 case WLAN_CIPHER_SUITE_GCMP:
207 case WLAN_CIPHER_SUITE_GCMP_256:
Johannes Bergfa7e1fb2015-01-22 18:44:19 +0100208 /* all of these we can do in software - if driver can */
209 if (ret == 1)
210 return 0;
Johannes Berg30686bf2015-06-02 21:39:54 +0200211 if (ieee80211_hw_check(&key->local->hw, SW_CRYPTO_CONTROL))
Johannes Bergfa7e1fb2015-01-22 18:44:19 +0100212 return -EINVAL;
Johannes Berge31b8212010-10-05 19:39:30 +0200213 return 0;
214 default:
215 return -EINVAL;
Johannes Berg3ffc2a92010-08-27 14:26:52 +0300216 }
Johannes Berg11a843b2007-08-28 17:01:55 -0400217}
218
219static void ieee80211_key_disable_hw_accel(struct ieee80211_key *key)
220{
Johannes Bergdc822b52008-12-29 12:55:09 +0100221 struct ieee80211_sub_if_data *sdata;
Johannes Berg89c91ca2012-01-20 13:55:19 +0100222 struct sta_info *sta;
Johannes Berg11a843b2007-08-28 17:01:55 -0400223 int ret;
224
Johannes Berg3b967662008-04-08 17:56:52 +0200225 might_sleep();
226
Johannes Bergdb4d1162008-02-25 16:27:45 +0100227 if (!key || !key->local->ops->set_key)
Johannes Berg11a843b2007-08-28 17:01:55 -0400228 return;
229
Johannes Bergad0e2b52010-06-01 10:19:19 +0200230 assert_key_lock(key->local);
231
232 if (!(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
Johannes Berg11a843b2007-08-28 17:01:55 -0400233 return;
234
Johannes Berg89c91ca2012-01-20 13:55:19 +0100235 sta = key->sta;
Johannes Bergdc822b52008-12-29 12:55:09 +0100236 sdata = key->sdata;
237
Johannes Berg1e359a52015-01-05 10:28:49 +0100238 if (!((key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_MMIC) ||
Ido Yarivdb128472015-01-06 08:39:02 -0500239 (key->conf.flags & IEEE80211_KEY_FLAG_RESERVE_TAILROOM)))
Yogesh Ashok Powar3bff1862011-06-28 18:41:37 +0530240 increment_tailroom_need_count(sdata);
241
Johannes Berg12375ef2009-11-25 20:30:31 +0100242 ret = drv_set_key(key->local, DISABLE_KEY, sdata,
Johannes Berg89c91ca2012-01-20 13:55:19 +0100243 sta ? &sta->sta : NULL, &key->conf);
Johannes Berg11a843b2007-08-28 17:01:55 -0400244
245 if (ret)
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200246 sdata_err(sdata,
Joe Perches0fb9a9e2010-08-20 16:25:38 -0700247 "failed to remove key (%d, %pM) from hardware (%d)\n",
Johannes Berg89c91ca2012-01-20 13:55:19 +0100248 key->conf.keyidx,
249 sta ? sta->sta.addr : bcast_addr, ret);
Johannes Berg11a843b2007-08-28 17:01:55 -0400250
Johannes Berg3b967662008-04-08 17:56:52 +0200251 key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE;
Johannes Berg3b967662008-04-08 17:56:52 +0200252}
253
254static void __ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata,
Johannes Bergf7e01042010-12-09 19:49:02 +0100255 int idx, bool uni, bool multi)
Johannes Berg3b967662008-04-08 17:56:52 +0200256{
257 struct ieee80211_key *key = NULL;
258
Johannes Bergad0e2b52010-06-01 10:19:19 +0200259 assert_key_lock(sdata->local);
260
Johannes Berg3b967662008-04-08 17:56:52 +0200261 if (idx >= 0 && idx < NUM_DEFAULT_KEYS)
Johannes Berg40b275b2011-05-13 14:15:49 +0200262 key = key_mtx_dereference(sdata->local, sdata->keys[idx]);
Johannes Berg3b967662008-04-08 17:56:52 +0200263
Yoni Divinskyde5fad82012-05-30 11:36:39 +0300264 if (uni) {
Johannes Bergf7e01042010-12-09 19:49:02 +0100265 rcu_assign_pointer(sdata->default_unicast_key, key);
Johannes Berg17c18bf2015-03-21 15:25:43 +0100266 ieee80211_check_fast_xmit_iface(sdata);
Yoni Divinskyde5fad82012-05-30 11:36:39 +0300267 drv_set_default_unicast_key(sdata->local, sdata, idx);
268 }
269
Johannes Bergf7e01042010-12-09 19:49:02 +0100270 if (multi)
271 rcu_assign_pointer(sdata->default_multicast_key, key);
Johannes Berg3b967662008-04-08 17:56:52 +0200272
Johannes Bergf7e01042010-12-09 19:49:02 +0100273 ieee80211_debugfs_key_update_default(sdata);
Johannes Berg3b967662008-04-08 17:56:52 +0200274}
275
Johannes Bergf7e01042010-12-09 19:49:02 +0100276void ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata, int idx,
277 bool uni, bool multi)
Johannes Berg3b967662008-04-08 17:56:52 +0200278{
Johannes Bergad0e2b52010-06-01 10:19:19 +0200279 mutex_lock(&sdata->local->key_mtx);
Johannes Bergf7e01042010-12-09 19:49:02 +0100280 __ieee80211_set_default_key(sdata, idx, uni, multi);
Johannes Bergad0e2b52010-06-01 10:19:19 +0200281 mutex_unlock(&sdata->local->key_mtx);
Johannes Berg3b967662008-04-08 17:56:52 +0200282}
283
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200284static void
285__ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata, int idx)
286{
287 struct ieee80211_key *key = NULL;
288
Johannes Bergad0e2b52010-06-01 10:19:19 +0200289 assert_key_lock(sdata->local);
290
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200291 if (idx >= NUM_DEFAULT_KEYS &&
292 idx < NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS)
Johannes Berg40b275b2011-05-13 14:15:49 +0200293 key = key_mtx_dereference(sdata->local, sdata->keys[idx]);
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200294
295 rcu_assign_pointer(sdata->default_mgmt_key, key);
296
Johannes Bergf7e01042010-12-09 19:49:02 +0100297 ieee80211_debugfs_key_update_default(sdata);
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200298}
299
300void ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata,
301 int idx)
302{
Johannes Bergad0e2b52010-06-01 10:19:19 +0200303 mutex_lock(&sdata->local->key_mtx);
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200304 __ieee80211_set_default_mgmt_key(sdata, idx);
Johannes Bergad0e2b52010-06-01 10:19:19 +0200305 mutex_unlock(&sdata->local->key_mtx);
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200306}
307
Johannes Berg3b967662008-04-08 17:56:52 +0200308
Johannes Berg3b8d9c22013-03-06 22:58:23 +0100309static void ieee80211_key_replace(struct ieee80211_sub_if_data *sdata,
310 struct sta_info *sta,
311 bool pairwise,
312 struct ieee80211_key *old,
313 struct ieee80211_key *new)
Johannes Berg3b967662008-04-08 17:56:52 +0200314{
Johannes Bergf7e01042010-12-09 19:49:02 +0100315 int idx;
316 bool defunikey, defmultikey, defmgmtkey;
Johannes Berg3b967662008-04-08 17:56:52 +0200317
Johannes Berg5282c3b2013-10-29 10:00:08 +0100318 /* caller must provide at least one old/new */
319 if (WARN_ON(!new && !old))
320 return;
321
Johannes Berg3b967662008-04-08 17:56:52 +0200322 if (new)
Johannes Bergf850e002011-07-13 19:50:53 +0200323 list_add_tail(&new->list, &sdata->key_list);
Johannes Berg3b967662008-04-08 17:56:52 +0200324
Max Stepanov2475b1cc2013-03-24 14:23:27 +0200325 WARN_ON(new && old && new->conf.keyidx != old->conf.keyidx);
326
327 if (old)
328 idx = old->conf.keyidx;
329 else
330 idx = new->conf.keyidx;
331
332 if (sta) {
333 if (pairwise) {
334 rcu_assign_pointer(sta->ptk[idx], new);
335 sta->ptk_idx = idx;
Johannes Berg17c18bf2015-03-21 15:25:43 +0100336 ieee80211_check_fast_xmit(sta);
Max Stepanov2475b1cc2013-03-24 14:23:27 +0200337 } else {
338 rcu_assign_pointer(sta->gtk[idx], new);
Max Stepanov2475b1cc2013-03-24 14:23:27 +0200339 }
Johannes Berg3b967662008-04-08 17:56:52 +0200340 } else {
Johannes Berg40b275b2011-05-13 14:15:49 +0200341 defunikey = old &&
342 old == key_mtx_dereference(sdata->local,
343 sdata->default_unicast_key);
344 defmultikey = old &&
345 old == key_mtx_dereference(sdata->local,
346 sdata->default_multicast_key);
347 defmgmtkey = old &&
348 old == key_mtx_dereference(sdata->local,
349 sdata->default_mgmt_key);
Johannes Berg3b967662008-04-08 17:56:52 +0200350
Johannes Bergf7e01042010-12-09 19:49:02 +0100351 if (defunikey && !new)
352 __ieee80211_set_default_key(sdata, -1, true, false);
353 if (defmultikey && !new)
354 __ieee80211_set_default_key(sdata, -1, false, true);
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200355 if (defmgmtkey && !new)
356 __ieee80211_set_default_mgmt_key(sdata, -1);
Johannes Berg3b967662008-04-08 17:56:52 +0200357
358 rcu_assign_pointer(sdata->keys[idx], new);
Johannes Bergf7e01042010-12-09 19:49:02 +0100359 if (defunikey && new)
360 __ieee80211_set_default_key(sdata, new->conf.keyidx,
361 true, false);
362 if (defmultikey && new)
363 __ieee80211_set_default_key(sdata, new->conf.keyidx,
364 false, true);
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200365 if (defmgmtkey && new)
366 __ieee80211_set_default_mgmt_key(sdata,
367 new->conf.keyidx);
Johannes Berg3b967662008-04-08 17:56:52 +0200368 }
369
Johannes Bergb5c34f62011-01-03 19:51:09 +0100370 if (old)
371 list_del(&old->list);
Johannes Berg11a843b2007-08-28 17:01:55 -0400372}
373
Max Stepanov2475b1cc2013-03-24 14:23:27 +0200374struct ieee80211_key *
375ieee80211_key_alloc(u32 cipher, int idx, size_t key_len,
376 const u8 *key_data,
377 size_t seq_len, const u8 *seq,
378 const struct ieee80211_cipher_scheme *cs)
Johannes Berg1f5a7e472007-07-27 15:43:23 +0200379{
380 struct ieee80211_key *key;
Ben Hutchings1ac62ba2010-08-01 17:37:03 +0100381 int i, j, err;
Johannes Berg1f5a7e472007-07-27 15:43:23 +0200382
Johannes Berg8c5bb1f2014-04-29 17:55:26 +0200383 if (WARN_ON(idx < 0 || idx >= NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS))
384 return ERR_PTR(-EINVAL);
Johannes Berg11a843b2007-08-28 17:01:55 -0400385
386 key = kzalloc(sizeof(struct ieee80211_key) + key_len, GFP_KERNEL);
Johannes Berg1f5a7e472007-07-27 15:43:23 +0200387 if (!key)
Ben Hutchings1ac62ba2010-08-01 17:37:03 +0100388 return ERR_PTR(-ENOMEM);
Johannes Berg11a843b2007-08-28 17:01:55 -0400389
390 /*
391 * Default to software encryption; we'll later upload the
392 * key to the hardware if possible.
393 */
Johannes Berg11a843b2007-08-28 17:01:55 -0400394 key->conf.flags = 0;
395 key->flags = 0;
396
Johannes Berg97359d12010-08-10 09:46:38 +0200397 key->conf.cipher = cipher;
Johannes Berg11a843b2007-08-28 17:01:55 -0400398 key->conf.keyidx = idx;
399 key->conf.keylen = key_len;
Johannes Berg97359d12010-08-10 09:46:38 +0200400 switch (cipher) {
401 case WLAN_CIPHER_SUITE_WEP40:
402 case WLAN_CIPHER_SUITE_WEP104:
Johannes Berg4325f6c2013-05-08 13:09:08 +0200403 key->conf.iv_len = IEEE80211_WEP_IV_LEN;
404 key->conf.icv_len = IEEE80211_WEP_ICV_LEN;
Felix Fietkau76708de2008-10-05 18:02:48 +0200405 break;
Johannes Berg97359d12010-08-10 09:46:38 +0200406 case WLAN_CIPHER_SUITE_TKIP:
Johannes Berg4325f6c2013-05-08 13:09:08 +0200407 key->conf.iv_len = IEEE80211_TKIP_IV_LEN;
408 key->conf.icv_len = IEEE80211_TKIP_ICV_LEN;
Jouni Malinen9f26a952009-05-15 12:38:32 +0300409 if (seq) {
Johannes Berg5a306f52012-11-14 23:22:21 +0100410 for (i = 0; i < IEEE80211_NUM_TIDS; i++) {
Jouni Malinenfaa8fdc2009-05-11 21:57:58 +0300411 key->u.tkip.rx[i].iv32 =
412 get_unaligned_le32(&seq[2]);
413 key->u.tkip.rx[i].iv16 =
414 get_unaligned_le16(seq);
415 }
416 }
Johannes Berg523b02e2011-07-07 22:28:01 +0200417 spin_lock_init(&key->u.tkip.txlock);
Felix Fietkau76708de2008-10-05 18:02:48 +0200418 break;
Johannes Berg97359d12010-08-10 09:46:38 +0200419 case WLAN_CIPHER_SUITE_CCMP:
Johannes Berg4325f6c2013-05-08 13:09:08 +0200420 key->conf.iv_len = IEEE80211_CCMP_HDR_LEN;
421 key->conf.icv_len = IEEE80211_CCMP_MIC_LEN;
Jouni Malinen9f26a952009-05-15 12:38:32 +0300422 if (seq) {
Johannes Berg5a306f52012-11-14 23:22:21 +0100423 for (i = 0; i < IEEE80211_NUM_TIDS + 1; i++)
Johannes Berg4325f6c2013-05-08 13:09:08 +0200424 for (j = 0; j < IEEE80211_CCMP_PN_LEN; j++)
Jouni Malinenfaa8fdc2009-05-11 21:57:58 +0300425 key->u.ccmp.rx_pn[i][j] =
Johannes Berg4325f6c2013-05-08 13:09:08 +0200426 seq[IEEE80211_CCMP_PN_LEN - j - 1];
Jouni Malinenfaa8fdc2009-05-11 21:57:58 +0300427 }
Johannes Berg11a843b2007-08-28 17:01:55 -0400428 /*
429 * Initialize AES key state here as an optimization so that
430 * it does not need to be initialized for every packet.
431 */
Jouni Malinen2b2ba0d2015-01-24 19:52:07 +0200432 key->u.ccmp.tfm = ieee80211_aes_key_setup_encrypt(
433 key_data, key_len, IEEE80211_CCMP_MIC_LEN);
434 if (IS_ERR(key->u.ccmp.tfm)) {
435 err = PTR_ERR(key->u.ccmp.tfm);
436 kfree(key);
437 return ERR_PTR(err);
438 }
439 break;
440 case WLAN_CIPHER_SUITE_CCMP_256:
441 key->conf.iv_len = IEEE80211_CCMP_256_HDR_LEN;
442 key->conf.icv_len = IEEE80211_CCMP_256_MIC_LEN;
443 for (i = 0; seq && i < IEEE80211_NUM_TIDS + 1; i++)
444 for (j = 0; j < IEEE80211_CCMP_256_PN_LEN; j++)
445 key->u.ccmp.rx_pn[i][j] =
446 seq[IEEE80211_CCMP_256_PN_LEN - j - 1];
447 /* Initialize AES key state here as an optimization so that
448 * it does not need to be initialized for every packet.
449 */
450 key->u.ccmp.tfm = ieee80211_aes_key_setup_encrypt(
451 key_data, key_len, IEEE80211_CCMP_256_MIC_LEN);
Ben Hutchings1ac62ba2010-08-01 17:37:03 +0100452 if (IS_ERR(key->u.ccmp.tfm)) {
453 err = PTR_ERR(key->u.ccmp.tfm);
Johannes Berg3b967662008-04-08 17:56:52 +0200454 kfree(key);
Petr Å tetiar1f951a72011-03-27 13:31:26 +0200455 return ERR_PTR(err);
Johannes Berg11a843b2007-08-28 17:01:55 -0400456 }
Johannes Berg60ae0f22010-08-10 09:46:39 +0200457 break;
458 case WLAN_CIPHER_SUITE_AES_CMAC:
Jouni Malinen56c52da2015-01-24 19:52:08 +0200459 case WLAN_CIPHER_SUITE_BIP_CMAC_256:
Johannes Berg60ae0f22010-08-10 09:46:39 +0200460 key->conf.iv_len = 0;
Jouni Malinen56c52da2015-01-24 19:52:08 +0200461 if (cipher == WLAN_CIPHER_SUITE_AES_CMAC)
462 key->conf.icv_len = sizeof(struct ieee80211_mmie);
463 else
464 key->conf.icv_len = sizeof(struct ieee80211_mmie_16);
Johannes Berg60ae0f22010-08-10 09:46:39 +0200465 if (seq)
Johannes Berg4325f6c2013-05-08 13:09:08 +0200466 for (j = 0; j < IEEE80211_CMAC_PN_LEN; j++)
Johannes Berg0f927322012-11-14 23:15:11 +0100467 key->u.aes_cmac.rx_pn[j] =
Johannes Berg4325f6c2013-05-08 13:09:08 +0200468 seq[IEEE80211_CMAC_PN_LEN - j - 1];
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200469 /*
470 * Initialize AES key state here as an optimization so that
471 * it does not need to be initialized for every packet.
472 */
473 key->u.aes_cmac.tfm =
Jouni Malinen56c52da2015-01-24 19:52:08 +0200474 ieee80211_aes_cmac_key_setup(key_data, key_len);
Ben Hutchings1ac62ba2010-08-01 17:37:03 +0100475 if (IS_ERR(key->u.aes_cmac.tfm)) {
476 err = PTR_ERR(key->u.aes_cmac.tfm);
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200477 kfree(key);
Petr Å tetiar1f951a72011-03-27 13:31:26 +0200478 return ERR_PTR(err);
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200479 }
Johannes Berg60ae0f22010-08-10 09:46:39 +0200480 break;
Jouni Malinen8ade5382015-01-24 19:52:09 +0200481 case WLAN_CIPHER_SUITE_BIP_GMAC_128:
482 case WLAN_CIPHER_SUITE_BIP_GMAC_256:
483 key->conf.iv_len = 0;
484 key->conf.icv_len = sizeof(struct ieee80211_mmie_16);
485 if (seq)
486 for (j = 0; j < IEEE80211_GMAC_PN_LEN; j++)
487 key->u.aes_gmac.rx_pn[j] =
488 seq[IEEE80211_GMAC_PN_LEN - j - 1];
489 /* Initialize AES key state here as an optimization so that
490 * it does not need to be initialized for every packet.
491 */
492 key->u.aes_gmac.tfm =
493 ieee80211_aes_gmac_key_setup(key_data, key_len);
494 if (IS_ERR(key->u.aes_gmac.tfm)) {
495 err = PTR_ERR(key->u.aes_gmac.tfm);
496 kfree(key);
497 return ERR_PTR(err);
498 }
499 break;
Jouni Malinen00b9cfa2015-01-24 19:52:06 +0200500 case WLAN_CIPHER_SUITE_GCMP:
501 case WLAN_CIPHER_SUITE_GCMP_256:
502 key->conf.iv_len = IEEE80211_GCMP_HDR_LEN;
503 key->conf.icv_len = IEEE80211_GCMP_MIC_LEN;
504 for (i = 0; seq && i < IEEE80211_NUM_TIDS + 1; i++)
505 for (j = 0; j < IEEE80211_GCMP_PN_LEN; j++)
506 key->u.gcmp.rx_pn[i][j] =
507 seq[IEEE80211_GCMP_PN_LEN - j - 1];
508 /* Initialize AES key state here as an optimization so that
509 * it does not need to be initialized for every packet.
510 */
511 key->u.gcmp.tfm = ieee80211_aes_gcm_key_setup_encrypt(key_data,
512 key_len);
513 if (IS_ERR(key->u.gcmp.tfm)) {
514 err = PTR_ERR(key->u.gcmp.tfm);
515 kfree(key);
516 return ERR_PTR(err);
517 }
518 break;
Max Stepanov2475b1cc2013-03-24 14:23:27 +0200519 default:
520 if (cs) {
Johannes Berge3a55b52015-05-05 16:32:29 +0200521 if (seq_len && seq_len != cs->pn_len) {
522 kfree(key);
523 return ERR_PTR(-EINVAL);
524 }
Max Stepanov2475b1cc2013-03-24 14:23:27 +0200525
526 key->conf.iv_len = cs->hdr_len;
527 key->conf.icv_len = cs->mic_len;
528 for (i = 0; i < IEEE80211_NUM_TIDS + 1; i++)
Johannes Berge3a55b52015-05-05 16:32:29 +0200529 for (j = 0; j < seq_len; j++)
Max Stepanov2475b1cc2013-03-24 14:23:27 +0200530 key->u.gen.rx_pn[i][j] =
Johannes Berge3a55b52015-05-05 16:32:29 +0200531 seq[seq_len - j - 1];
Cedric Izoardc7ef38e2015-03-17 10:47:33 +0000532 key->flags |= KEY_FLAG_CIPHER_SCHEME;
Max Stepanov2475b1cc2013-03-24 14:23:27 +0200533 }
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200534 }
Johannes Berg60ae0f22010-08-10 09:46:39 +0200535 memcpy(key->conf.key, key_data, key_len);
536 INIT_LIST_HEAD(&key->list);
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200537
Johannes Bergdb4d1162008-02-25 16:27:45 +0100538 return key;
539}
Johannes Berg11a843b2007-08-28 17:01:55 -0400540
Johannes Berg79cf2df2013-03-06 22:53:52 +0100541static void ieee80211_key_free_common(struct ieee80211_key *key)
542{
Jouni Malinen00b9cfa2015-01-24 19:52:06 +0200543 switch (key->conf.cipher) {
544 case WLAN_CIPHER_SUITE_CCMP:
Jouni Malinen2b2ba0d2015-01-24 19:52:07 +0200545 case WLAN_CIPHER_SUITE_CCMP_256:
Johannes Berg79cf2df2013-03-06 22:53:52 +0100546 ieee80211_aes_key_free(key->u.ccmp.tfm);
Jouni Malinen00b9cfa2015-01-24 19:52:06 +0200547 break;
548 case WLAN_CIPHER_SUITE_AES_CMAC:
Jouni Malinen56c52da2015-01-24 19:52:08 +0200549 case WLAN_CIPHER_SUITE_BIP_CMAC_256:
Johannes Berg79cf2df2013-03-06 22:53:52 +0100550 ieee80211_aes_cmac_key_free(key->u.aes_cmac.tfm);
Jouni Malinen00b9cfa2015-01-24 19:52:06 +0200551 break;
Jouni Malinen8ade5382015-01-24 19:52:09 +0200552 case WLAN_CIPHER_SUITE_BIP_GMAC_128:
553 case WLAN_CIPHER_SUITE_BIP_GMAC_256:
554 ieee80211_aes_gmac_key_free(key->u.aes_gmac.tfm);
555 break;
Jouni Malinen00b9cfa2015-01-24 19:52:06 +0200556 case WLAN_CIPHER_SUITE_GCMP:
557 case WLAN_CIPHER_SUITE_GCMP_256:
558 ieee80211_aes_gcm_key_free(key->u.gcmp.tfm);
559 break;
560 }
Johannes Berg29c3f9c2014-09-10 13:39:55 +0300561 kzfree(key);
Johannes Berg79cf2df2013-03-06 22:53:52 +0100562}
563
Johannes Berg6d10e462013-03-06 23:09:11 +0100564static void __ieee80211_key_destroy(struct ieee80211_key *key,
565 bool delay_tailroom)
Johannes Bergad0e2b52010-06-01 10:19:19 +0200566{
Jouni Malinen32162a42010-07-26 15:52:03 -0700567 if (key->local)
568 ieee80211_key_disable_hw_accel(key);
Johannes Bergad0e2b52010-06-01 10:19:19 +0200569
Yogesh Ashok Powar3bff1862011-06-28 18:41:37 +0530570 if (key->local) {
Johannes Berg8d1f7ec2013-02-23 00:59:03 +0100571 struct ieee80211_sub_if_data *sdata = key->sdata;
572
Jouni Malinen32162a42010-07-26 15:52:03 -0700573 ieee80211_debugfs_key_remove(key);
Johannes Berg8d1f7ec2013-02-23 00:59:03 +0100574
575 if (delay_tailroom) {
576 /* see ieee80211_delayed_tailroom_dec */
577 sdata->crypto_tx_tailroom_pending_dec++;
578 schedule_delayed_work(&sdata->dec_tailroom_needed_wk,
579 HZ/2);
580 } else {
Michal Kaziorf9dca802015-05-13 09:16:48 +0000581 decrease_tailroom_need_count(sdata, 1);
Johannes Berg8d1f7ec2013-02-23 00:59:03 +0100582 }
Yogesh Ashok Powar3bff1862011-06-28 18:41:37 +0530583 }
Johannes Bergad0e2b52010-06-01 10:19:19 +0200584
Johannes Berg79cf2df2013-03-06 22:53:52 +0100585 ieee80211_key_free_common(key);
586}
587
Johannes Berg6d10e462013-03-06 23:09:11 +0100588static void ieee80211_key_destroy(struct ieee80211_key *key,
589 bool delay_tailroom)
590{
591 if (!key)
592 return;
593
594 /*
595 * Synchronize so the TX path can no longer be using
596 * this key before we free/remove it.
597 */
598 synchronize_net();
599
600 __ieee80211_key_destroy(key, delay_tailroom);
601}
602
Johannes Berg79cf2df2013-03-06 22:53:52 +0100603void ieee80211_key_free_unused(struct ieee80211_key *key)
604{
605 WARN_ON(key->sdata || key->local);
606 ieee80211_key_free_common(key);
Johannes Bergad0e2b52010-06-01 10:19:19 +0200607}
608
Johannes Berg3ffc2a92010-08-27 14:26:52 +0300609int ieee80211_key_link(struct ieee80211_key *key,
610 struct ieee80211_sub_if_data *sdata,
611 struct sta_info *sta)
Johannes Bergdb4d1162008-02-25 16:27:45 +0100612{
Johannes Berg27b3eb92013-08-07 20:11:55 +0200613 struct ieee80211_local *local = sdata->local;
Johannes Bergdb4d1162008-02-25 16:27:45 +0100614 struct ieee80211_key *old_key;
Johannes Berg3ffc2a92010-08-27 14:26:52 +0300615 int idx, ret;
Mariusz Kozlowski67aa0302011-03-26 18:58:51 +0100616 bool pairwise;
Johannes Bergdb4d1162008-02-25 16:27:45 +0100617
Mariusz Kozlowski67aa0302011-03-26 18:58:51 +0100618 pairwise = key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE;
Johannes Bergdb4d1162008-02-25 16:27:45 +0100619 idx = key->conf.keyidx;
620 key->local = sdata->local;
621 key->sdata = sdata;
622 key->sta = sta;
623
Johannes Bergad0e2b52010-06-01 10:19:19 +0200624 mutex_lock(&sdata->local->key_mtx);
Johannes Berg3b967662008-04-08 17:56:52 +0200625
Johannes Berge31b8212010-10-05 19:39:30 +0200626 if (sta && pairwise)
Max Stepanov2475b1cc2013-03-24 14:23:27 +0200627 old_key = key_mtx_dereference(sdata->local, sta->ptk[idx]);
Johannes Berge31b8212010-10-05 19:39:30 +0200628 else if (sta)
Johannes Berg40b275b2011-05-13 14:15:49 +0200629 old_key = key_mtx_dereference(sdata->local, sta->gtk[idx]);
Johannes Bergd4e46a32007-09-14 11:10:24 -0400630 else
Johannes Berg40b275b2011-05-13 14:15:49 +0200631 old_key = key_mtx_dereference(sdata->local, sdata->keys[idx]);
Johannes Bergdb4d1162008-02-25 16:27:45 +0100632
Yogesh Ashok Powar3bff1862011-06-28 18:41:37 +0530633 increment_tailroom_need_count(sdata);
634
Johannes Berg3b8d9c22013-03-06 22:58:23 +0100635 ieee80211_key_replace(sdata, sta, pairwise, old_key, key);
636 ieee80211_key_destroy(old_key, true);
Johannes Bergd4e46a32007-09-14 11:10:24 -0400637
Johannes Bergad0e2b52010-06-01 10:19:19 +0200638 ieee80211_debugfs_key_add(key);
Johannes Berg3b967662008-04-08 17:56:52 +0200639
Johannes Berg27b3eb92013-08-07 20:11:55 +0200640 if (!local->wowlan) {
641 ret = ieee80211_key_enable_hw_accel(key);
642 if (ret)
643 ieee80211_key_free(key, true);
644 } else {
645 ret = 0;
646 }
Johannes Berg79cf2df2013-03-06 22:53:52 +0100647
Johannes Bergad0e2b52010-06-01 10:19:19 +0200648 mutex_unlock(&sdata->local->key_mtx);
Johannes Berg3ffc2a92010-08-27 14:26:52 +0300649
650 return ret;
Johannes Berg3a245762008-04-09 16:45:37 +0200651}
652
Johannes Berg3b8d9c22013-03-06 22:58:23 +0100653void ieee80211_key_free(struct ieee80211_key *key, bool delay_tailroom)
Johannes Berg3a245762008-04-09 16:45:37 +0200654{
Johannes Berg5c0c3642011-05-12 14:31:49 +0200655 if (!key)
656 return;
657
Johannes Berg3a245762008-04-09 16:45:37 +0200658 /*
659 * Replace key with nothingness if it was ever used.
660 */
661 if (key->sdata)
Johannes Berg3b8d9c22013-03-06 22:58:23 +0100662 ieee80211_key_replace(key->sdata, key->sta,
Johannes Berge31b8212010-10-05 19:39:30 +0200663 key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE,
664 key, NULL);
Johannes Berg3b8d9c22013-03-06 22:58:23 +0100665 ieee80211_key_destroy(key, delay_tailroom);
Johannes Berg1f5a7e472007-07-27 15:43:23 +0200666}
667
Johannes Berg3b967662008-04-08 17:56:52 +0200668void ieee80211_enable_keys(struct ieee80211_sub_if_data *sdata)
669{
Johannes Bergad0e2b52010-06-01 10:19:19 +0200670 struct ieee80211_key *key;
Michal Kaziorf9dca802015-05-13 09:16:48 +0000671 struct ieee80211_sub_if_data *vlan;
Johannes Bergad0e2b52010-06-01 10:19:19 +0200672
Johannes Berg3a245762008-04-09 16:45:37 +0200673 ASSERT_RTNL();
Johannes Berg3b967662008-04-08 17:56:52 +0200674
Johannes Berg9607e6b2009-12-23 13:15:31 +0100675 if (WARN_ON(!ieee80211_sdata_running(sdata)))
Johannes Berg3b967662008-04-08 17:56:52 +0200676 return;
677
Johannes Bergad0e2b52010-06-01 10:19:19 +0200678 mutex_lock(&sdata->local->key_mtx);
679
Michal Kaziorf9dca802015-05-13 09:16:48 +0000680 WARN_ON_ONCE(sdata->crypto_tx_tailroom_needed_cnt ||
681 sdata->crypto_tx_tailroom_pending_dec);
682
683 if (sdata->vif.type == NL80211_IFTYPE_AP) {
684 list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list)
685 WARN_ON_ONCE(vlan->crypto_tx_tailroom_needed_cnt ||
686 vlan->crypto_tx_tailroom_pending_dec);
687 }
Yogesh Ashok Powar3bff1862011-06-28 18:41:37 +0530688
689 list_for_each_entry(key, &sdata->key_list, list) {
690 increment_tailroom_need_count(sdata);
Johannes Bergad0e2b52010-06-01 10:19:19 +0200691 ieee80211_key_enable_hw_accel(key);
Yogesh Ashok Powar3bff1862011-06-28 18:41:37 +0530692 }
Johannes Bergad0e2b52010-06-01 10:19:19 +0200693
694 mutex_unlock(&sdata->local->key_mtx);
Johannes Berg3b967662008-04-08 17:56:52 +0200695}
696
Michal Kaziorf9dca802015-05-13 09:16:48 +0000697void ieee80211_reset_crypto_tx_tailroom(struct ieee80211_sub_if_data *sdata)
698{
699 struct ieee80211_sub_if_data *vlan;
700
701 mutex_lock(&sdata->local->key_mtx);
702
703 sdata->crypto_tx_tailroom_needed_cnt = 0;
704
705 if (sdata->vif.type == NL80211_IFTYPE_AP) {
706 list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list)
707 vlan->crypto_tx_tailroom_needed_cnt = 0;
708 }
709
710 mutex_unlock(&sdata->local->key_mtx);
711}
712
Johannes Berg830af022011-07-05 16:35:39 +0200713void ieee80211_iter_keys(struct ieee80211_hw *hw,
714 struct ieee80211_vif *vif,
715 void (*iter)(struct ieee80211_hw *hw,
716 struct ieee80211_vif *vif,
717 struct ieee80211_sta *sta,
718 struct ieee80211_key_conf *key,
719 void *data),
720 void *iter_data)
721{
722 struct ieee80211_local *local = hw_to_local(hw);
Johannes Berg27b3eb92013-08-07 20:11:55 +0200723 struct ieee80211_key *key, *tmp;
Johannes Berg830af022011-07-05 16:35:39 +0200724 struct ieee80211_sub_if_data *sdata;
725
726 ASSERT_RTNL();
727
728 mutex_lock(&local->key_mtx);
729 if (vif) {
730 sdata = vif_to_sdata(vif);
Johannes Berg27b3eb92013-08-07 20:11:55 +0200731 list_for_each_entry_safe(key, tmp, &sdata->key_list, list)
Johannes Berg830af022011-07-05 16:35:39 +0200732 iter(hw, &sdata->vif,
733 key->sta ? &key->sta->sta : NULL,
734 &key->conf, iter_data);
735 } else {
736 list_for_each_entry(sdata, &local->interfaces, list)
Johannes Berg27b3eb92013-08-07 20:11:55 +0200737 list_for_each_entry_safe(key, tmp,
738 &sdata->key_list, list)
Johannes Berg830af022011-07-05 16:35:39 +0200739 iter(hw, &sdata->vif,
740 key->sta ? &key->sta->sta : NULL,
741 &key->conf, iter_data);
742 }
743 mutex_unlock(&local->key_mtx);
744}
745EXPORT_SYMBOL(ieee80211_iter_keys);
746
Johannes Berg7907c7d2013-12-04 23:47:09 +0100747static void ieee80211_free_keys_iface(struct ieee80211_sub_if_data *sdata,
748 struct list_head *keys)
Johannes Berg11a843b2007-08-28 17:01:55 -0400749{
750 struct ieee80211_key *key, *tmp;
Johannes Berg3b967662008-04-08 17:56:52 +0200751
Michal Kaziorf9dca802015-05-13 09:16:48 +0000752 decrease_tailroom_need_count(sdata,
753 sdata->crypto_tx_tailroom_pending_dec);
Johannes Berg8d1f7ec2013-02-23 00:59:03 +0100754 sdata->crypto_tx_tailroom_pending_dec = 0;
755
Jouni Malinen3cfcf6ac2009-01-08 13:32:02 +0200756 ieee80211_debugfs_key_remove_mgmt_default(sdata);
Johannes Berg11a843b2007-08-28 17:01:55 -0400757
Johannes Berg6d10e462013-03-06 23:09:11 +0100758 list_for_each_entry_safe(key, tmp, &sdata->key_list, list) {
759 ieee80211_key_replace(key->sdata, key->sta,
760 key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE,
761 key, NULL);
Johannes Berg7907c7d2013-12-04 23:47:09 +0100762 list_add_tail(&key->list, keys);
Johannes Berg6d10e462013-03-06 23:09:11 +0100763 }
Johannes Berg11a843b2007-08-28 17:01:55 -0400764
Johannes Bergf7e01042010-12-09 19:49:02 +0100765 ieee80211_debugfs_key_update_default(sdata);
Johannes Berg7907c7d2013-12-04 23:47:09 +0100766}
Johannes Bergf7e01042010-12-09 19:49:02 +0100767
Johannes Berg7907c7d2013-12-04 23:47:09 +0100768void ieee80211_free_keys(struct ieee80211_sub_if_data *sdata,
769 bool force_synchronize)
770{
771 struct ieee80211_local *local = sdata->local;
772 struct ieee80211_sub_if_data *vlan;
Michal Kaziorf9dca802015-05-13 09:16:48 +0000773 struct ieee80211_sub_if_data *master;
Johannes Berg7907c7d2013-12-04 23:47:09 +0100774 struct ieee80211_key *key, *tmp;
775 LIST_HEAD(keys);
776
777 cancel_delayed_work_sync(&sdata->dec_tailroom_needed_wk);
778
779 mutex_lock(&local->key_mtx);
780
781 ieee80211_free_keys_iface(sdata, &keys);
782
783 if (sdata->vif.type == NL80211_IFTYPE_AP) {
784 list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list)
785 ieee80211_free_keys_iface(vlan, &keys);
Johannes Berg6d10e462013-03-06 23:09:11 +0100786 }
787
Johannes Berg7907c7d2013-12-04 23:47:09 +0100788 if (!list_empty(&keys) || force_synchronize)
789 synchronize_net();
790 list_for_each_entry_safe(key, tmp, &keys, list)
791 __ieee80211_key_destroy(key, false);
792
Michal Kaziorf9dca802015-05-13 09:16:48 +0000793 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
794 if (sdata->bss) {
795 master = container_of(sdata->bss,
796 struct ieee80211_sub_if_data,
797 u.ap);
798
799 WARN_ON_ONCE(sdata->crypto_tx_tailroom_needed_cnt !=
800 master->crypto_tx_tailroom_needed_cnt);
801 }
802 } else {
803 WARN_ON_ONCE(sdata->crypto_tx_tailroom_needed_cnt ||
804 sdata->crypto_tx_tailroom_pending_dec);
805 }
806
Johannes Berg7907c7d2013-12-04 23:47:09 +0100807 if (sdata->vif.type == NL80211_IFTYPE_AP) {
808 list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list)
809 WARN_ON_ONCE(vlan->crypto_tx_tailroom_needed_cnt ||
810 vlan->crypto_tx_tailroom_pending_dec);
811 }
Johannes Berg8d1f7ec2013-02-23 00:59:03 +0100812
Johannes Berg7907c7d2013-12-04 23:47:09 +0100813 mutex_unlock(&local->key_mtx);
Johannes Berg11a843b2007-08-28 17:01:55 -0400814}
Johannes Bergc68f4b82011-07-05 16:35:41 +0200815
Johannes Berg6d10e462013-03-06 23:09:11 +0100816void ieee80211_free_sta_keys(struct ieee80211_local *local,
817 struct sta_info *sta)
818{
Johannes Bergc8782072013-12-04 23:05:45 +0100819 struct ieee80211_key *key;
Johannes Berg6d10e462013-03-06 23:09:11 +0100820 int i;
821
822 mutex_lock(&local->key_mtx);
Johannes Berg28a9bc62014-12-17 13:55:49 +0100823 for (i = 0; i < ARRAY_SIZE(sta->gtk); i++) {
Johannes Berg6d10e462013-03-06 23:09:11 +0100824 key = key_mtx_dereference(local, sta->gtk[i]);
825 if (!key)
826 continue;
827 ieee80211_key_replace(key->sdata, key->sta,
828 key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE,
829 key, NULL);
Johannes Bergc8782072013-12-04 23:05:45 +0100830 __ieee80211_key_destroy(key, true);
Johannes Berg6d10e462013-03-06 23:09:11 +0100831 }
832
Max Stepanov2475b1cc2013-03-24 14:23:27 +0200833 for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
834 key = key_mtx_dereference(local, sta->ptk[i]);
835 if (!key)
836 continue;
Johannes Berg6d10e462013-03-06 23:09:11 +0100837 ieee80211_key_replace(key->sdata, key->sta,
838 key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE,
839 key, NULL);
Johannes Berg6d10e462013-03-06 23:09:11 +0100840 __ieee80211_key_destroy(key, true);
Johannes Bergc8782072013-12-04 23:05:45 +0100841 }
Johannes Berg6d10e462013-03-06 23:09:11 +0100842
843 mutex_unlock(&local->key_mtx);
844}
845
Johannes Berg8d1f7ec2013-02-23 00:59:03 +0100846void ieee80211_delayed_tailroom_dec(struct work_struct *wk)
847{
848 struct ieee80211_sub_if_data *sdata;
849
850 sdata = container_of(wk, struct ieee80211_sub_if_data,
851 dec_tailroom_needed_wk.work);
852
853 /*
854 * The reason for the delayed tailroom needed decrementing is to
855 * make roaming faster: during roaming, all keys are first deleted
856 * and then new keys are installed. The first new key causes the
857 * crypto_tx_tailroom_needed_cnt to go from 0 to 1, which invokes
858 * the cost of synchronize_net() (which can be slow). Avoid this
859 * by deferring the crypto_tx_tailroom_needed_cnt decrementing on
860 * key removal for a while, so if we roam the value is larger than
861 * zero and no 0->1 transition happens.
862 *
863 * The cost is that if the AP switching was from an AP with keys
864 * to one without, we still allocate tailroom while it would no
865 * longer be needed. However, in the typical (fast) roaming case
866 * within an ESS this usually won't happen.
867 */
868
869 mutex_lock(&sdata->local->key_mtx);
Michal Kaziorf9dca802015-05-13 09:16:48 +0000870 decrease_tailroom_need_count(sdata,
871 sdata->crypto_tx_tailroom_pending_dec);
Johannes Berg8d1f7ec2013-02-23 00:59:03 +0100872 sdata->crypto_tx_tailroom_pending_dec = 0;
873 mutex_unlock(&sdata->local->key_mtx);
874}
Johannes Bergc68f4b82011-07-05 16:35:41 +0200875
876void ieee80211_gtk_rekey_notify(struct ieee80211_vif *vif, const u8 *bssid,
877 const u8 *replay_ctr, gfp_t gfp)
878{
879 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
880
881 trace_api_gtk_rekey_notify(sdata, bssid, replay_ctr);
882
883 cfg80211_gtk_rekey_notify(sdata->dev, bssid, replay_ctr, gfp);
884}
885EXPORT_SYMBOL_GPL(ieee80211_gtk_rekey_notify);
Johannes Berg3ea542d2011-07-07 18:58:00 +0200886
887void ieee80211_get_key_tx_seq(struct ieee80211_key_conf *keyconf,
888 struct ieee80211_key_seq *seq)
889{
890 struct ieee80211_key *key;
891 u64 pn64;
892
893 if (WARN_ON(!(keyconf->flags & IEEE80211_KEY_FLAG_GENERATE_IV)))
894 return;
895
896 key = container_of(keyconf, struct ieee80211_key, conf);
897
898 switch (key->conf.cipher) {
899 case WLAN_CIPHER_SUITE_TKIP:
900 seq->tkip.iv32 = key->u.tkip.tx.iv32;
901 seq->tkip.iv16 = key->u.tkip.tx.iv16;
902 break;
903 case WLAN_CIPHER_SUITE_CCMP:
Jouni Malinen2b2ba0d2015-01-24 19:52:07 +0200904 case WLAN_CIPHER_SUITE_CCMP_256:
Johannes Berg3ea542d2011-07-07 18:58:00 +0200905 case WLAN_CIPHER_SUITE_AES_CMAC:
Jouni Malinen56c52da2015-01-24 19:52:08 +0200906 case WLAN_CIPHER_SUITE_BIP_CMAC_256:
Johannes Bergdb388a52015-06-01 15:36:51 +0200907 BUILD_BUG_ON(offsetof(typeof(*seq), ccmp) !=
908 offsetof(typeof(*seq), aes_cmac));
Jouni Malinen8ade5382015-01-24 19:52:09 +0200909 case WLAN_CIPHER_SUITE_BIP_GMAC_128:
910 case WLAN_CIPHER_SUITE_BIP_GMAC_256:
Johannes Bergdb388a52015-06-01 15:36:51 +0200911 BUILD_BUG_ON(offsetof(typeof(*seq), ccmp) !=
912 offsetof(typeof(*seq), aes_gmac));
913 case WLAN_CIPHER_SUITE_GCMP:
914 case WLAN_CIPHER_SUITE_GCMP_256:
915 BUILD_BUG_ON(offsetof(typeof(*seq), ccmp) !=
916 offsetof(typeof(*seq), gcmp));
917 pn64 = atomic64_read(&key->conf.tx_pn);
Jouni Malinen8ade5382015-01-24 19:52:09 +0200918 seq->ccmp.pn[5] = pn64;
919 seq->ccmp.pn[4] = pn64 >> 8;
920 seq->ccmp.pn[3] = pn64 >> 16;
921 seq->ccmp.pn[2] = pn64 >> 24;
922 seq->ccmp.pn[1] = pn64 >> 32;
923 seq->ccmp.pn[0] = pn64 >> 40;
924 break;
Johannes Berg3ea542d2011-07-07 18:58:00 +0200925 default:
926 WARN_ON(1);
927 }
928}
929EXPORT_SYMBOL(ieee80211_get_key_tx_seq);
930
931void ieee80211_get_key_rx_seq(struct ieee80211_key_conf *keyconf,
932 int tid, struct ieee80211_key_seq *seq)
933{
934 struct ieee80211_key *key;
935 const u8 *pn;
936
937 key = container_of(keyconf, struct ieee80211_key, conf);
938
939 switch (key->conf.cipher) {
940 case WLAN_CIPHER_SUITE_TKIP:
Johannes Berg5a306f52012-11-14 23:22:21 +0100941 if (WARN_ON(tid < 0 || tid >= IEEE80211_NUM_TIDS))
Johannes Berg3ea542d2011-07-07 18:58:00 +0200942 return;
943 seq->tkip.iv32 = key->u.tkip.rx[tid].iv32;
944 seq->tkip.iv16 = key->u.tkip.rx[tid].iv16;
945 break;
946 case WLAN_CIPHER_SUITE_CCMP:
Jouni Malinen2b2ba0d2015-01-24 19:52:07 +0200947 case WLAN_CIPHER_SUITE_CCMP_256:
Johannes Berg5a306f52012-11-14 23:22:21 +0100948 if (WARN_ON(tid < -1 || tid >= IEEE80211_NUM_TIDS))
Johannes Berg3ea542d2011-07-07 18:58:00 +0200949 return;
950 if (tid < 0)
Johannes Berg5a306f52012-11-14 23:22:21 +0100951 pn = key->u.ccmp.rx_pn[IEEE80211_NUM_TIDS];
Johannes Berg3ea542d2011-07-07 18:58:00 +0200952 else
953 pn = key->u.ccmp.rx_pn[tid];
Johannes Berg4325f6c2013-05-08 13:09:08 +0200954 memcpy(seq->ccmp.pn, pn, IEEE80211_CCMP_PN_LEN);
Johannes Berg3ea542d2011-07-07 18:58:00 +0200955 break;
956 case WLAN_CIPHER_SUITE_AES_CMAC:
Jouni Malinen56c52da2015-01-24 19:52:08 +0200957 case WLAN_CIPHER_SUITE_BIP_CMAC_256:
Johannes Berg3ea542d2011-07-07 18:58:00 +0200958 if (WARN_ON(tid != 0))
959 return;
960 pn = key->u.aes_cmac.rx_pn;
Johannes Berg4325f6c2013-05-08 13:09:08 +0200961 memcpy(seq->aes_cmac.pn, pn, IEEE80211_CMAC_PN_LEN);
Johannes Berg3ea542d2011-07-07 18:58:00 +0200962 break;
Jouni Malinen8ade5382015-01-24 19:52:09 +0200963 case WLAN_CIPHER_SUITE_BIP_GMAC_128:
964 case WLAN_CIPHER_SUITE_BIP_GMAC_256:
965 if (WARN_ON(tid != 0))
966 return;
967 pn = key->u.aes_gmac.rx_pn;
968 memcpy(seq->aes_gmac.pn, pn, IEEE80211_GMAC_PN_LEN);
969 break;
Jouni Malinen00b9cfa2015-01-24 19:52:06 +0200970 case WLAN_CIPHER_SUITE_GCMP:
971 case WLAN_CIPHER_SUITE_GCMP_256:
972 if (WARN_ON(tid < -1 || tid >= IEEE80211_NUM_TIDS))
973 return;
974 if (tid < 0)
975 pn = key->u.gcmp.rx_pn[IEEE80211_NUM_TIDS];
976 else
977 pn = key->u.gcmp.rx_pn[tid];
978 memcpy(seq->gcmp.pn, pn, IEEE80211_GCMP_PN_LEN);
979 break;
Johannes Berg3ea542d2011-07-07 18:58:00 +0200980 }
981}
982EXPORT_SYMBOL(ieee80211_get_key_rx_seq);
Johannes Berg27b3eb92013-08-07 20:11:55 +0200983
984void ieee80211_set_key_tx_seq(struct ieee80211_key_conf *keyconf,
985 struct ieee80211_key_seq *seq)
986{
987 struct ieee80211_key *key;
988 u64 pn64;
989
990 key = container_of(keyconf, struct ieee80211_key, conf);
991
992 switch (key->conf.cipher) {
993 case WLAN_CIPHER_SUITE_TKIP:
994 key->u.tkip.tx.iv32 = seq->tkip.iv32;
995 key->u.tkip.tx.iv16 = seq->tkip.iv16;
996 break;
997 case WLAN_CIPHER_SUITE_CCMP:
Jouni Malinen2b2ba0d2015-01-24 19:52:07 +0200998 case WLAN_CIPHER_SUITE_CCMP_256:
Johannes Bergdb388a52015-06-01 15:36:51 +0200999 case WLAN_CIPHER_SUITE_AES_CMAC:
1000 case WLAN_CIPHER_SUITE_BIP_CMAC_256:
1001 BUILD_BUG_ON(offsetof(typeof(*seq), ccmp) !=
1002 offsetof(typeof(*seq), aes_cmac));
1003 case WLAN_CIPHER_SUITE_BIP_GMAC_128:
1004 case WLAN_CIPHER_SUITE_BIP_GMAC_256:
1005 BUILD_BUG_ON(offsetof(typeof(*seq), ccmp) !=
1006 offsetof(typeof(*seq), aes_gmac));
1007 case WLAN_CIPHER_SUITE_GCMP:
1008 case WLAN_CIPHER_SUITE_GCMP_256:
1009 BUILD_BUG_ON(offsetof(typeof(*seq), ccmp) !=
1010 offsetof(typeof(*seq), gcmp));
Johannes Berg27b3eb92013-08-07 20:11:55 +02001011 pn64 = (u64)seq->ccmp.pn[5] |
1012 ((u64)seq->ccmp.pn[4] << 8) |
1013 ((u64)seq->ccmp.pn[3] << 16) |
1014 ((u64)seq->ccmp.pn[2] << 24) |
1015 ((u64)seq->ccmp.pn[1] << 32) |
1016 ((u64)seq->ccmp.pn[0] << 40);
Johannes Bergdb388a52015-06-01 15:36:51 +02001017 atomic64_set(&key->conf.tx_pn, pn64);
Jouni Malinen00b9cfa2015-01-24 19:52:06 +02001018 break;
Johannes Berg27b3eb92013-08-07 20:11:55 +02001019 default:
1020 WARN_ON(1);
1021 break;
1022 }
1023}
1024EXPORT_SYMBOL_GPL(ieee80211_set_key_tx_seq);
1025
1026void ieee80211_set_key_rx_seq(struct ieee80211_key_conf *keyconf,
1027 int tid, struct ieee80211_key_seq *seq)
1028{
1029 struct ieee80211_key *key;
1030 u8 *pn;
1031
1032 key = container_of(keyconf, struct ieee80211_key, conf);
1033
1034 switch (key->conf.cipher) {
1035 case WLAN_CIPHER_SUITE_TKIP:
1036 if (WARN_ON(tid < 0 || tid >= IEEE80211_NUM_TIDS))
1037 return;
1038 key->u.tkip.rx[tid].iv32 = seq->tkip.iv32;
1039 key->u.tkip.rx[tid].iv16 = seq->tkip.iv16;
1040 break;
1041 case WLAN_CIPHER_SUITE_CCMP:
Jouni Malinen2b2ba0d2015-01-24 19:52:07 +02001042 case WLAN_CIPHER_SUITE_CCMP_256:
Johannes Berg27b3eb92013-08-07 20:11:55 +02001043 if (WARN_ON(tid < -1 || tid >= IEEE80211_NUM_TIDS))
1044 return;
1045 if (tid < 0)
1046 pn = key->u.ccmp.rx_pn[IEEE80211_NUM_TIDS];
1047 else
1048 pn = key->u.ccmp.rx_pn[tid];
1049 memcpy(pn, seq->ccmp.pn, IEEE80211_CCMP_PN_LEN);
1050 break;
1051 case WLAN_CIPHER_SUITE_AES_CMAC:
Jouni Malinen56c52da2015-01-24 19:52:08 +02001052 case WLAN_CIPHER_SUITE_BIP_CMAC_256:
Johannes Berg27b3eb92013-08-07 20:11:55 +02001053 if (WARN_ON(tid != 0))
1054 return;
1055 pn = key->u.aes_cmac.rx_pn;
1056 memcpy(pn, seq->aes_cmac.pn, IEEE80211_CMAC_PN_LEN);
1057 break;
Jouni Malinen8ade5382015-01-24 19:52:09 +02001058 case WLAN_CIPHER_SUITE_BIP_GMAC_128:
1059 case WLAN_CIPHER_SUITE_BIP_GMAC_256:
1060 if (WARN_ON(tid != 0))
1061 return;
1062 pn = key->u.aes_gmac.rx_pn;
1063 memcpy(pn, seq->aes_gmac.pn, IEEE80211_GMAC_PN_LEN);
1064 break;
Jouni Malinen00b9cfa2015-01-24 19:52:06 +02001065 case WLAN_CIPHER_SUITE_GCMP:
1066 case WLAN_CIPHER_SUITE_GCMP_256:
1067 if (WARN_ON(tid < -1 || tid >= IEEE80211_NUM_TIDS))
1068 return;
1069 if (tid < 0)
1070 pn = key->u.gcmp.rx_pn[IEEE80211_NUM_TIDS];
1071 else
1072 pn = key->u.gcmp.rx_pn[tid];
1073 memcpy(pn, seq->gcmp.pn, IEEE80211_GCMP_PN_LEN);
1074 break;
Johannes Berg27b3eb92013-08-07 20:11:55 +02001075 default:
1076 WARN_ON(1);
1077 break;
1078 }
1079}
1080EXPORT_SYMBOL_GPL(ieee80211_set_key_rx_seq);
1081
1082void ieee80211_remove_key(struct ieee80211_key_conf *keyconf)
1083{
1084 struct ieee80211_key *key;
1085
1086 key = container_of(keyconf, struct ieee80211_key, conf);
1087
1088 assert_key_lock(key->local);
1089
1090 /*
1091 * if key was uploaded, we assume the driver will/has remove(d)
1092 * it, so adjust bookkeeping accordingly
1093 */
1094 if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE) {
1095 key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE;
1096
Johannes Berg1e359a52015-01-05 10:28:49 +01001097 if (!((key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_MMIC) ||
Ido Yarivdb128472015-01-06 08:39:02 -05001098 (key->conf.flags & IEEE80211_KEY_FLAG_RESERVE_TAILROOM)))
Johannes Berg27b3eb92013-08-07 20:11:55 +02001099 increment_tailroom_need_count(key->sdata);
1100 }
1101
1102 ieee80211_key_free(key, false);
1103}
1104EXPORT_SYMBOL_GPL(ieee80211_remove_key);
1105
1106struct ieee80211_key_conf *
1107ieee80211_gtk_rekey_add(struct ieee80211_vif *vif,
1108 struct ieee80211_key_conf *keyconf)
1109{
1110 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
1111 struct ieee80211_local *local = sdata->local;
1112 struct ieee80211_key *key;
1113 int err;
1114
1115 if (WARN_ON(!local->wowlan))
1116 return ERR_PTR(-EINVAL);
1117
1118 if (WARN_ON(vif->type != NL80211_IFTYPE_STATION))
1119 return ERR_PTR(-EINVAL);
1120
1121 key = ieee80211_key_alloc(keyconf->cipher, keyconf->keyidx,
1122 keyconf->keylen, keyconf->key,
Max Stepanov2475b1cc2013-03-24 14:23:27 +02001123 0, NULL, NULL);
Johannes Berg27b3eb92013-08-07 20:11:55 +02001124 if (IS_ERR(key))
Johannes Bergc5dc1642013-08-28 19:03:36 +02001125 return ERR_CAST(key);
Johannes Berg27b3eb92013-08-07 20:11:55 +02001126
1127 if (sdata->u.mgd.mfp != IEEE80211_MFP_DISABLED)
1128 key->conf.flags |= IEEE80211_KEY_FLAG_RX_MGMT;
1129
1130 err = ieee80211_key_link(key, sdata, NULL);
1131 if (err)
1132 return ERR_PTR(err);
1133
1134 return &key->conf;
1135}
1136EXPORT_SYMBOL_GPL(ieee80211_gtk_rekey_add);