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 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 <net/mac80211.h> 18 #include "ieee80211_i.h" 19 #include "debugfs_key.h" 20 #include "aes_ccm.h" 21 22 23 /** 24 * DOC: Key handling basics 25 * 26 * Key handling in mac80211 is done based on per-interface (sub_if_data) 27 * keys and per-station keys. Since each station belongs to an interface, 28 * each station key also belongs to that interface. 29 * 30 * Hardware acceleration is done on a best-effort basis, for each key 31 * that is eligible the hardware is asked to enable that key but if 32 * it cannot do that they key is simply kept for software encryption. 33 * There is currently no way of knowing this except by looking into 34 * debugfs. 35 * 36 * All operations here are called under RTNL so no extra locking is 37 * required. 38 * 39 * NOTE: This code requires that sta info *destruction* is done under 40 * RTNL, otherwise it can try to access already freed STA structs 41 * when a STA key is being freed. 42 */ 43 44 static const u8 bcast_addr[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; 45 static const u8 zero_addr[ETH_ALEN]; 46 47 static const u8 *get_mac_for_key(struct ieee80211_key *key) 48 { 49 const u8 *addr = bcast_addr; 50 51 /* 52 * If we're an AP we won't ever receive frames with a non-WEP 53 * group key so we tell the driver that by using the zero MAC 54 * address to indicate a transmit-only key. 55 */ 56 if (key->conf.alg != ALG_WEP && 57 (key->sdata->vif.type == IEEE80211_IF_TYPE_AP || 58 key->sdata->vif.type == IEEE80211_IF_TYPE_VLAN)) 59 addr = zero_addr; 60 61 if (key->sta) 62 addr = key->sta->addr; 63 64 return addr; 65 } 66 67 static void ieee80211_key_enable_hw_accel(struct ieee80211_key *key) 68 { 69 const u8 *addr; 70 int ret; 71 DECLARE_MAC_BUF(mac); 72 73 if (!key->local->ops->set_key) 74 return; 75 76 addr = get_mac_for_key(key); 77 78 ret = key->local->ops->set_key(local_to_hw(key->local), SET_KEY, 79 key->sdata->dev->dev_addr, addr, 80 &key->conf); 81 82 if (!ret) 83 key->flags |= KEY_FLAG_UPLOADED_TO_HARDWARE; 84 85 if (ret && ret != -ENOSPC && ret != -EOPNOTSUPP) 86 printk(KERN_ERR "mac80211-%s: failed to set key " 87 "(%d, %s) to hardware (%d)\n", 88 wiphy_name(key->local->hw.wiphy), 89 key->conf.keyidx, print_mac(mac, addr), ret); 90 } 91 92 static void ieee80211_key_mark_hw_accel_off(struct ieee80211_key *key) 93 { 94 if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE) { 95 key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE; 96 key->flags |= KEY_FLAG_REMOVE_FROM_HARDWARE; 97 } 98 } 99 100 static void ieee80211_key_disable_hw_accel(struct ieee80211_key *key) 101 { 102 const u8 *addr; 103 int ret; 104 DECLARE_MAC_BUF(mac); 105 106 if (!key || !key->local->ops->set_key) 107 return; 108 109 if (!(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE) && 110 !(key->flags & KEY_FLAG_REMOVE_FROM_HARDWARE)) 111 return; 112 113 addr = get_mac_for_key(key); 114 115 ret = key->local->ops->set_key(local_to_hw(key->local), DISABLE_KEY, 116 key->sdata->dev->dev_addr, addr, 117 &key->conf); 118 119 if (ret) 120 printk(KERN_ERR "mac80211-%s: failed to remove key " 121 "(%d, %s) from hardware (%d)\n", 122 wiphy_name(key->local->hw.wiphy), 123 key->conf.keyidx, print_mac(mac, addr), ret); 124 125 key->flags &= ~(KEY_FLAG_UPLOADED_TO_HARDWARE | 126 KEY_FLAG_REMOVE_FROM_HARDWARE); 127 } 128 129 struct ieee80211_key *ieee80211_key_alloc(enum ieee80211_key_alg alg, 130 int idx, 131 size_t key_len, 132 const u8 *key_data) 133 { 134 struct ieee80211_key *key; 135 136 BUG_ON(idx < 0 || idx >= NUM_DEFAULT_KEYS); 137 138 key = kzalloc(sizeof(struct ieee80211_key) + key_len, GFP_KERNEL); 139 if (!key) 140 return NULL; 141 142 /* 143 * Default to software encryption; we'll later upload the 144 * key to the hardware if possible. 145 */ 146 key->conf.flags = 0; 147 key->flags = 0; 148 149 key->conf.alg = alg; 150 key->conf.keyidx = idx; 151 key->conf.keylen = key_len; 152 memcpy(key->conf.key, key_data, key_len); 153 INIT_LIST_HEAD(&key->list); 154 155 if (alg == ALG_CCMP) { 156 /* 157 * Initialize AES key state here as an optimization so that 158 * it does not need to be initialized for every packet. 159 */ 160 key->u.ccmp.tfm = ieee80211_aes_key_setup_encrypt(key_data); 161 if (!key->u.ccmp.tfm) { 162 ieee80211_key_free(key); 163 return NULL; 164 } 165 } 166 167 return key; 168 } 169 170 static void __ieee80211_key_replace(struct ieee80211_sub_if_data *sdata, 171 struct sta_info *sta, 172 struct ieee80211_key *key, 173 struct ieee80211_key *new) 174 { 175 int idx, defkey; 176 177 if (sta) { 178 rcu_assign_pointer(sta->key, new); 179 } else { 180 WARN_ON(new && key && new->conf.keyidx != key->conf.keyidx); 181 182 if (key) 183 idx = key->conf.keyidx; 184 else 185 idx = new->conf.keyidx; 186 187 defkey = key && sdata->default_key == key; 188 189 if (defkey && !new) 190 ieee80211_set_default_key(sdata, -1); 191 192 rcu_assign_pointer(sdata->keys[idx], new); 193 if (new) 194 list_add(&new->list, &sdata->key_list); 195 196 if (defkey && new) 197 ieee80211_set_default_key(sdata, new->conf.keyidx); 198 } 199 200 if (key) { 201 ieee80211_key_mark_hw_accel_off(key); 202 /* 203 * We'll use an empty list to indicate that the key 204 * has already been removed. 205 */ 206 list_del_init(&key->list); 207 } 208 } 209 210 void ieee80211_key_link(struct ieee80211_key *key, 211 struct ieee80211_sub_if_data *sdata, 212 struct sta_info *sta) 213 { 214 struct ieee80211_key *old_key; 215 int idx; 216 217 ASSERT_RTNL(); 218 might_sleep(); 219 220 BUG_ON(!sdata); 221 BUG_ON(!key); 222 223 idx = key->conf.keyidx; 224 key->local = sdata->local; 225 key->sdata = sdata; 226 key->sta = sta; 227 228 ieee80211_debugfs_key_add(key->local, key); 229 230 if (sta) { 231 ieee80211_debugfs_key_sta_link(key, sta); 232 233 /* 234 * some hardware cannot handle TKIP with QoS, so 235 * we indicate whether QoS could be in use. 236 */ 237 if (sta->flags & WLAN_STA_WME) 238 key->conf.flags |= IEEE80211_KEY_FLAG_WMM_STA; 239 } else { 240 if (sdata->vif.type == IEEE80211_IF_TYPE_STA) { 241 struct sta_info *ap; 242 243 rcu_read_lock(); 244 245 /* same here, the AP could be using QoS */ 246 ap = sta_info_get(key->local, key->sdata->u.sta.bssid); 247 if (ap) { 248 if (ap->flags & WLAN_STA_WME) 249 key->conf.flags |= 250 IEEE80211_KEY_FLAG_WMM_STA; 251 } 252 253 rcu_read_unlock(); 254 } 255 } 256 257 if (sta) 258 old_key = sta->key; 259 else 260 old_key = sdata->keys[idx]; 261 262 __ieee80211_key_replace(sdata, sta, old_key, key); 263 264 if (old_key) { 265 synchronize_rcu(); 266 ieee80211_key_free(old_key); 267 } 268 269 if (netif_running(sdata->dev)) 270 ieee80211_key_enable_hw_accel(key); 271 } 272 273 void ieee80211_key_free(struct ieee80211_key *key) 274 { 275 ASSERT_RTNL(); 276 might_sleep(); 277 278 if (!key) 279 return; 280 281 if (key->sdata) { 282 /* 283 * Replace key with nothingness. 284 * 285 * Because other code may have key reference (RCU protected) 286 * right now, we then wait for a grace period before freeing 287 * it. 288 * An empty list indicates it was never added to the key list 289 * or has been removed already. It may, however, still be in 290 * hardware for acceleration. 291 */ 292 if (!list_empty(&key->list)) 293 __ieee80211_key_replace(key->sdata, key->sta, 294 key, NULL); 295 296 /* 297 * Do NOT remove this without looking at sta_info_destroy() 298 */ 299 synchronize_rcu(); 300 301 /* 302 * Remove from hwaccel if appropriate, this will 303 * only happen when the key is actually unlinked, 304 * it will already be done when the key was replaced. 305 */ 306 ieee80211_key_disable_hw_accel(key); 307 } 308 309 if (key->conf.alg == ALG_CCMP) 310 ieee80211_aes_key_free(key->u.ccmp.tfm); 311 ieee80211_debugfs_key_remove(key); 312 313 kfree(key); 314 } 315 316 void ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata, int idx) 317 { 318 struct ieee80211_key *key = NULL; 319 320 if (idx >= 0 && idx < NUM_DEFAULT_KEYS) 321 key = sdata->keys[idx]; 322 323 if (sdata->default_key != key) { 324 ieee80211_debugfs_key_remove_default(sdata); 325 326 rcu_assign_pointer(sdata->default_key, key); 327 328 if (sdata->default_key) 329 ieee80211_debugfs_key_add_default(sdata); 330 } 331 } 332 333 void ieee80211_free_keys(struct ieee80211_sub_if_data *sdata) 334 { 335 struct ieee80211_key *key, *tmp; 336 LIST_HEAD(tmp_list); 337 338 ASSERT_RTNL(); 339 might_sleep(); 340 341 list_for_each_entry_safe(key, tmp, &sdata->key_list, list) 342 ieee80211_key_free(key); 343 } 344 345 void ieee80211_enable_keys(struct ieee80211_sub_if_data *sdata) 346 { 347 struct ieee80211_key *key; 348 349 ASSERT_RTNL(); 350 might_sleep(); 351 352 if (WARN_ON(!netif_running(sdata->dev))) 353 return; 354 355 list_for_each_entry(key, &sdata->key_list, list) 356 ieee80211_key_enable_hw_accel(key); 357 } 358 359 void ieee80211_disable_keys(struct ieee80211_sub_if_data *sdata) 360 { 361 struct ieee80211_key *key; 362 363 ASSERT_RTNL(); 364 might_sleep(); 365 366 list_for_each_entry(key, &sdata->key_list, list) 367 ieee80211_key_disable_hw_accel(key); 368 } 369