Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * Copyright 2002-2005, Instant802 Networks, Inc.
4 : : * Copyright 2005-2006, Devicescape Software, Inc.
5 : : * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
6 : : * Copyright 2007-2008 Johannes Berg <johannes@sipsolutions.net>
7 : : * Copyright 2013-2014 Intel Mobile Communications GmbH
8 : : * Copyright 2015-2017 Intel Deutschland GmbH
9 : : * Copyright 2018-2020 Intel Corporation
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 <linux/export.h>
19 : : #include <net/mac80211.h>
20 : : #include <crypto/algapi.h>
21 : : #include <asm/unaligned.h>
22 : : #include "ieee80211_i.h"
23 : : #include "driver-ops.h"
24 : : #include "debugfs_key.h"
25 : : #include "aes_ccm.h"
26 : : #include "aes_cmac.h"
27 : : #include "aes_gmac.h"
28 : : #include "aes_gcm.h"
29 : :
30 : :
31 : : /**
32 : : * DOC: Key handling basics
33 : : *
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 : : *
38 : : * 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.
45 : : *
46 : : * 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.
52 : : */
53 : :
54 : : static const u8 bcast_addr[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
55 : :
56 : 0 : static void assert_key_lock(struct ieee80211_local *local)
57 : : {
58 : 0 : lockdep_assert_held(&local->key_mtx);
59 : : }
60 : :
61 : : static void
62 : 0 : update_vlan_tailroom_need_count(struct ieee80211_sub_if_data *sdata, int delta)
63 : : {
64 : 0 : struct ieee80211_sub_if_data *vlan;
65 : :
66 : 0 : if (sdata->vif.type != NL80211_IFTYPE_AP)
67 : : return;
68 : :
69 : : /* crypto_tx_tailroom_needed_cnt is protected by this */
70 : 0 : assert_key_lock(sdata->local);
71 : :
72 : 0 : rcu_read_lock();
73 : :
74 [ # # # # ]: 0 : list_for_each_entry_rcu(vlan, &sdata->u.ap.vlans, u.vlan.list)
75 : 0 : vlan->crypto_tx_tailroom_needed_cnt += delta;
76 : :
77 : 0 : rcu_read_unlock();
78 : : }
79 : :
80 : 0 : static 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 : :
101 : 0 : assert_key_lock(sdata->local);
102 : :
103 [ # # ]: 0 : update_vlan_tailroom_need_count(sdata, 1);
104 : :
105 [ # # ]: 0 : 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 : 0 : synchronize_net();
111 : : }
112 : 0 : }
113 : :
114 : 0 : static void decrease_tailroom_need_count(struct ieee80211_sub_if_data *sdata,
115 : : int delta)
116 : : {
117 : 0 : assert_key_lock(sdata->local);
118 : :
119 [ # # ]: 0 : WARN_ON_ONCE(sdata->crypto_tx_tailroom_needed_cnt < delta);
120 : :
121 [ # # ]: 0 : update_vlan_tailroom_need_count(sdata, -delta);
122 : 0 : sdata->crypto_tx_tailroom_needed_cnt -= delta;
123 : 0 : }
124 : :
125 : 0 : static int ieee80211_key_enable_hw_accel(struct ieee80211_key *key)
126 : : {
127 : 0 : struct ieee80211_sub_if_data *sdata = key->sdata;
128 : 0 : struct sta_info *sta;
129 : 0 : int ret = -EOPNOTSUPP;
130 : :
131 : 0 : might_sleep();
132 : :
133 [ # # ]: 0 : 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 [ # # ]: 0 : if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE &&
142 [ # # ]: 0 : !(key->conf.flags & (IEEE80211_KEY_FLAG_GENERATE_MMIC |
143 : : IEEE80211_KEY_FLAG_PUT_MIC_SPACE |
144 : : IEEE80211_KEY_FLAG_RESERVE_TAILROOM)))
145 : 0 : increment_tailroom_need_count(sdata);
146 : :
147 : 0 : key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE;
148 : 0 : return -EINVAL;
149 : : }
150 : :
151 [ # # ]: 0 : if (!key->local->ops->set_key)
152 : 0 : goto out_unsupported;
153 : :
154 : 0 : assert_key_lock(key->local);
155 : :
156 : 0 : sta = key->sta;
157 : :
158 : : /*
159 : : * If this is a per-STA GTK, check if it
160 : : * is supported; if not, return.
161 : : */
162 [ # # # # : 0 : if (sta && !(key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE) &&
# # ]
163 : : !ieee80211_hw_check(&key->local->hw, SUPPORTS_PER_STA_GTK))
164 : 0 : goto out_unsupported;
165 : :
166 [ # # # # ]: 0 : if (sta && !sta->uploaded)
167 : 0 : goto out_unsupported;
168 : :
169 [ # # ]: 0 : if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
170 : : /*
171 : : * The driver doesn't know anything about VLAN interfaces.
172 : : * Hence, don't send GTKs for VLAN interfaces to the driver.
173 : : */
174 [ # # ]: 0 : if (!(key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
175 : 0 : ret = 1;
176 : 0 : goto out_unsupported;
177 : : }
178 : : }
179 : :
180 [ # # ]: 0 : ret = drv_set_key(key->local, SET_KEY, sdata,
181 : : sta ? &sta->sta : NULL, &key->conf);
182 : :
183 [ # # ]: 0 : if (!ret) {
184 : 0 : key->flags |= KEY_FLAG_UPLOADED_TO_HARDWARE;
185 : :
186 [ # # ]: 0 : if (!(key->conf.flags & (IEEE80211_KEY_FLAG_GENERATE_MMIC |
187 : : IEEE80211_KEY_FLAG_PUT_MIC_SPACE |
188 : : IEEE80211_KEY_FLAG_RESERVE_TAILROOM)))
189 : 0 : decrease_tailroom_need_count(sdata, 1);
190 : :
191 [ # # ]: 0 : WARN_ON((key->conf.flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE) &&
192 : : (key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_IV));
193 : :
194 [ # # ]: 0 : WARN_ON((key->conf.flags & IEEE80211_KEY_FLAG_PUT_MIC_SPACE) &&
195 : : (key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_MMIC));
196 : :
197 : : return 0;
198 : : }
199 : :
200 [ # # # # ]: 0 : if (ret != -ENOSPC && ret != -EOPNOTSUPP && ret != 1)
201 [ # # ]: 0 : sdata_err(sdata,
202 : : "failed to set key (%d, %pM) to hardware (%d)\n",
203 : : key->conf.keyidx,
204 : : sta ? sta->sta.addr : bcast_addr, ret);
205 : :
206 : 0 : out_unsupported:
207 [ # # ]: 0 : switch (key->conf.cipher) {
208 : 0 : case WLAN_CIPHER_SUITE_WEP40:
209 : : case WLAN_CIPHER_SUITE_WEP104:
210 : : case WLAN_CIPHER_SUITE_TKIP:
211 : : case WLAN_CIPHER_SUITE_CCMP:
212 : : case WLAN_CIPHER_SUITE_CCMP_256:
213 : : case WLAN_CIPHER_SUITE_AES_CMAC:
214 : : case WLAN_CIPHER_SUITE_BIP_CMAC_256:
215 : : case WLAN_CIPHER_SUITE_BIP_GMAC_128:
216 : : case WLAN_CIPHER_SUITE_BIP_GMAC_256:
217 : : case WLAN_CIPHER_SUITE_GCMP:
218 : : case WLAN_CIPHER_SUITE_GCMP_256:
219 : : /* all of these we can do in software - if driver can */
220 [ # # ]: 0 : if (ret == 1)
221 : : return 0;
222 [ # # ]: 0 : if (ieee80211_hw_check(&key->local->hw, SW_CRYPTO_CONTROL))
223 : 0 : return -EINVAL;
224 : : return 0;
225 : : default:
226 : : return -EINVAL;
227 : : }
228 : : }
229 : :
230 : 0 : static void ieee80211_key_disable_hw_accel(struct ieee80211_key *key)
231 : : {
232 : 0 : struct ieee80211_sub_if_data *sdata;
233 : 0 : struct sta_info *sta;
234 : 0 : int ret;
235 : :
236 : 0 : might_sleep();
237 : :
238 [ # # # # ]: 0 : if (!key || !key->local->ops->set_key)
239 : : return;
240 : :
241 : 0 : assert_key_lock(key->local);
242 : :
243 [ # # ]: 0 : if (!(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
244 : : return;
245 : :
246 : 0 : sta = key->sta;
247 : 0 : sdata = key->sdata;
248 : :
249 [ # # ]: 0 : if (!(key->conf.flags & (IEEE80211_KEY_FLAG_GENERATE_MMIC |
250 : : IEEE80211_KEY_FLAG_PUT_MIC_SPACE |
251 : : IEEE80211_KEY_FLAG_RESERVE_TAILROOM)))
252 : 0 : increment_tailroom_need_count(sdata);
253 : :
254 : 0 : key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE;
255 [ # # ]: 0 : ret = drv_set_key(key->local, DISABLE_KEY, sdata,
256 : : sta ? &sta->sta : NULL, &key->conf);
257 : :
258 [ # # ]: 0 : if (ret)
259 [ # # ]: 0 : sdata_err(sdata,
260 : : "failed to remove key (%d, %pM) from hardware (%d)\n",
261 : : key->conf.keyidx,
262 : : sta ? sta->sta.addr : bcast_addr, ret);
263 : : }
264 : :
265 : 0 : static int _ieee80211_set_tx_key(struct ieee80211_key *key, bool force)
266 : : {
267 : 0 : struct sta_info *sta = key->sta;
268 : 0 : struct ieee80211_local *local = key->local;
269 : :
270 : 0 : assert_key_lock(local);
271 : :
272 : 0 : set_sta_flag(sta, WLAN_STA_USES_ENCRYPTION);
273 : :
274 : 0 : sta->ptk_idx = key->conf.keyidx;
275 : :
276 [ # # # # ]: 0 : if (force || !ieee80211_hw_check(&local->hw, AMPDU_KEYBORDER_SUPPORT))
277 : 0 : clear_sta_flag(sta, WLAN_STA_BLOCK_BA);
278 : 0 : ieee80211_check_fast_xmit(sta);
279 : :
280 : 0 : return 0;
281 : : }
282 : :
283 : 0 : int ieee80211_set_tx_key(struct ieee80211_key *key)
284 : : {
285 : 0 : return _ieee80211_set_tx_key(key, false);
286 : : }
287 : :
288 : 0 : static void ieee80211_pairwise_rekey(struct ieee80211_key *old,
289 : : struct ieee80211_key *new)
290 : : {
291 : 0 : struct ieee80211_local *local = new->local;
292 : 0 : struct sta_info *sta = new->sta;
293 : 0 : int i;
294 : :
295 : 0 : assert_key_lock(local);
296 : :
297 [ # # ]: 0 : if (new->conf.flags & IEEE80211_KEY_FLAG_NO_AUTO_TX) {
298 : : /* Extended Key ID key install, initial one or rekey */
299 : :
300 [ # # # # ]: 0 : if (sta->ptk_idx != INVALID_PTK_KEYIDX &&
301 : : !ieee80211_hw_check(&local->hw, AMPDU_KEYBORDER_SUPPORT)) {
302 : : /* Aggregation Sessions with Extended Key ID must not
303 : : * mix MPDUs with different keyIDs within one A-MPDU.
304 : : * Tear down running Tx aggregation sessions and block
305 : : * new Rx/Tx aggregation requests during rekey to
306 : : * ensure there are no A-MPDUs when the driver is not
307 : : * supporting A-MPDU key borders. (Blocking Tx only
308 : : * would be sufficient but WLAN_STA_BLOCK_BA gets the
309 : : * job done for the few ms we need it.)
310 : : */
311 : 0 : set_sta_flag(sta, WLAN_STA_BLOCK_BA);
312 : 0 : mutex_lock(&sta->ampdu_mlme.mtx);
313 [ # # ]: 0 : for (i = 0; i < IEEE80211_NUM_TIDS; i++)
314 : 0 : ___ieee80211_stop_tx_ba_session(sta, i,
315 : : AGG_STOP_LOCAL_REQUEST);
316 : 0 : mutex_unlock(&sta->ampdu_mlme.mtx);
317 : : }
318 [ # # ]: 0 : } else if (old) {
319 : : /* Rekey without Extended Key ID.
320 : : * Aggregation sessions are OK when running on SW crypto.
321 : : * A broken remote STA may cause issues not observed with HW
322 : : * crypto, though.
323 : : */
324 [ # # ]: 0 : if (!(old->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
325 : : return;
326 : :
327 : : /* Stop Tx till we are on the new key */
328 : 0 : old->flags |= KEY_FLAG_TAINTED;
329 : 0 : ieee80211_clear_fast_xmit(sta);
330 [ # # ]: 0 : if (ieee80211_hw_check(&local->hw, AMPDU_AGGREGATION)) {
331 : 0 : set_sta_flag(sta, WLAN_STA_BLOCK_BA);
332 : 0 : ieee80211_sta_tear_down_BA_sessions(sta,
333 : : AGG_STOP_LOCAL_REQUEST);
334 : : }
335 [ # # ]: 0 : if (!wiphy_ext_feature_isset(local->hw.wiphy,
336 : : NL80211_EXT_FEATURE_CAN_REPLACE_PTK0)) {
337 [ # # ]: 0 : pr_warn_ratelimited("Rekeying PTK for STA %pM but driver can't safely do that.",
338 : : sta->sta.addr);
339 : : /* Flushing the driver queues *may* help prevent
340 : : * the clear text leaks and freezes.
341 : : */
342 : 0 : ieee80211_flush_queues(local, old->sdata, false);
343 : : }
344 : : }
345 : : }
346 : :
347 : 0 : static void __ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata,
348 : : int idx, bool uni, bool multi)
349 : : {
350 : 0 : struct ieee80211_key *key = NULL;
351 : :
352 : 0 : assert_key_lock(sdata->local);
353 : :
354 [ # # ]: 0 : if (idx >= 0 && idx < NUM_DEFAULT_KEYS)
355 : 0 : key = key_mtx_dereference(sdata->local, sdata->keys[idx]);
356 : :
357 [ # # ]: 0 : if (uni) {
358 : 0 : rcu_assign_pointer(sdata->default_unicast_key, key);
359 : 0 : ieee80211_check_fast_xmit_iface(sdata);
360 [ # # ]: 0 : if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN)
361 : 0 : drv_set_default_unicast_key(sdata->local, sdata, idx);
362 : : }
363 : :
364 [ # # ]: 0 : if (multi)
365 : 0 : rcu_assign_pointer(sdata->default_multicast_key, key);
366 : :
367 : 0 : ieee80211_debugfs_key_update_default(sdata);
368 : 0 : }
369 : :
370 : 0 : void ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata, int idx,
371 : : bool uni, bool multi)
372 : : {
373 : 0 : mutex_lock(&sdata->local->key_mtx);
374 : 0 : __ieee80211_set_default_key(sdata, idx, uni, multi);
375 : 0 : mutex_unlock(&sdata->local->key_mtx);
376 : 0 : }
377 : :
378 : : static void
379 : 0 : __ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata, int idx)
380 : : {
381 : 0 : struct ieee80211_key *key = NULL;
382 : :
383 : 0 : assert_key_lock(sdata->local);
384 : :
385 : 0 : if (idx >= NUM_DEFAULT_KEYS &&
386 : : idx < NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS)
387 : 0 : key = key_mtx_dereference(sdata->local, sdata->keys[idx]);
388 : :
389 : 0 : rcu_assign_pointer(sdata->default_mgmt_key, key);
390 : :
391 : 0 : ieee80211_debugfs_key_update_default(sdata);
392 : 0 : }
393 : :
394 : 0 : void ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata,
395 : : int idx)
396 : : {
397 : 0 : mutex_lock(&sdata->local->key_mtx);
398 [ # # ]: 0 : __ieee80211_set_default_mgmt_key(sdata, idx);
399 : 0 : mutex_unlock(&sdata->local->key_mtx);
400 : 0 : }
401 : :
402 : 0 : static int ieee80211_key_replace(struct ieee80211_sub_if_data *sdata,
403 : : struct sta_info *sta,
404 : : bool pairwise,
405 : : struct ieee80211_key *old,
406 : : struct ieee80211_key *new)
407 : : {
408 : 0 : int idx;
409 : 0 : int ret = 0;
410 : 0 : bool defunikey, defmultikey, defmgmtkey;
411 : :
412 : : /* caller must provide at least one old/new */
413 [ # # # # ]: 0 : if (WARN_ON(!new && !old))
414 : : return 0;
415 : :
416 [ # # ]: 0 : if (new)
417 : 0 : list_add_tail_rcu(&new->list, &sdata->key_list);
418 : :
419 [ # # # # : 0 : WARN_ON(new && old && new->conf.keyidx != old->conf.keyidx);
# # ]
420 : :
421 [ # # # # ]: 0 : if (new && sta && pairwise) {
422 : : /* Unicast rekey needs special handling. With Extended Key ID
423 : : * old is still NULL for the first rekey.
424 : : */
425 : 0 : ieee80211_pairwise_rekey(old, new);
426 : : }
427 : :
428 [ # # ]: 0 : if (old) {
429 : 0 : idx = old->conf.keyidx;
430 : :
431 [ # # ]: 0 : if (old->flags & KEY_FLAG_UPLOADED_TO_HARDWARE) {
432 : 0 : ieee80211_key_disable_hw_accel(old);
433 : :
434 [ # # ]: 0 : if (new)
435 : 0 : ret = ieee80211_key_enable_hw_accel(new);
436 : : }
437 : : } else {
438 : : /* new must be provided in case old is not */
439 : 0 : idx = new->conf.keyidx;
440 [ # # ]: 0 : if (!new->local->wowlan)
441 : 0 : ret = ieee80211_key_enable_hw_accel(new);
442 : : }
443 : :
444 [ # # ]: 0 : if (ret)
445 : : return ret;
446 : :
447 [ # # ]: 0 : if (sta) {
448 [ # # ]: 0 : if (pairwise) {
449 [ # # ]: 0 : rcu_assign_pointer(sta->ptk[idx], new);
450 [ # # ]: 0 : if (new &&
451 [ # # ]: 0 : !(new->conf.flags & IEEE80211_KEY_FLAG_NO_AUTO_TX))
452 : 0 : _ieee80211_set_tx_key(new, true);
453 : : } else {
454 : 0 : rcu_assign_pointer(sta->gtk[idx], new);
455 : : }
456 : : /* Only needed for transition from no key -> key.
457 : : * Still triggers unnecessary when using Extended Key ID
458 : : * and installing the second key ID the first time.
459 : : */
460 [ # # ]: 0 : if (new && !old)
461 : 0 : ieee80211_check_fast_rx(sta);
462 : : } else {
463 [ # # ]: 0 : defunikey = old &&
464 [ # # ]: 0 : old == key_mtx_dereference(sdata->local,
465 : : sdata->default_unicast_key);
466 [ # # ]: 0 : defmultikey = old &&
467 [ # # ]: 0 : old == key_mtx_dereference(sdata->local,
468 : : sdata->default_multicast_key);
469 [ # # ]: 0 : defmgmtkey = old &&
470 [ # # ]: 0 : old == key_mtx_dereference(sdata->local,
471 : : sdata->default_mgmt_key);
472 : :
473 [ # # ]: 0 : if (defunikey && !new)
474 : 0 : __ieee80211_set_default_key(sdata, -1, true, false);
475 [ # # ]: 0 : if (defmultikey && !new)
476 : 0 : __ieee80211_set_default_key(sdata, -1, false, true);
477 [ # # ]: 0 : if (defmgmtkey && !new)
478 : 0 : __ieee80211_set_default_mgmt_key(sdata, -1);
479 : :
480 [ # # ]: 0 : rcu_assign_pointer(sdata->keys[idx], new);
481 [ # # ]: 0 : if (defunikey && new)
482 : 0 : __ieee80211_set_default_key(sdata, new->conf.keyidx,
483 : : true, false);
484 [ # # ]: 0 : if (defmultikey && new)
485 : 0 : __ieee80211_set_default_key(sdata, new->conf.keyidx,
486 : : false, true);
487 [ # # ]: 0 : if (defmgmtkey && new)
488 : 0 : __ieee80211_set_default_mgmt_key(sdata,
489 [ # # ]: 0 : new->conf.keyidx);
490 : : }
491 : :
492 [ # # ]: 0 : if (old)
493 : 0 : list_del_rcu(&old->list);
494 : :
495 : : return 0;
496 : : }
497 : :
498 : : struct ieee80211_key *
499 : 0 : ieee80211_key_alloc(u32 cipher, int idx, size_t key_len,
500 : : const u8 *key_data,
501 : : size_t seq_len, const u8 *seq,
502 : : const struct ieee80211_cipher_scheme *cs)
503 : : {
504 : 0 : struct ieee80211_key *key;
505 : 0 : int i, j, err;
506 : :
507 [ # # # # ]: 0 : if (WARN_ON(idx < 0 || idx >= NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS))
508 : : return ERR_PTR(-EINVAL);
509 : :
510 : 0 : key = kzalloc(sizeof(struct ieee80211_key) + key_len, GFP_KERNEL);
511 [ # # ]: 0 : if (!key)
512 : : return ERR_PTR(-ENOMEM);
513 : :
514 : : /*
515 : : * Default to software encryption; we'll later upload the
516 : : * key to the hardware if possible.
517 : : */
518 : 0 : key->conf.flags = 0;
519 : 0 : key->flags = 0;
520 : :
521 : 0 : key->conf.cipher = cipher;
522 : 0 : key->conf.keyidx = idx;
523 : 0 : key->conf.keylen = key_len;
524 [ # # # # : 0 : switch (cipher) {
# # # # ]
525 : 0 : case WLAN_CIPHER_SUITE_WEP40:
526 : : case WLAN_CIPHER_SUITE_WEP104:
527 : 0 : key->conf.iv_len = IEEE80211_WEP_IV_LEN;
528 : 0 : key->conf.icv_len = IEEE80211_WEP_ICV_LEN;
529 : 0 : break;
530 : 0 : case WLAN_CIPHER_SUITE_TKIP:
531 : 0 : key->conf.iv_len = IEEE80211_TKIP_IV_LEN;
532 : 0 : key->conf.icv_len = IEEE80211_TKIP_ICV_LEN;
533 [ # # ]: 0 : if (seq) {
534 [ # # ]: 0 : for (i = 0; i < IEEE80211_NUM_TIDS; i++) {
535 : 0 : key->u.tkip.rx[i].iv32 =
536 : : get_unaligned_le32(&seq[2]);
537 : 0 : key->u.tkip.rx[i].iv16 =
538 : : get_unaligned_le16(seq);
539 : : }
540 : : }
541 : 0 : spin_lock_init(&key->u.tkip.txlock);
542 : 0 : break;
543 : 0 : case WLAN_CIPHER_SUITE_CCMP:
544 : 0 : key->conf.iv_len = IEEE80211_CCMP_HDR_LEN;
545 : 0 : key->conf.icv_len = IEEE80211_CCMP_MIC_LEN;
546 [ # # ]: 0 : if (seq) {
547 [ # # ]: 0 : for (i = 0; i < IEEE80211_NUM_TIDS + 1; i++)
548 [ # # ]: 0 : for (j = 0; j < IEEE80211_CCMP_PN_LEN; j++)
549 : 0 : key->u.ccmp.rx_pn[i][j] =
550 : 0 : seq[IEEE80211_CCMP_PN_LEN - j - 1];
551 : : }
552 : : /*
553 : : * Initialize AES key state here as an optimization so that
554 : : * it does not need to be initialized for every packet.
555 : : */
556 : 0 : key->u.ccmp.tfm = ieee80211_aes_key_setup_encrypt(
557 : : key_data, key_len, IEEE80211_CCMP_MIC_LEN);
558 [ # # ]: 0 : if (IS_ERR(key->u.ccmp.tfm)) {
559 : 0 : err = PTR_ERR(key->u.ccmp.tfm);
560 : 0 : kfree(key);
561 : 0 : return ERR_PTR(err);
562 : : }
563 : : break;
564 : 0 : case WLAN_CIPHER_SUITE_CCMP_256:
565 : 0 : key->conf.iv_len = IEEE80211_CCMP_256_HDR_LEN;
566 : 0 : key->conf.icv_len = IEEE80211_CCMP_256_MIC_LEN;
567 [ # # ]: 0 : for (i = 0; seq && i < IEEE80211_NUM_TIDS + 1; i++)
568 [ # # ]: 0 : for (j = 0; j < IEEE80211_CCMP_256_PN_LEN; j++)
569 : 0 : key->u.ccmp.rx_pn[i][j] =
570 : 0 : seq[IEEE80211_CCMP_256_PN_LEN - j - 1];
571 : : /* Initialize AES key state here as an optimization so that
572 : : * it does not need to be initialized for every packet.
573 : : */
574 : 0 : key->u.ccmp.tfm = ieee80211_aes_key_setup_encrypt(
575 : : key_data, key_len, IEEE80211_CCMP_256_MIC_LEN);
576 [ # # ]: 0 : if (IS_ERR(key->u.ccmp.tfm)) {
577 : 0 : err = PTR_ERR(key->u.ccmp.tfm);
578 : 0 : kfree(key);
579 : 0 : return ERR_PTR(err);
580 : : }
581 : : break;
582 : 0 : case WLAN_CIPHER_SUITE_AES_CMAC:
583 : : case WLAN_CIPHER_SUITE_BIP_CMAC_256:
584 : 0 : key->conf.iv_len = 0;
585 [ # # ]: 0 : if (cipher == WLAN_CIPHER_SUITE_AES_CMAC)
586 : 0 : key->conf.icv_len = sizeof(struct ieee80211_mmie);
587 : : else
588 : 0 : key->conf.icv_len = sizeof(struct ieee80211_mmie_16);
589 [ # # ]: 0 : if (seq)
590 [ # # ]: 0 : for (j = 0; j < IEEE80211_CMAC_PN_LEN; j++)
591 : 0 : key->u.aes_cmac.rx_pn[j] =
592 : 0 : seq[IEEE80211_CMAC_PN_LEN - j - 1];
593 : : /*
594 : : * Initialize AES key state here as an optimization so that
595 : : * it does not need to be initialized for every packet.
596 : : */
597 : 0 : key->u.aes_cmac.tfm =
598 : 0 : ieee80211_aes_cmac_key_setup(key_data, key_len);
599 [ # # ]: 0 : if (IS_ERR(key->u.aes_cmac.tfm)) {
600 : 0 : err = PTR_ERR(key->u.aes_cmac.tfm);
601 : 0 : kfree(key);
602 : 0 : return ERR_PTR(err);
603 : : }
604 : : break;
605 : 0 : case WLAN_CIPHER_SUITE_BIP_GMAC_128:
606 : : case WLAN_CIPHER_SUITE_BIP_GMAC_256:
607 : 0 : key->conf.iv_len = 0;
608 : 0 : key->conf.icv_len = sizeof(struct ieee80211_mmie_16);
609 [ # # ]: 0 : if (seq)
610 [ # # ]: 0 : for (j = 0; j < IEEE80211_GMAC_PN_LEN; j++)
611 : 0 : key->u.aes_gmac.rx_pn[j] =
612 : 0 : seq[IEEE80211_GMAC_PN_LEN - j - 1];
613 : : /* Initialize AES key state here as an optimization so that
614 : : * it does not need to be initialized for every packet.
615 : : */
616 : 0 : key->u.aes_gmac.tfm =
617 : 0 : ieee80211_aes_gmac_key_setup(key_data, key_len);
618 [ # # ]: 0 : if (IS_ERR(key->u.aes_gmac.tfm)) {
619 : 0 : err = PTR_ERR(key->u.aes_gmac.tfm);
620 : 0 : kfree(key);
621 : 0 : return ERR_PTR(err);
622 : : }
623 : : break;
624 : 0 : case WLAN_CIPHER_SUITE_GCMP:
625 : : case WLAN_CIPHER_SUITE_GCMP_256:
626 : 0 : key->conf.iv_len = IEEE80211_GCMP_HDR_LEN;
627 : 0 : key->conf.icv_len = IEEE80211_GCMP_MIC_LEN;
628 [ # # ]: 0 : for (i = 0; seq && i < IEEE80211_NUM_TIDS + 1; i++)
629 [ # # ]: 0 : for (j = 0; j < IEEE80211_GCMP_PN_LEN; j++)
630 : 0 : key->u.gcmp.rx_pn[i][j] =
631 : 0 : seq[IEEE80211_GCMP_PN_LEN - j - 1];
632 : : /* Initialize AES key state here as an optimization so that
633 : : * it does not need to be initialized for every packet.
634 : : */
635 : 0 : key->u.gcmp.tfm = ieee80211_aes_gcm_key_setup_encrypt(key_data,
636 : : key_len);
637 [ # # ]: 0 : if (IS_ERR(key->u.gcmp.tfm)) {
638 : 0 : err = PTR_ERR(key->u.gcmp.tfm);
639 : 0 : kfree(key);
640 : 0 : return ERR_PTR(err);
641 : : }
642 : : break;
643 : 0 : default:
644 [ # # ]: 0 : if (cs) {
645 [ # # # # ]: 0 : if (seq_len && seq_len != cs->pn_len) {
646 : 0 : kfree(key);
647 : 0 : return ERR_PTR(-EINVAL);
648 : : }
649 : :
650 : 0 : key->conf.iv_len = cs->hdr_len;
651 : 0 : key->conf.icv_len = cs->mic_len;
652 [ # # ]: 0 : for (i = 0; i < IEEE80211_NUM_TIDS + 1; i++)
653 [ # # ]: 0 : for (j = 0; j < seq_len; j++)
654 : 0 : key->u.gen.rx_pn[i][j] =
655 : 0 : seq[seq_len - j - 1];
656 : 0 : key->flags |= KEY_FLAG_CIPHER_SCHEME;
657 : : }
658 : : }
659 : 0 : memcpy(key->conf.key, key_data, key_len);
660 : 0 : INIT_LIST_HEAD(&key->list);
661 : :
662 : 0 : return key;
663 : : }
664 : :
665 : 0 : static void ieee80211_key_free_common(struct ieee80211_key *key)
666 : : {
667 [ # # # # : 0 : switch (key->conf.cipher) {
# ]
668 : 0 : case WLAN_CIPHER_SUITE_CCMP:
669 : : case WLAN_CIPHER_SUITE_CCMP_256:
670 : 0 : ieee80211_aes_key_free(key->u.ccmp.tfm);
671 : : break;
672 : 0 : case WLAN_CIPHER_SUITE_AES_CMAC:
673 : : case WLAN_CIPHER_SUITE_BIP_CMAC_256:
674 : 0 : ieee80211_aes_cmac_key_free(key->u.aes_cmac.tfm);
675 : 0 : break;
676 : 0 : case WLAN_CIPHER_SUITE_BIP_GMAC_128:
677 : : case WLAN_CIPHER_SUITE_BIP_GMAC_256:
678 : 0 : ieee80211_aes_gmac_key_free(key->u.aes_gmac.tfm);
679 : 0 : break;
680 : 0 : case WLAN_CIPHER_SUITE_GCMP:
681 : : case WLAN_CIPHER_SUITE_GCMP_256:
682 : 0 : ieee80211_aes_gcm_key_free(key->u.gcmp.tfm);
683 : : break;
684 : : }
685 : 0 : kzfree(key);
686 : 0 : }
687 : :
688 : 0 : static void __ieee80211_key_destroy(struct ieee80211_key *key,
689 : : bool delay_tailroom)
690 : : {
691 [ # # ]: 0 : if (key->local) {
692 : 0 : struct ieee80211_sub_if_data *sdata = key->sdata;
693 : :
694 : 0 : ieee80211_debugfs_key_remove(key);
695 : :
696 [ # # ]: 0 : if (delay_tailroom) {
697 : : /* see ieee80211_delayed_tailroom_dec */
698 : 0 : sdata->crypto_tx_tailroom_pending_dec++;
699 : 0 : schedule_delayed_work(&sdata->dec_tailroom_needed_wk,
700 : : HZ/2);
701 : : } else {
702 : 0 : decrease_tailroom_need_count(sdata, 1);
703 : : }
704 : : }
705 : :
706 : 0 : ieee80211_key_free_common(key);
707 : 0 : }
708 : :
709 : 0 : static void ieee80211_key_destroy(struct ieee80211_key *key,
710 : : bool delay_tailroom)
711 : : {
712 : 0 : if (!key)
713 : : return;
714 : :
715 : : /*
716 : : * Synchronize so the TX path and rcu key iterators
717 : : * can no longer be using this key before we free/remove it.
718 : : */
719 : 0 : synchronize_net();
720 : :
721 : 0 : __ieee80211_key_destroy(key, delay_tailroom);
722 : : }
723 : :
724 : 0 : void ieee80211_key_free_unused(struct ieee80211_key *key)
725 : : {
726 [ # # # # : 0 : WARN_ON(key->sdata || key->local);
# # ]
727 : 0 : ieee80211_key_free_common(key);
728 : 0 : }
729 : :
730 : : static bool ieee80211_key_identical(struct ieee80211_sub_if_data *sdata,
731 : : struct ieee80211_key *old,
732 : : struct ieee80211_key *new)
733 : : {
734 : : u8 tkip_old[WLAN_KEY_LEN_TKIP], tkip_new[WLAN_KEY_LEN_TKIP];
735 : : u8 *tk_old, *tk_new;
736 : :
737 : : if (!old || new->conf.keylen != old->conf.keylen)
738 : : return false;
739 : :
740 : : tk_old = old->conf.key;
741 : : tk_new = new->conf.key;
742 : :
743 : : /*
744 : : * In station mode, don't compare the TX MIC key, as it's never used
745 : : * and offloaded rekeying may not care to send it to the host. This
746 : : * is the case in iwlwifi, for example.
747 : : */
748 : : if (sdata->vif.type == NL80211_IFTYPE_STATION &&
749 : : new->conf.cipher == WLAN_CIPHER_SUITE_TKIP &&
750 : : new->conf.keylen == WLAN_KEY_LEN_TKIP &&
751 : : !(new->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
752 : : memcpy(tkip_old, tk_old, WLAN_KEY_LEN_TKIP);
753 : : memcpy(tkip_new, tk_new, WLAN_KEY_LEN_TKIP);
754 : : memset(tkip_old + NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY, 0, 8);
755 : : memset(tkip_new + NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY, 0, 8);
756 : : tk_old = tkip_old;
757 : : tk_new = tkip_new;
758 : : }
759 : :
760 : : return !crypto_memneq(tk_old, tk_new, new->conf.keylen);
761 : : }
762 : :
763 : 0 : int ieee80211_key_link(struct ieee80211_key *key,
764 : : struct ieee80211_sub_if_data *sdata,
765 : : struct sta_info *sta)
766 : : {
767 : 0 : struct ieee80211_key *old_key;
768 : 0 : int idx = key->conf.keyidx;
769 : 0 : bool pairwise = key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE;
770 : : /*
771 : : * We want to delay tailroom updates only for station - in that
772 : : * case it helps roaming speed, but in other cases it hurts and
773 : : * can cause warnings to appear.
774 : : */
775 : 0 : bool delay_tailroom = sdata->vif.type == NL80211_IFTYPE_STATION;
776 : 0 : int ret = -EOPNOTSUPP;
777 : :
778 : 0 : mutex_lock(&sdata->local->key_mtx);
779 : :
780 [ # # ]: 0 : if (sta && pairwise) {
781 : 0 : struct ieee80211_key *alt_key;
782 : :
783 : 0 : old_key = key_mtx_dereference(sdata->local, sta->ptk[idx]);
784 : 0 : alt_key = key_mtx_dereference(sdata->local, sta->ptk[idx ^ 1]);
785 : :
786 : : /* The rekey code assumes that the old and new key are using
787 : : * the same cipher. Enforce the assumption for pairwise keys.
788 : : */
789 [ # # # # : 0 : if ((alt_key && alt_key->conf.cipher != key->conf.cipher) ||
# # ]
790 [ # # ]: 0 : (old_key && old_key->conf.cipher != key->conf.cipher))
791 : 0 : goto out;
792 [ # # ]: 0 : } else if (sta) {
793 : 0 : old_key = key_mtx_dereference(sdata->local, sta->gtk[idx]);
794 : : } else {
795 : 0 : old_key = key_mtx_dereference(sdata->local, sdata->keys[idx]);
796 : : }
797 : :
798 : : /* Non-pairwise keys must also not switch the cipher on rekey */
799 [ # # ]: 0 : if (!pairwise) {
800 [ # # # # ]: 0 : if (old_key && old_key->conf.cipher != key->conf.cipher)
801 : 0 : goto out;
802 : : }
803 : :
804 : : /*
805 : : * Silently accept key re-installation without really installing the
806 : : * new version of the key to avoid nonce reuse or replay issues.
807 : : */
808 [ # # ]: 0 : if (ieee80211_key_identical(sdata, old_key, key)) {
809 : 0 : ieee80211_key_free_unused(key);
810 : 0 : ret = 0;
811 : 0 : goto out;
812 : : }
813 : :
814 : 0 : key->local = sdata->local;
815 : 0 : key->sdata = sdata;
816 : 0 : key->sta = sta;
817 : :
818 : 0 : increment_tailroom_need_count(sdata);
819 : :
820 : 0 : ret = ieee80211_key_replace(sdata, sta, pairwise, old_key, key);
821 : :
822 [ # # ]: 0 : if (!ret) {
823 : 0 : ieee80211_debugfs_key_add(key);
824 [ # # ]: 0 : ieee80211_key_destroy(old_key, delay_tailroom);
825 : : } else {
826 : 0 : ieee80211_key_free(key, delay_tailroom);
827 : : }
828 : :
829 : 0 : out:
830 : 0 : mutex_unlock(&sdata->local->key_mtx);
831 : :
832 : 0 : return ret;
833 : : }
834 : :
835 : 0 : void ieee80211_key_free(struct ieee80211_key *key, bool delay_tailroom)
836 : : {
837 [ # # ]: 0 : if (!key)
838 : : return;
839 : :
840 : : /*
841 : : * Replace key with nothingness if it was ever used.
842 : : */
843 [ # # ]: 0 : if (key->sdata)
844 : 0 : ieee80211_key_replace(key->sdata, key->sta,
845 : 0 : key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE,
846 : : key, NULL);
847 : 0 : ieee80211_key_destroy(key, delay_tailroom);
848 : : }
849 : :
850 : 0 : void ieee80211_reenable_keys(struct ieee80211_sub_if_data *sdata)
851 : : {
852 : 0 : struct ieee80211_key *key;
853 : 0 : struct ieee80211_sub_if_data *vlan;
854 : :
855 [ # # # # ]: 0 : ASSERT_RTNL();
856 : :
857 : 0 : mutex_lock(&sdata->local->key_mtx);
858 : :
859 : 0 : sdata->crypto_tx_tailroom_needed_cnt = 0;
860 : 0 : sdata->crypto_tx_tailroom_pending_dec = 0;
861 : :
862 [ # # ]: 0 : if (sdata->vif.type == NL80211_IFTYPE_AP) {
863 [ # # ]: 0 : list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list) {
864 : 0 : vlan->crypto_tx_tailroom_needed_cnt = 0;
865 : 0 : vlan->crypto_tx_tailroom_pending_dec = 0;
866 : : }
867 : : }
868 : :
869 [ # # ]: 0 : if (ieee80211_sdata_running(sdata)) {
870 [ # # ]: 0 : list_for_each_entry(key, &sdata->key_list, list) {
871 : 0 : increment_tailroom_need_count(sdata);
872 : 0 : ieee80211_key_enable_hw_accel(key);
873 : : }
874 : : }
875 : :
876 : 0 : mutex_unlock(&sdata->local->key_mtx);
877 : 0 : }
878 : :
879 : 0 : void ieee80211_iter_keys(struct ieee80211_hw *hw,
880 : : struct ieee80211_vif *vif,
881 : : void (*iter)(struct ieee80211_hw *hw,
882 : : struct ieee80211_vif *vif,
883 : : struct ieee80211_sta *sta,
884 : : struct ieee80211_key_conf *key,
885 : : void *data),
886 : : void *iter_data)
887 : : {
888 : 0 : struct ieee80211_local *local = hw_to_local(hw);
889 : 0 : struct ieee80211_key *key, *tmp;
890 : 0 : struct ieee80211_sub_if_data *sdata;
891 : :
892 [ # # # # ]: 0 : ASSERT_RTNL();
893 : :
894 : 0 : mutex_lock(&local->key_mtx);
895 [ # # ]: 0 : if (vif) {
896 : 0 : sdata = vif_to_sdata(vif);
897 [ # # ]: 0 : list_for_each_entry_safe(key, tmp, &sdata->key_list, list)
898 : 0 : iter(hw, &sdata->vif,
899 [ # # ]: 0 : key->sta ? &key->sta->sta : NULL,
900 : : &key->conf, iter_data);
901 : : } else {
902 [ # # ]: 0 : list_for_each_entry(sdata, &local->interfaces, list)
903 [ # # ]: 0 : list_for_each_entry_safe(key, tmp,
904 : : &sdata->key_list, list)
905 : 0 : iter(hw, &sdata->vif,
906 [ # # ]: 0 : key->sta ? &key->sta->sta : NULL,
907 : : &key->conf, iter_data);
908 : : }
909 : 0 : mutex_unlock(&local->key_mtx);
910 : 0 : }
911 : : EXPORT_SYMBOL(ieee80211_iter_keys);
912 : :
913 : : static void
914 : 0 : _ieee80211_iter_keys_rcu(struct ieee80211_hw *hw,
915 : : struct ieee80211_sub_if_data *sdata,
916 : : void (*iter)(struct ieee80211_hw *hw,
917 : : struct ieee80211_vif *vif,
918 : : struct ieee80211_sta *sta,
919 : : struct ieee80211_key_conf *key,
920 : : void *data),
921 : : void *iter_data)
922 : : {
923 : 0 : struct ieee80211_key *key;
924 : :
925 [ # # ]: 0 : list_for_each_entry_rcu(key, &sdata->key_list, list) {
926 : : /* skip keys of station in removal process */
927 [ # # # # ]: 0 : if (key->sta && key->sta->removed)
928 : 0 : continue;
929 [ # # ]: 0 : if (!(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
930 : 0 : continue;
931 : :
932 [ # # ]: 0 : iter(hw, &sdata->vif,
933 : : key->sta ? &key->sta->sta : NULL,
934 : : &key->conf, iter_data);
935 : : }
936 : 0 : }
937 : :
938 : 0 : void ieee80211_iter_keys_rcu(struct ieee80211_hw *hw,
939 : : struct ieee80211_vif *vif,
940 : : void (*iter)(struct ieee80211_hw *hw,
941 : : struct ieee80211_vif *vif,
942 : : struct ieee80211_sta *sta,
943 : : struct ieee80211_key_conf *key,
944 : : void *data),
945 : : void *iter_data)
946 : : {
947 [ # # ]: 0 : struct ieee80211_local *local = hw_to_local(hw);
948 : 0 : struct ieee80211_sub_if_data *sdata;
949 : :
950 [ # # ]: 0 : if (vif) {
951 : 0 : sdata = vif_to_sdata(vif);
952 : 0 : _ieee80211_iter_keys_rcu(hw, sdata, iter, iter_data);
953 : : } else {
954 [ # # ]: 0 : list_for_each_entry_rcu(sdata, &local->interfaces, list)
955 : 0 : _ieee80211_iter_keys_rcu(hw, sdata, iter, iter_data);
956 : : }
957 : 0 : }
958 : : EXPORT_SYMBOL(ieee80211_iter_keys_rcu);
959 : :
960 : 0 : static void ieee80211_free_keys_iface(struct ieee80211_sub_if_data *sdata,
961 : : struct list_head *keys)
962 : : {
963 : 0 : struct ieee80211_key *key, *tmp;
964 : :
965 : 0 : decrease_tailroom_need_count(sdata,
966 : : sdata->crypto_tx_tailroom_pending_dec);
967 : 0 : sdata->crypto_tx_tailroom_pending_dec = 0;
968 : :
969 : 0 : ieee80211_debugfs_key_remove_mgmt_default(sdata);
970 : :
971 [ # # ]: 0 : list_for_each_entry_safe(key, tmp, &sdata->key_list, list) {
972 : 0 : ieee80211_key_replace(key->sdata, key->sta,
973 : 0 : key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE,
974 : : key, NULL);
975 : 0 : list_add_tail(&key->list, keys);
976 : : }
977 : :
978 : 0 : ieee80211_debugfs_key_update_default(sdata);
979 : 0 : }
980 : :
981 : 0 : void ieee80211_free_keys(struct ieee80211_sub_if_data *sdata,
982 : : bool force_synchronize)
983 : : {
984 : 0 : struct ieee80211_local *local = sdata->local;
985 : 0 : struct ieee80211_sub_if_data *vlan;
986 : 0 : struct ieee80211_sub_if_data *master;
987 : 0 : struct ieee80211_key *key, *tmp;
988 : 0 : LIST_HEAD(keys);
989 : :
990 : 0 : cancel_delayed_work_sync(&sdata->dec_tailroom_needed_wk);
991 : :
992 : 0 : mutex_lock(&local->key_mtx);
993 : :
994 : 0 : ieee80211_free_keys_iface(sdata, &keys);
995 : :
996 [ # # ]: 0 : if (sdata->vif.type == NL80211_IFTYPE_AP) {
997 [ # # ]: 0 : list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list)
998 : 0 : ieee80211_free_keys_iface(vlan, &keys);
999 : : }
1000 : :
1001 [ # # # # ]: 0 : if (!list_empty(&keys) || force_synchronize)
1002 : 0 : synchronize_net();
1003 [ # # ]: 0 : list_for_each_entry_safe(key, tmp, &keys, list)
1004 : 0 : __ieee80211_key_destroy(key, false);
1005 : :
1006 [ # # ]: 0 : if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
1007 [ # # ]: 0 : if (sdata->bss) {
1008 : 0 : master = container_of(sdata->bss,
1009 : : struct ieee80211_sub_if_data,
1010 : : u.ap);
1011 : :
1012 [ # # ]: 0 : WARN_ON_ONCE(sdata->crypto_tx_tailroom_needed_cnt !=
1013 : : master->crypto_tx_tailroom_needed_cnt);
1014 : : }
1015 : : } else {
1016 [ # # ]: 0 : WARN_ON_ONCE(sdata->crypto_tx_tailroom_needed_cnt ||
1017 : : sdata->crypto_tx_tailroom_pending_dec);
1018 : : }
1019 : :
1020 [ # # ]: 0 : if (sdata->vif.type == NL80211_IFTYPE_AP) {
1021 [ # # ]: 0 : list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list)
1022 [ # # ]: 0 : WARN_ON_ONCE(vlan->crypto_tx_tailroom_needed_cnt ||
1023 : : vlan->crypto_tx_tailroom_pending_dec);
1024 : : }
1025 : :
1026 : 0 : mutex_unlock(&local->key_mtx);
1027 : 0 : }
1028 : :
1029 : 0 : void ieee80211_free_sta_keys(struct ieee80211_local *local,
1030 : : struct sta_info *sta)
1031 : : {
1032 : 0 : struct ieee80211_key *key;
1033 : 0 : int i;
1034 : :
1035 : 0 : mutex_lock(&local->key_mtx);
1036 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(sta->gtk); i++) {
1037 : 0 : key = key_mtx_dereference(local, sta->gtk[i]);
1038 [ # # ]: 0 : if (!key)
1039 : 0 : continue;
1040 : 0 : ieee80211_key_replace(key->sdata, key->sta,
1041 : 0 : key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE,
1042 : : key, NULL);
1043 : 0 : __ieee80211_key_destroy(key, key->sdata->vif.type ==
1044 : : NL80211_IFTYPE_STATION);
1045 : : }
1046 : :
1047 [ # # ]: 0 : for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
1048 : 0 : key = key_mtx_dereference(local, sta->ptk[i]);
1049 [ # # ]: 0 : if (!key)
1050 : 0 : continue;
1051 : 0 : ieee80211_key_replace(key->sdata, key->sta,
1052 : 0 : key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE,
1053 : : key, NULL);
1054 : 0 : __ieee80211_key_destroy(key, key->sdata->vif.type ==
1055 : : NL80211_IFTYPE_STATION);
1056 : : }
1057 : :
1058 : 0 : mutex_unlock(&local->key_mtx);
1059 : 0 : }
1060 : :
1061 : 0 : void ieee80211_delayed_tailroom_dec(struct work_struct *wk)
1062 : : {
1063 : 0 : struct ieee80211_sub_if_data *sdata;
1064 : :
1065 : 0 : sdata = container_of(wk, struct ieee80211_sub_if_data,
1066 : : dec_tailroom_needed_wk.work);
1067 : :
1068 : : /*
1069 : : * The reason for the delayed tailroom needed decrementing is to
1070 : : * make roaming faster: during roaming, all keys are first deleted
1071 : : * and then new keys are installed. The first new key causes the
1072 : : * crypto_tx_tailroom_needed_cnt to go from 0 to 1, which invokes
1073 : : * the cost of synchronize_net() (which can be slow). Avoid this
1074 : : * by deferring the crypto_tx_tailroom_needed_cnt decrementing on
1075 : : * key removal for a while, so if we roam the value is larger than
1076 : : * zero and no 0->1 transition happens.
1077 : : *
1078 : : * The cost is that if the AP switching was from an AP with keys
1079 : : * to one without, we still allocate tailroom while it would no
1080 : : * longer be needed. However, in the typical (fast) roaming case
1081 : : * within an ESS this usually won't happen.
1082 : : */
1083 : :
1084 : 0 : mutex_lock(&sdata->local->key_mtx);
1085 : 0 : decrease_tailroom_need_count(sdata,
1086 : : sdata->crypto_tx_tailroom_pending_dec);
1087 : 0 : sdata->crypto_tx_tailroom_pending_dec = 0;
1088 : 0 : mutex_unlock(&sdata->local->key_mtx);
1089 : 0 : }
1090 : :
1091 : 0 : void ieee80211_gtk_rekey_notify(struct ieee80211_vif *vif, const u8 *bssid,
1092 : : const u8 *replay_ctr, gfp_t gfp)
1093 : : {
1094 : 0 : struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
1095 : :
1096 : 0 : trace_api_gtk_rekey_notify(sdata, bssid, replay_ctr);
1097 : :
1098 : 0 : cfg80211_gtk_rekey_notify(sdata->dev, bssid, replay_ctr, gfp);
1099 : 0 : }
1100 : : EXPORT_SYMBOL_GPL(ieee80211_gtk_rekey_notify);
1101 : :
1102 : 0 : void ieee80211_get_key_rx_seq(struct ieee80211_key_conf *keyconf,
1103 : : int tid, struct ieee80211_key_seq *seq)
1104 : : {
1105 : 0 : struct ieee80211_key *key;
1106 : 0 : const u8 *pn;
1107 : :
1108 : 0 : key = container_of(keyconf, struct ieee80211_key, conf);
1109 : :
1110 [ # # # # : 0 : switch (key->conf.cipher) {
# # ]
1111 : 0 : case WLAN_CIPHER_SUITE_TKIP:
1112 [ # # # # ]: 0 : if (WARN_ON(tid < 0 || tid >= IEEE80211_NUM_TIDS))
1113 : : return;
1114 : 0 : seq->tkip.iv32 = key->u.tkip.rx[tid].iv32;
1115 : 0 : seq->tkip.iv16 = key->u.tkip.rx[tid].iv16;
1116 : 0 : break;
1117 : 0 : case WLAN_CIPHER_SUITE_CCMP:
1118 : : case WLAN_CIPHER_SUITE_CCMP_256:
1119 [ # # # # ]: 0 : if (WARN_ON(tid < -1 || tid >= IEEE80211_NUM_TIDS))
1120 : : return;
1121 [ # # ]: 0 : if (tid < 0)
1122 : 0 : pn = key->u.ccmp.rx_pn[IEEE80211_NUM_TIDS];
1123 : : else
1124 : 0 : pn = key->u.ccmp.rx_pn[tid];
1125 : 0 : memcpy(seq->ccmp.pn, pn, IEEE80211_CCMP_PN_LEN);
1126 : 0 : break;
1127 : 0 : case WLAN_CIPHER_SUITE_AES_CMAC:
1128 : : case WLAN_CIPHER_SUITE_BIP_CMAC_256:
1129 [ # # # # ]: 0 : if (WARN_ON(tid != 0))
1130 : : return;
1131 : 0 : pn = key->u.aes_cmac.rx_pn;
1132 : 0 : memcpy(seq->aes_cmac.pn, pn, IEEE80211_CMAC_PN_LEN);
1133 : 0 : break;
1134 : 0 : case WLAN_CIPHER_SUITE_BIP_GMAC_128:
1135 : : case WLAN_CIPHER_SUITE_BIP_GMAC_256:
1136 [ # # # # ]: 0 : if (WARN_ON(tid != 0))
1137 : : return;
1138 : 0 : pn = key->u.aes_gmac.rx_pn;
1139 : 0 : memcpy(seq->aes_gmac.pn, pn, IEEE80211_GMAC_PN_LEN);
1140 : 0 : break;
1141 : 0 : case WLAN_CIPHER_SUITE_GCMP:
1142 : : case WLAN_CIPHER_SUITE_GCMP_256:
1143 [ # # # # ]: 0 : if (WARN_ON(tid < -1 || tid >= IEEE80211_NUM_TIDS))
1144 : : return;
1145 [ # # ]: 0 : if (tid < 0)
1146 : 0 : pn = key->u.gcmp.rx_pn[IEEE80211_NUM_TIDS];
1147 : : else
1148 : 0 : pn = key->u.gcmp.rx_pn[tid];
1149 : 0 : memcpy(seq->gcmp.pn, pn, IEEE80211_GCMP_PN_LEN);
1150 : 0 : break;
1151 : : }
1152 : 0 : }
1153 : : EXPORT_SYMBOL(ieee80211_get_key_rx_seq);
1154 : :
1155 : 0 : void ieee80211_set_key_rx_seq(struct ieee80211_key_conf *keyconf,
1156 : : int tid, struct ieee80211_key_seq *seq)
1157 : : {
1158 : 0 : struct ieee80211_key *key;
1159 : 0 : u8 *pn;
1160 : :
1161 : 0 : key = container_of(keyconf, struct ieee80211_key, conf);
1162 : :
1163 [ # # # # : 0 : switch (key->conf.cipher) {
# # ]
1164 : 0 : case WLAN_CIPHER_SUITE_TKIP:
1165 [ # # # # ]: 0 : if (WARN_ON(tid < 0 || tid >= IEEE80211_NUM_TIDS))
1166 : : return;
1167 : 0 : key->u.tkip.rx[tid].iv32 = seq->tkip.iv32;
1168 : 0 : key->u.tkip.rx[tid].iv16 = seq->tkip.iv16;
1169 : 0 : break;
1170 : 0 : case WLAN_CIPHER_SUITE_CCMP:
1171 : : case WLAN_CIPHER_SUITE_CCMP_256:
1172 [ # # # # ]: 0 : if (WARN_ON(tid < -1 || tid >= IEEE80211_NUM_TIDS))
1173 : : return;
1174 [ # # ]: 0 : if (tid < 0)
1175 : 0 : pn = key->u.ccmp.rx_pn[IEEE80211_NUM_TIDS];
1176 : : else
1177 : 0 : pn = key->u.ccmp.rx_pn[tid];
1178 : 0 : memcpy(pn, seq->ccmp.pn, IEEE80211_CCMP_PN_LEN);
1179 : 0 : break;
1180 : 0 : case WLAN_CIPHER_SUITE_AES_CMAC:
1181 : : case WLAN_CIPHER_SUITE_BIP_CMAC_256:
1182 [ # # # # ]: 0 : if (WARN_ON(tid != 0))
1183 : : return;
1184 : 0 : pn = key->u.aes_cmac.rx_pn;
1185 : 0 : memcpy(pn, seq->aes_cmac.pn, IEEE80211_CMAC_PN_LEN);
1186 : 0 : break;
1187 : 0 : case WLAN_CIPHER_SUITE_BIP_GMAC_128:
1188 : : case WLAN_CIPHER_SUITE_BIP_GMAC_256:
1189 [ # # # # ]: 0 : if (WARN_ON(tid != 0))
1190 : : return;
1191 : 0 : pn = key->u.aes_gmac.rx_pn;
1192 : 0 : memcpy(pn, seq->aes_gmac.pn, IEEE80211_GMAC_PN_LEN);
1193 : 0 : break;
1194 : 0 : case WLAN_CIPHER_SUITE_GCMP:
1195 : : case WLAN_CIPHER_SUITE_GCMP_256:
1196 [ # # # # ]: 0 : if (WARN_ON(tid < -1 || tid >= IEEE80211_NUM_TIDS))
1197 : : return;
1198 [ # # ]: 0 : if (tid < 0)
1199 : 0 : pn = key->u.gcmp.rx_pn[IEEE80211_NUM_TIDS];
1200 : : else
1201 : 0 : pn = key->u.gcmp.rx_pn[tid];
1202 : 0 : memcpy(pn, seq->gcmp.pn, IEEE80211_GCMP_PN_LEN);
1203 : 0 : break;
1204 : : default:
1205 : 0 : WARN_ON(1);
1206 : 0 : break;
1207 : : }
1208 : : }
1209 : : EXPORT_SYMBOL_GPL(ieee80211_set_key_rx_seq);
1210 : :
1211 : 0 : void ieee80211_remove_key(struct ieee80211_key_conf *keyconf)
1212 : : {
1213 : 0 : struct ieee80211_key *key;
1214 : :
1215 : 0 : key = container_of(keyconf, struct ieee80211_key, conf);
1216 : :
1217 : 0 : assert_key_lock(key->local);
1218 : :
1219 : : /*
1220 : : * if key was uploaded, we assume the driver will/has remove(d)
1221 : : * it, so adjust bookkeeping accordingly
1222 : : */
1223 [ # # ]: 0 : if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE) {
1224 : 0 : key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE;
1225 : :
1226 [ # # ]: 0 : if (!(key->conf.flags & (IEEE80211_KEY_FLAG_GENERATE_MMIC |
1227 : : IEEE80211_KEY_FLAG_PUT_MIC_SPACE |
1228 : : IEEE80211_KEY_FLAG_RESERVE_TAILROOM)))
1229 : 0 : increment_tailroom_need_count(key->sdata);
1230 : : }
1231 : :
1232 : 0 : ieee80211_key_free(key, false);
1233 : 0 : }
1234 : : EXPORT_SYMBOL_GPL(ieee80211_remove_key);
1235 : :
1236 : : struct ieee80211_key_conf *
1237 : 0 : ieee80211_gtk_rekey_add(struct ieee80211_vif *vif,
1238 : : struct ieee80211_key_conf *keyconf)
1239 : : {
1240 [ # # ]: 0 : struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
1241 : 0 : struct ieee80211_local *local = sdata->local;
1242 : 0 : struct ieee80211_key *key;
1243 : 0 : int err;
1244 : :
1245 [ # # # # ]: 0 : if (WARN_ON(!local->wowlan))
1246 : : return ERR_PTR(-EINVAL);
1247 : :
1248 [ # # # # ]: 0 : if (WARN_ON(vif->type != NL80211_IFTYPE_STATION))
1249 : : return ERR_PTR(-EINVAL);
1250 : :
1251 : 0 : key = ieee80211_key_alloc(keyconf->cipher, keyconf->keyidx,
1252 : 0 : keyconf->keylen, keyconf->key,
1253 : : 0, NULL, NULL);
1254 [ # # ]: 0 : if (IS_ERR(key))
1255 : : return ERR_CAST(key);
1256 : :
1257 [ # # ]: 0 : if (sdata->u.mgd.mfp != IEEE80211_MFP_DISABLED)
1258 : 0 : key->conf.flags |= IEEE80211_KEY_FLAG_RX_MGMT;
1259 : :
1260 : 0 : err = ieee80211_key_link(key, sdata, NULL);
1261 [ # # ]: 0 : if (err)
1262 : 0 : return ERR_PTR(err);
1263 : :
1264 : 0 : return &key->conf;
1265 : : }
1266 : : EXPORT_SYMBOL_GPL(ieee80211_gtk_rekey_add);
|
