mac80211: make key locking clearer
[linux-2.6.git] / net / mac80211 / key.c
1 /*
2  * Copyright 2002-2005, Instant802 Networks, Inc.
3  * Copyright 2005-2006, Devicescape Software, Inc.
4  * Copyright 2006-2007  Jiri Benc <jbenc@suse.cz>
5  * Copyright 2007-2008  Johannes Berg <johannes@sipsolutions.net>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  */
11
12 #include <linux/if_ether.h>
13 #include <linux/etherdevice.h>
14 #include <linux/list.h>
15 #include <linux/rcupdate.h>
16 #include <linux/rtnetlink.h>
17 #include <linux/slab.h>
18 #include <net/mac80211.h>
19 #include "ieee80211_i.h"
20 #include "driver-ops.h"
21 #include "debugfs_key.h"
22 #include "aes_ccm.h"
23 #include "aes_cmac.h"
24
25
26 /**
27  * DOC: Key handling basics
28  *
29  * Key handling in mac80211 is done based on per-interface (sub_if_data)
30  * keys and per-station keys. Since each station belongs to an interface,
31  * each station key also belongs to that interface.
32  *
33  * Hardware acceleration is done on a best-effort basis for algorithms
34  * that are implemented in software,  for each key the hardware is asked
35  * to enable that key for offloading but if it cannot do that the key is
36  * simply kept for software encryption (unless it is for an algorithm
37  * that isn't implemented in software).
38  * There is currently no way of knowing whether a key is handled in SW
39  * or HW except by looking into debugfs.
40  *
41  * All key management is internally protected by a mutex. Within all
42  * other parts of mac80211, key references are, just as STA structure
43  * references, protected by RCU. Note, however, that some things are
44  * unprotected, namely the key->sta dereferences within the hardware
45  * acceleration functions. This means that sta_info_destroy() must
46  * remove the key which waits for an RCU grace period.
47  */
48
49 static const u8 bcast_addr[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
50
51 static void assert_key_lock(struct ieee80211_local *local)
52 {
53         lockdep_assert_held(&local->key_mtx);
54 }
55
56 static struct ieee80211_sta *get_sta_for_key(struct ieee80211_key *key)
57 {
58         if (key->sta)
59                 return &key->sta->sta;
60
61         return NULL;
62 }
63
64 static int ieee80211_key_enable_hw_accel(struct ieee80211_key *key)
65 {
66         struct ieee80211_sub_if_data *sdata;
67         struct ieee80211_sta *sta;
68         int ret;
69
70         might_sleep();
71
72         if (!key->local->ops->set_key)
73                 goto out_unsupported;
74
75         assert_key_lock(key->local);
76
77         sta = get_sta_for_key(key);
78
79         /*
80          * If this is a per-STA GTK, check if it
81          * is supported; if not, return.
82          */
83         if (sta && !(key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE) &&
84             !(key->local->hw.flags & IEEE80211_HW_SUPPORTS_PER_STA_GTK))
85                 goto out_unsupported;
86
87         sdata = key->sdata;
88         if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
89                 /*
90                  * The driver doesn't know anything about VLAN interfaces.
91                  * Hence, don't send GTKs for VLAN interfaces to the driver.
92                  */
93                 if (!(key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE))
94                         goto out_unsupported;
95                 sdata = container_of(sdata->bss,
96                                      struct ieee80211_sub_if_data,
97                                      u.ap);
98         }
99
100         ret = drv_set_key(key->local, SET_KEY, sdata, sta, &key->conf);
101
102         if (!ret) {
103                 key->flags |= KEY_FLAG_UPLOADED_TO_HARDWARE;
104
105                 if (!((key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_MMIC) ||
106                       (key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_IV)))
107                         key->local->crypto_tx_tailroom_needed_cnt--;
108
109                 return 0;
110         }
111
112         if (ret != -ENOSPC && ret != -EOPNOTSUPP)
113                 wiphy_err(key->local->hw.wiphy,
114                           "failed to set key (%d, %pM) to hardware (%d)\n",
115                           key->conf.keyidx, sta ? sta->addr : bcast_addr, ret);
116
117  out_unsupported:
118         switch (key->conf.cipher) {
119         case WLAN_CIPHER_SUITE_WEP40:
120         case WLAN_CIPHER_SUITE_WEP104:
121         case WLAN_CIPHER_SUITE_TKIP:
122         case WLAN_CIPHER_SUITE_CCMP:
123         case WLAN_CIPHER_SUITE_AES_CMAC:
124                 /* all of these we can do in software */
125                 return 0;
126         default:
127                 return -EINVAL;
128         }
129 }
130
131 static void ieee80211_key_disable_hw_accel(struct ieee80211_key *key)
132 {
133         struct ieee80211_sub_if_data *sdata;
134         struct ieee80211_sta *sta;
135         int ret;
136
137         might_sleep();
138
139         if (!key || !key->local->ops->set_key)
140                 return;
141
142         assert_key_lock(key->local);
143
144         if (!(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
145                 return;
146
147         sta = get_sta_for_key(key);
148         sdata = key->sdata;
149
150         if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
151                 sdata = container_of(sdata->bss,
152                                      struct ieee80211_sub_if_data,
153                                      u.ap);
154
155         ret = drv_set_key(key->local, DISABLE_KEY, sdata,
156                           sta, &key->conf);
157
158         if (ret)
159                 wiphy_err(key->local->hw.wiphy,
160                           "failed to remove key (%d, %pM) from hardware (%d)\n",
161                           key->conf.keyidx, sta ? sta->addr : bcast_addr, ret);
162
163         key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE;
164
165         if (!((key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_MMIC) ||
166               (key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_IV)))
167                 key->local->crypto_tx_tailroom_needed_cnt++;
168 }
169
170 void ieee80211_key_removed(struct ieee80211_key_conf *key_conf)
171 {
172         struct ieee80211_key *key;
173
174         key = container_of(key_conf, struct ieee80211_key, conf);
175
176         might_sleep();
177         assert_key_lock(key->local);
178
179         key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE;
180
181         /*
182          * Flush TX path to avoid attempts to use this key
183          * after this function returns. Until then, drivers
184          * must be prepared to handle the key.
185          */
186         synchronize_rcu();
187 }
188 EXPORT_SYMBOL_GPL(ieee80211_key_removed);
189
190 static void __ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata,
191                                         int idx, bool uni, bool multi)
192 {
193         struct ieee80211_key *key = NULL;
194
195         assert_key_lock(sdata->local);
196
197         if (idx >= 0 && idx < NUM_DEFAULT_KEYS)
198                 key = sdata->keys[idx];
199
200         if (uni)
201                 rcu_assign_pointer(sdata->default_unicast_key, key);
202         if (multi)
203                 rcu_assign_pointer(sdata->default_multicast_key, key);
204
205         ieee80211_debugfs_key_update_default(sdata);
206 }
207
208 void ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata, int idx,
209                                bool uni, bool multi)
210 {
211         mutex_lock(&sdata->local->key_mtx);
212         __ieee80211_set_default_key(sdata, idx, uni, multi);
213         mutex_unlock(&sdata->local->key_mtx);
214 }
215
216 static void
217 __ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata, int idx)
218 {
219         struct ieee80211_key *key = NULL;
220
221         assert_key_lock(sdata->local);
222
223         if (idx >= NUM_DEFAULT_KEYS &&
224             idx < NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS)
225                 key = sdata->keys[idx];
226
227         rcu_assign_pointer(sdata->default_mgmt_key, key);
228
229         ieee80211_debugfs_key_update_default(sdata);
230 }
231
232 void ieee80211_set_default_mgmt_key(struct ieee80211_sub_if_data *sdata,
233                                     int idx)
234 {
235         mutex_lock(&sdata->local->key_mtx);
236         __ieee80211_set_default_mgmt_key(sdata, idx);
237         mutex_unlock(&sdata->local->key_mtx);
238 }
239
240
241 static void __ieee80211_key_replace(struct ieee80211_sub_if_data *sdata,
242                                     struct sta_info *sta,
243                                     bool pairwise,
244                                     struct ieee80211_key *old,
245                                     struct ieee80211_key *new)
246 {
247         int idx;
248         bool defunikey, defmultikey, defmgmtkey;
249
250         if (new)
251                 list_add(&new->list, &sdata->key_list);
252
253         if (sta && pairwise) {
254                 rcu_assign_pointer(sta->ptk, new);
255         } else if (sta) {
256                 if (old)
257                         idx = old->conf.keyidx;
258                 else
259                         idx = new->conf.keyidx;
260                 rcu_assign_pointer(sta->gtk[idx], new);
261         } else {
262                 WARN_ON(new && old && new->conf.keyidx != old->conf.keyidx);
263
264                 if (old)
265                         idx = old->conf.keyidx;
266                 else
267                         idx = new->conf.keyidx;
268
269                 defunikey = old && sdata->default_unicast_key == old;
270                 defmultikey = old && sdata->default_multicast_key == old;
271                 defmgmtkey = old && sdata->default_mgmt_key == old;
272
273                 if (defunikey && !new)
274                         __ieee80211_set_default_key(sdata, -1, true, false);
275                 if (defmultikey && !new)
276                         __ieee80211_set_default_key(sdata, -1, false, true);
277                 if (defmgmtkey && !new)
278                         __ieee80211_set_default_mgmt_key(sdata, -1);
279
280                 rcu_assign_pointer(sdata->keys[idx], new);
281                 if (defunikey && new)
282                         __ieee80211_set_default_key(sdata, new->conf.keyidx,
283                                                     true, false);
284                 if (defmultikey && new)
285                         __ieee80211_set_default_key(sdata, new->conf.keyidx,
286                                                     false, true);
287                 if (defmgmtkey && new)
288                         __ieee80211_set_default_mgmt_key(sdata,
289                                                          new->conf.keyidx);
290         }
291
292         if (old)
293                 list_del(&old->list);
294 }
295
296 struct ieee80211_key *ieee80211_key_alloc(u32 cipher, int idx, size_t key_len,
297                                           const u8 *key_data,
298                                           size_t seq_len, const u8 *seq)
299 {
300         struct ieee80211_key *key;
301         int i, j, err;
302
303         BUG_ON(idx < 0 || idx >= NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS);
304
305         key = kzalloc(sizeof(struct ieee80211_key) + key_len, GFP_KERNEL);
306         if (!key)
307                 return ERR_PTR(-ENOMEM);
308
309         /*
310          * Default to software encryption; we'll later upload the
311          * key to the hardware if possible.
312          */
313         key->conf.flags = 0;
314         key->flags = 0;
315
316         key->conf.cipher = cipher;
317         key->conf.keyidx = idx;
318         key->conf.keylen = key_len;
319         switch (cipher) {
320         case WLAN_CIPHER_SUITE_WEP40:
321         case WLAN_CIPHER_SUITE_WEP104:
322                 key->conf.iv_len = WEP_IV_LEN;
323                 key->conf.icv_len = WEP_ICV_LEN;
324                 break;
325         case WLAN_CIPHER_SUITE_TKIP:
326                 key->conf.iv_len = TKIP_IV_LEN;
327                 key->conf.icv_len = TKIP_ICV_LEN;
328                 if (seq) {
329                         for (i = 0; i < NUM_RX_DATA_QUEUES; i++) {
330                                 key->u.tkip.rx[i].iv32 =
331                                         get_unaligned_le32(&seq[2]);
332                                 key->u.tkip.rx[i].iv16 =
333                                         get_unaligned_le16(seq);
334                         }
335                 }
336                 break;
337         case WLAN_CIPHER_SUITE_CCMP:
338                 key->conf.iv_len = CCMP_HDR_LEN;
339                 key->conf.icv_len = CCMP_MIC_LEN;
340                 if (seq) {
341                         for (i = 0; i < NUM_RX_DATA_QUEUES + 1; i++)
342                                 for (j = 0; j < CCMP_PN_LEN; j++)
343                                         key->u.ccmp.rx_pn[i][j] =
344                                                 seq[CCMP_PN_LEN - j - 1];
345                 }
346                 /*
347                  * Initialize AES key state here as an optimization so that
348                  * it does not need to be initialized for every packet.
349                  */
350                 key->u.ccmp.tfm = ieee80211_aes_key_setup_encrypt(key_data);
351                 if (IS_ERR(key->u.ccmp.tfm)) {
352                         err = PTR_ERR(key->u.ccmp.tfm);
353                         kfree(key);
354                         return ERR_PTR(err);
355                 }
356                 break;
357         case WLAN_CIPHER_SUITE_AES_CMAC:
358                 key->conf.iv_len = 0;
359                 key->conf.icv_len = sizeof(struct ieee80211_mmie);
360                 if (seq)
361                         for (j = 0; j < 6; j++)
362                                 key->u.aes_cmac.rx_pn[j] = seq[6 - j - 1];
363                 /*
364                  * Initialize AES key state here as an optimization so that
365                  * it does not need to be initialized for every packet.
366                  */
367                 key->u.aes_cmac.tfm =
368                         ieee80211_aes_cmac_key_setup(key_data);
369                 if (IS_ERR(key->u.aes_cmac.tfm)) {
370                         err = PTR_ERR(key->u.aes_cmac.tfm);
371                         kfree(key);
372                         return ERR_PTR(err);
373                 }
374                 break;
375         }
376         memcpy(key->conf.key, key_data, key_len);
377         INIT_LIST_HEAD(&key->list);
378
379         return key;
380 }
381
382 static void __ieee80211_key_destroy(struct ieee80211_key *key)
383 {
384         if (!key)
385                 return;
386
387         /*
388          * Synchronize so the TX path can no longer be using
389          * this key before we free/remove it.
390          */
391         synchronize_rcu();
392
393         if (key->local)
394                 ieee80211_key_disable_hw_accel(key);
395
396         if (key->conf.cipher == WLAN_CIPHER_SUITE_CCMP)
397                 ieee80211_aes_key_free(key->u.ccmp.tfm);
398         if (key->conf.cipher == WLAN_CIPHER_SUITE_AES_CMAC)
399                 ieee80211_aes_cmac_key_free(key->u.aes_cmac.tfm);
400         if (key->local) {
401                 ieee80211_debugfs_key_remove(key);
402                 key->local->crypto_tx_tailroom_needed_cnt--;
403         }
404
405         kfree(key);
406 }
407
408 int ieee80211_key_link(struct ieee80211_key *key,
409                        struct ieee80211_sub_if_data *sdata,
410                        struct sta_info *sta)
411 {
412         struct ieee80211_key *old_key;
413         int idx, ret;
414         bool pairwise;
415
416         BUG_ON(!sdata);
417         BUG_ON(!key);
418
419         pairwise = key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE;
420         idx = key->conf.keyidx;
421         key->local = sdata->local;
422         key->sdata = sdata;
423         key->sta = sta;
424
425         if (sta) {
426                 /*
427                  * some hardware cannot handle TKIP with QoS, so
428                  * we indicate whether QoS could be in use.
429                  */
430                 if (test_sta_flags(sta, WLAN_STA_WME))
431                         key->conf.flags |= IEEE80211_KEY_FLAG_WMM_STA;
432         } else {
433                 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
434                         struct sta_info *ap;
435
436                         /*
437                          * We're getting a sta pointer in, so must be under
438                          * appropriate locking for sta_info_get().
439                          */
440
441                         /* same here, the AP could be using QoS */
442                         ap = sta_info_get(key->sdata, key->sdata->u.mgd.bssid);
443                         if (ap) {
444                                 if (test_sta_flags(ap, WLAN_STA_WME))
445                                         key->conf.flags |=
446                                                 IEEE80211_KEY_FLAG_WMM_STA;
447                         }
448                 }
449         }
450
451         mutex_lock(&sdata->local->key_mtx);
452
453         if (sta && pairwise)
454                 old_key = sta->ptk;
455         else if (sta)
456                 old_key = sta->gtk[idx];
457         else
458                 old_key = sdata->keys[idx];
459
460         __ieee80211_key_replace(sdata, sta, pairwise, old_key, key);
461         __ieee80211_key_destroy(old_key);
462
463         ieee80211_debugfs_key_add(key);
464
465         key->local->crypto_tx_tailroom_needed_cnt++;
466
467         ret = ieee80211_key_enable_hw_accel(key);
468
469         mutex_unlock(&sdata->local->key_mtx);
470
471         return ret;
472 }
473
474 void __ieee80211_key_free(struct ieee80211_key *key)
475 {
476         if (!key)
477                 return;
478
479         /*
480          * Replace key with nothingness if it was ever used.
481          */
482         if (key->sdata)
483                 __ieee80211_key_replace(key->sdata, key->sta,
484                                 key->conf.flags & IEEE80211_KEY_FLAG_PAIRWISE,
485                                 key, NULL);
486         __ieee80211_key_destroy(key);
487 }
488
489 void ieee80211_key_free(struct ieee80211_local *local,
490                         struct ieee80211_key *key)
491 {
492         mutex_lock(&local->key_mtx);
493         __ieee80211_key_free(key);
494         mutex_unlock(&local->key_mtx);
495 }
496
497 void ieee80211_enable_keys(struct ieee80211_sub_if_data *sdata)
498 {
499         struct ieee80211_key *key;
500
501         ASSERT_RTNL();
502
503         if (WARN_ON(!ieee80211_sdata_running(sdata)))
504                 return;
505
506         mutex_lock(&sdata->local->key_mtx);
507
508         sdata->local->crypto_tx_tailroom_needed_cnt = 0;
509
510         list_for_each_entry(key, &sdata->key_list, list) {
511                 sdata->local->crypto_tx_tailroom_needed_cnt++;
512                 ieee80211_key_enable_hw_accel(key);
513         }
514
515         mutex_unlock(&sdata->local->key_mtx);
516 }
517
518 void ieee80211_disable_keys(struct ieee80211_sub_if_data *sdata)
519 {
520         struct ieee80211_key *key;
521
522         ASSERT_RTNL();
523
524         mutex_lock(&sdata->local->key_mtx);
525
526         list_for_each_entry(key, &sdata->key_list, list)
527                 ieee80211_key_disable_hw_accel(key);
528
529         mutex_unlock(&sdata->local->key_mtx);
530 }
531
532 void ieee80211_free_keys(struct ieee80211_sub_if_data *sdata)
533 {
534         struct ieee80211_key *key, *tmp;
535
536         mutex_lock(&sdata->local->key_mtx);
537
538         ieee80211_debugfs_key_remove_mgmt_default(sdata);
539
540         list_for_each_entry_safe(key, tmp, &sdata->key_list, list)
541                 __ieee80211_key_free(key);
542
543         ieee80211_debugfs_key_update_default(sdata);
544
545         mutex_unlock(&sdata->local->key_mtx);
546 }