xref: /linux/net/mac802154/llsec.c (revision 79790b6818e96c58fe2bffee1b418c16e64e7b80)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) 2014 Fraunhofer ITWM
4  *
5  * Written by:
6  * Phoebe Buckheister <phoebe.buckheister@itwm.fraunhofer.de>
7  */
8 
9 #include <linux/err.h>
10 #include <linux/bug.h>
11 #include <linux/completion.h>
12 #include <linux/ieee802154.h>
13 #include <linux/rculist.h>
14 
15 #include <crypto/aead.h>
16 #include <crypto/skcipher.h>
17 
18 #include "ieee802154_i.h"
19 #include "llsec.h"
20 
21 static void llsec_key_put(struct mac802154_llsec_key *key);
22 static bool llsec_key_id_equal(const struct ieee802154_llsec_key_id *a,
23 			       const struct ieee802154_llsec_key_id *b);
24 
25 static void llsec_dev_free(struct mac802154_llsec_device *dev);
26 
mac802154_llsec_init(struct mac802154_llsec * sec)27 void mac802154_llsec_init(struct mac802154_llsec *sec)
28 {
29 	memset(sec, 0, sizeof(*sec));
30 
31 	memset(&sec->params.default_key_source, 0xFF, IEEE802154_ADDR_LEN);
32 
33 	INIT_LIST_HEAD(&sec->table.security_levels);
34 	INIT_LIST_HEAD(&sec->table.devices);
35 	INIT_LIST_HEAD(&sec->table.keys);
36 	hash_init(sec->devices_short);
37 	hash_init(sec->devices_hw);
38 	rwlock_init(&sec->lock);
39 }
40 
mac802154_llsec_destroy(struct mac802154_llsec * sec)41 void mac802154_llsec_destroy(struct mac802154_llsec *sec)
42 {
43 	struct ieee802154_llsec_seclevel *sl, *sn;
44 	struct ieee802154_llsec_device *dev, *dn;
45 	struct ieee802154_llsec_key_entry *key, *kn;
46 
47 	list_for_each_entry_safe(sl, sn, &sec->table.security_levels, list) {
48 		struct mac802154_llsec_seclevel *msl;
49 
50 		msl = container_of(sl, struct mac802154_llsec_seclevel, level);
51 		list_del(&sl->list);
52 		kfree_sensitive(msl);
53 	}
54 
55 	list_for_each_entry_safe(dev, dn, &sec->table.devices, list) {
56 		struct mac802154_llsec_device *mdev;
57 
58 		mdev = container_of(dev, struct mac802154_llsec_device, dev);
59 		list_del(&dev->list);
60 		llsec_dev_free(mdev);
61 	}
62 
63 	list_for_each_entry_safe(key, kn, &sec->table.keys, list) {
64 		struct mac802154_llsec_key *mkey;
65 
66 		mkey = container_of(key->key, struct mac802154_llsec_key, key);
67 		list_del(&key->list);
68 		llsec_key_put(mkey);
69 		kfree_sensitive(key);
70 	}
71 }
72 
mac802154_llsec_get_params(struct mac802154_llsec * sec,struct ieee802154_llsec_params * params)73 int mac802154_llsec_get_params(struct mac802154_llsec *sec,
74 			       struct ieee802154_llsec_params *params)
75 {
76 	read_lock_bh(&sec->lock);
77 	*params = sec->params;
78 	read_unlock_bh(&sec->lock);
79 
80 	return 0;
81 }
82 
mac802154_llsec_set_params(struct mac802154_llsec * sec,const struct ieee802154_llsec_params * params,int changed)83 int mac802154_llsec_set_params(struct mac802154_llsec *sec,
84 			       const struct ieee802154_llsec_params *params,
85 			       int changed)
86 {
87 	write_lock_bh(&sec->lock);
88 
89 	if (changed & IEEE802154_LLSEC_PARAM_ENABLED)
90 		sec->params.enabled = params->enabled;
91 	if (changed & IEEE802154_LLSEC_PARAM_FRAME_COUNTER)
92 		sec->params.frame_counter = params->frame_counter;
93 	if (changed & IEEE802154_LLSEC_PARAM_OUT_LEVEL)
94 		sec->params.out_level = params->out_level;
95 	if (changed & IEEE802154_LLSEC_PARAM_OUT_KEY)
96 		sec->params.out_key = params->out_key;
97 	if (changed & IEEE802154_LLSEC_PARAM_KEY_SOURCE)
98 		sec->params.default_key_source = params->default_key_source;
99 	if (changed & IEEE802154_LLSEC_PARAM_PAN_ID)
100 		sec->params.pan_id = params->pan_id;
101 	if (changed & IEEE802154_LLSEC_PARAM_HWADDR)
102 		sec->params.hwaddr = params->hwaddr;
103 	if (changed & IEEE802154_LLSEC_PARAM_COORD_HWADDR)
104 		sec->params.coord_hwaddr = params->coord_hwaddr;
105 	if (changed & IEEE802154_LLSEC_PARAM_COORD_SHORTADDR)
106 		sec->params.coord_shortaddr = params->coord_shortaddr;
107 
108 	write_unlock_bh(&sec->lock);
109 
110 	return 0;
111 }
112 
113 static struct mac802154_llsec_key*
llsec_key_alloc(const struct ieee802154_llsec_key * template)114 llsec_key_alloc(const struct ieee802154_llsec_key *template)
115 {
116 	const int authsizes[3] = { 4, 8, 16 };
117 	struct mac802154_llsec_key *key;
118 	int i;
119 
120 	key = kzalloc(sizeof(*key), GFP_KERNEL);
121 	if (!key)
122 		return NULL;
123 
124 	kref_init(&key->ref);
125 	key->key = *template;
126 
127 	BUILD_BUG_ON(ARRAY_SIZE(authsizes) != ARRAY_SIZE(key->tfm));
128 
129 	for (i = 0; i < ARRAY_SIZE(key->tfm); i++) {
130 		key->tfm[i] = crypto_alloc_aead("ccm(aes)", 0,
131 						CRYPTO_ALG_ASYNC);
132 		if (IS_ERR(key->tfm[i]))
133 			goto err_tfm;
134 		if (crypto_aead_setkey(key->tfm[i], template->key,
135 				       IEEE802154_LLSEC_KEY_SIZE))
136 			goto err_tfm;
137 		if (crypto_aead_setauthsize(key->tfm[i], authsizes[i]))
138 			goto err_tfm;
139 	}
140 
141 	key->tfm0 = crypto_alloc_sync_skcipher("ctr(aes)", 0, 0);
142 	if (IS_ERR(key->tfm0))
143 		goto err_tfm;
144 
145 	if (crypto_sync_skcipher_setkey(key->tfm0, template->key,
146 				   IEEE802154_LLSEC_KEY_SIZE))
147 		goto err_tfm0;
148 
149 	return key;
150 
151 err_tfm0:
152 	crypto_free_sync_skcipher(key->tfm0);
153 err_tfm:
154 	for (i = 0; i < ARRAY_SIZE(key->tfm); i++)
155 		if (!IS_ERR_OR_NULL(key->tfm[i]))
156 			crypto_free_aead(key->tfm[i]);
157 
158 	kfree_sensitive(key);
159 	return NULL;
160 }
161 
llsec_key_release(struct kref * ref)162 static void llsec_key_release(struct kref *ref)
163 {
164 	struct mac802154_llsec_key *key;
165 	int i;
166 
167 	key = container_of(ref, struct mac802154_llsec_key, ref);
168 
169 	for (i = 0; i < ARRAY_SIZE(key->tfm); i++)
170 		crypto_free_aead(key->tfm[i]);
171 
172 	crypto_free_sync_skcipher(key->tfm0);
173 	kfree_sensitive(key);
174 }
175 
176 static struct mac802154_llsec_key*
llsec_key_get(struct mac802154_llsec_key * key)177 llsec_key_get(struct mac802154_llsec_key *key)
178 {
179 	kref_get(&key->ref);
180 	return key;
181 }
182 
llsec_key_put(struct mac802154_llsec_key * key)183 static void llsec_key_put(struct mac802154_llsec_key *key)
184 {
185 	kref_put(&key->ref, llsec_key_release);
186 }
187 
llsec_key_id_equal(const struct ieee802154_llsec_key_id * a,const struct ieee802154_llsec_key_id * b)188 static bool llsec_key_id_equal(const struct ieee802154_llsec_key_id *a,
189 			       const struct ieee802154_llsec_key_id *b)
190 {
191 	if (a->mode != b->mode)
192 		return false;
193 
194 	if (a->mode == IEEE802154_SCF_KEY_IMPLICIT)
195 		return ieee802154_addr_equal(&a->device_addr, &b->device_addr);
196 
197 	if (a->id != b->id)
198 		return false;
199 
200 	switch (a->mode) {
201 	case IEEE802154_SCF_KEY_INDEX:
202 		return true;
203 	case IEEE802154_SCF_KEY_SHORT_INDEX:
204 		return a->short_source == b->short_source;
205 	case IEEE802154_SCF_KEY_HW_INDEX:
206 		return a->extended_source == b->extended_source;
207 	}
208 
209 	return false;
210 }
211 
mac802154_llsec_key_add(struct mac802154_llsec * sec,const struct ieee802154_llsec_key_id * id,const struct ieee802154_llsec_key * key)212 int mac802154_llsec_key_add(struct mac802154_llsec *sec,
213 			    const struct ieee802154_llsec_key_id *id,
214 			    const struct ieee802154_llsec_key *key)
215 {
216 	struct mac802154_llsec_key *mkey = NULL;
217 	struct ieee802154_llsec_key_entry *pos, *new;
218 
219 	if (!(key->frame_types & (1 << IEEE802154_FC_TYPE_MAC_CMD)) &&
220 	    key->cmd_frame_ids)
221 		return -EINVAL;
222 
223 	list_for_each_entry(pos, &sec->table.keys, list) {
224 		if (llsec_key_id_equal(&pos->id, id))
225 			return -EEXIST;
226 
227 		if (memcmp(pos->key->key, key->key,
228 			   IEEE802154_LLSEC_KEY_SIZE))
229 			continue;
230 
231 		mkey = container_of(pos->key, struct mac802154_llsec_key, key);
232 
233 		/* Don't allow multiple instances of the same AES key to have
234 		 * different allowed frame types/command frame ids, as this is
235 		 * not possible in the 802.15.4 PIB.
236 		 */
237 		if (pos->key->frame_types != key->frame_types ||
238 		    pos->key->cmd_frame_ids != key->cmd_frame_ids)
239 			return -EEXIST;
240 
241 		break;
242 	}
243 
244 	new = kzalloc(sizeof(*new), GFP_KERNEL);
245 	if (!new)
246 		return -ENOMEM;
247 
248 	if (!mkey)
249 		mkey = llsec_key_alloc(key);
250 	else
251 		mkey = llsec_key_get(mkey);
252 
253 	if (!mkey)
254 		goto fail;
255 
256 	new->id = *id;
257 	new->key = &mkey->key;
258 
259 	list_add_rcu(&new->list, &sec->table.keys);
260 
261 	return 0;
262 
263 fail:
264 	kfree_sensitive(new);
265 	return -ENOMEM;
266 }
267 
mac802154_llsec_key_del_rcu(struct rcu_head * rcu)268 static void mac802154_llsec_key_del_rcu(struct rcu_head *rcu)
269 {
270 	struct ieee802154_llsec_key_entry *pos;
271 	struct mac802154_llsec_key *mkey;
272 
273 	pos = container_of(rcu, struct ieee802154_llsec_key_entry, rcu);
274 	mkey = container_of(pos->key, struct mac802154_llsec_key, key);
275 
276 	llsec_key_put(mkey);
277 	kfree_sensitive(pos);
278 }
279 
mac802154_llsec_key_del(struct mac802154_llsec * sec,const struct ieee802154_llsec_key_id * key)280 int mac802154_llsec_key_del(struct mac802154_llsec *sec,
281 			    const struct ieee802154_llsec_key_id *key)
282 {
283 	struct ieee802154_llsec_key_entry *pos;
284 
285 	list_for_each_entry(pos, &sec->table.keys, list) {
286 		if (llsec_key_id_equal(&pos->id, key)) {
287 			list_del_rcu(&pos->list);
288 			call_rcu(&pos->rcu, mac802154_llsec_key_del_rcu);
289 			return 0;
290 		}
291 	}
292 
293 	return -ENOENT;
294 }
295 
llsec_dev_use_shortaddr(__le16 short_addr)296 static bool llsec_dev_use_shortaddr(__le16 short_addr)
297 {
298 	return short_addr != cpu_to_le16(IEEE802154_ADDR_UNDEF) &&
299 		short_addr != cpu_to_le16(0xffff);
300 }
301 
llsec_dev_hash_short(__le16 short_addr,__le16 pan_id)302 static u32 llsec_dev_hash_short(__le16 short_addr, __le16 pan_id)
303 {
304 	return ((__force u16)short_addr) << 16 | (__force u16)pan_id;
305 }
306 
llsec_dev_hash_long(__le64 hwaddr)307 static u64 llsec_dev_hash_long(__le64 hwaddr)
308 {
309 	return (__force u64)hwaddr;
310 }
311 
312 static struct mac802154_llsec_device*
llsec_dev_find_short(struct mac802154_llsec * sec,__le16 short_addr,__le16 pan_id)313 llsec_dev_find_short(struct mac802154_llsec *sec, __le16 short_addr,
314 		     __le16 pan_id)
315 {
316 	struct mac802154_llsec_device *dev;
317 	u32 key = llsec_dev_hash_short(short_addr, pan_id);
318 
319 	hash_for_each_possible_rcu(sec->devices_short, dev, bucket_s, key) {
320 		if (dev->dev.short_addr == short_addr &&
321 		    dev->dev.pan_id == pan_id)
322 			return dev;
323 	}
324 
325 	return NULL;
326 }
327 
328 static struct mac802154_llsec_device*
llsec_dev_find_long(struct mac802154_llsec * sec,__le64 hwaddr)329 llsec_dev_find_long(struct mac802154_llsec *sec, __le64 hwaddr)
330 {
331 	struct mac802154_llsec_device *dev;
332 	u64 key = llsec_dev_hash_long(hwaddr);
333 
334 	hash_for_each_possible_rcu(sec->devices_hw, dev, bucket_hw, key) {
335 		if (dev->dev.hwaddr == hwaddr)
336 			return dev;
337 	}
338 
339 	return NULL;
340 }
341 
llsec_dev_free(struct mac802154_llsec_device * dev)342 static void llsec_dev_free(struct mac802154_llsec_device *dev)
343 {
344 	struct ieee802154_llsec_device_key *pos, *pn;
345 	struct mac802154_llsec_device_key *devkey;
346 
347 	list_for_each_entry_safe(pos, pn, &dev->dev.keys, list) {
348 		devkey = container_of(pos, struct mac802154_llsec_device_key,
349 				      devkey);
350 
351 		list_del(&pos->list);
352 		kfree_sensitive(devkey);
353 	}
354 
355 	kfree_sensitive(dev);
356 }
357 
mac802154_llsec_dev_add(struct mac802154_llsec * sec,const struct ieee802154_llsec_device * dev)358 int mac802154_llsec_dev_add(struct mac802154_llsec *sec,
359 			    const struct ieee802154_llsec_device *dev)
360 {
361 	struct mac802154_llsec_device *entry;
362 	u32 skey = llsec_dev_hash_short(dev->short_addr, dev->pan_id);
363 	u64 hwkey = llsec_dev_hash_long(dev->hwaddr);
364 
365 	BUILD_BUG_ON(sizeof(hwkey) != IEEE802154_ADDR_LEN);
366 
367 	if ((llsec_dev_use_shortaddr(dev->short_addr) &&
368 	     llsec_dev_find_short(sec, dev->short_addr, dev->pan_id)) ||
369 	     llsec_dev_find_long(sec, dev->hwaddr))
370 		return -EEXIST;
371 
372 	entry = kmalloc(sizeof(*entry), GFP_KERNEL);
373 	if (!entry)
374 		return -ENOMEM;
375 
376 	entry->dev = *dev;
377 	spin_lock_init(&entry->lock);
378 	INIT_LIST_HEAD(&entry->dev.keys);
379 
380 	if (llsec_dev_use_shortaddr(dev->short_addr))
381 		hash_add_rcu(sec->devices_short, &entry->bucket_s, skey);
382 	else
383 		INIT_HLIST_NODE(&entry->bucket_s);
384 
385 	hash_add_rcu(sec->devices_hw, &entry->bucket_hw, hwkey);
386 	list_add_tail_rcu(&entry->dev.list, &sec->table.devices);
387 
388 	return 0;
389 }
390 
llsec_dev_free_rcu(struct rcu_head * rcu)391 static void llsec_dev_free_rcu(struct rcu_head *rcu)
392 {
393 	llsec_dev_free(container_of(rcu, struct mac802154_llsec_device, rcu));
394 }
395 
mac802154_llsec_dev_del(struct mac802154_llsec * sec,__le64 device_addr)396 int mac802154_llsec_dev_del(struct mac802154_llsec *sec, __le64 device_addr)
397 {
398 	struct mac802154_llsec_device *pos;
399 
400 	pos = llsec_dev_find_long(sec, device_addr);
401 	if (!pos)
402 		return -ENOENT;
403 
404 	hash_del_rcu(&pos->bucket_s);
405 	hash_del_rcu(&pos->bucket_hw);
406 	list_del_rcu(&pos->dev.list);
407 	call_rcu(&pos->rcu, llsec_dev_free_rcu);
408 
409 	return 0;
410 }
411 
412 static struct mac802154_llsec_device_key*
llsec_devkey_find(struct mac802154_llsec_device * dev,const struct ieee802154_llsec_key_id * key)413 llsec_devkey_find(struct mac802154_llsec_device *dev,
414 		  const struct ieee802154_llsec_key_id *key)
415 {
416 	struct ieee802154_llsec_device_key *devkey;
417 
418 	list_for_each_entry_rcu(devkey, &dev->dev.keys, list) {
419 		if (!llsec_key_id_equal(key, &devkey->key_id))
420 			continue;
421 
422 		return container_of(devkey, struct mac802154_llsec_device_key,
423 				    devkey);
424 	}
425 
426 	return NULL;
427 }
428 
mac802154_llsec_devkey_add(struct mac802154_llsec * sec,__le64 dev_addr,const struct ieee802154_llsec_device_key * key)429 int mac802154_llsec_devkey_add(struct mac802154_llsec *sec,
430 			       __le64 dev_addr,
431 			       const struct ieee802154_llsec_device_key *key)
432 {
433 	struct mac802154_llsec_device *dev;
434 	struct mac802154_llsec_device_key *devkey;
435 
436 	dev = llsec_dev_find_long(sec, dev_addr);
437 
438 	if (!dev)
439 		return -ENOENT;
440 
441 	if (llsec_devkey_find(dev, &key->key_id))
442 		return -EEXIST;
443 
444 	devkey = kmalloc(sizeof(*devkey), GFP_KERNEL);
445 	if (!devkey)
446 		return -ENOMEM;
447 
448 	devkey->devkey = *key;
449 	list_add_tail_rcu(&devkey->devkey.list, &dev->dev.keys);
450 	return 0;
451 }
452 
mac802154_llsec_devkey_del(struct mac802154_llsec * sec,__le64 dev_addr,const struct ieee802154_llsec_device_key * key)453 int mac802154_llsec_devkey_del(struct mac802154_llsec *sec,
454 			       __le64 dev_addr,
455 			       const struct ieee802154_llsec_device_key *key)
456 {
457 	struct mac802154_llsec_device *dev;
458 	struct mac802154_llsec_device_key *devkey;
459 
460 	dev = llsec_dev_find_long(sec, dev_addr);
461 
462 	if (!dev)
463 		return -ENOENT;
464 
465 	devkey = llsec_devkey_find(dev, &key->key_id);
466 	if (!devkey)
467 		return -ENOENT;
468 
469 	list_del_rcu(&devkey->devkey.list);
470 	kfree_rcu(devkey, rcu);
471 	return 0;
472 }
473 
474 static struct mac802154_llsec_seclevel*
llsec_find_seclevel(const struct mac802154_llsec * sec,const struct ieee802154_llsec_seclevel * sl)475 llsec_find_seclevel(const struct mac802154_llsec *sec,
476 		    const struct ieee802154_llsec_seclevel *sl)
477 {
478 	struct ieee802154_llsec_seclevel *pos;
479 
480 	list_for_each_entry(pos, &sec->table.security_levels, list) {
481 		if (pos->frame_type != sl->frame_type ||
482 		    (pos->frame_type == IEEE802154_FC_TYPE_MAC_CMD &&
483 		     pos->cmd_frame_id != sl->cmd_frame_id) ||
484 		    pos->device_override != sl->device_override ||
485 		    pos->sec_levels != sl->sec_levels)
486 			continue;
487 
488 		return container_of(pos, struct mac802154_llsec_seclevel,
489 				    level);
490 	}
491 
492 	return NULL;
493 }
494 
mac802154_llsec_seclevel_add(struct mac802154_llsec * sec,const struct ieee802154_llsec_seclevel * sl)495 int mac802154_llsec_seclevel_add(struct mac802154_llsec *sec,
496 				 const struct ieee802154_llsec_seclevel *sl)
497 {
498 	struct mac802154_llsec_seclevel *entry;
499 
500 	if (llsec_find_seclevel(sec, sl))
501 		return -EEXIST;
502 
503 	entry = kmalloc(sizeof(*entry), GFP_KERNEL);
504 	if (!entry)
505 		return -ENOMEM;
506 
507 	entry->level = *sl;
508 
509 	list_add_tail_rcu(&entry->level.list, &sec->table.security_levels);
510 
511 	return 0;
512 }
513 
mac802154_llsec_seclevel_del(struct mac802154_llsec * sec,const struct ieee802154_llsec_seclevel * sl)514 int mac802154_llsec_seclevel_del(struct mac802154_llsec *sec,
515 				 const struct ieee802154_llsec_seclevel *sl)
516 {
517 	struct mac802154_llsec_seclevel *pos;
518 
519 	pos = llsec_find_seclevel(sec, sl);
520 	if (!pos)
521 		return -ENOENT;
522 
523 	list_del_rcu(&pos->level.list);
524 	kfree_rcu(pos, rcu);
525 
526 	return 0;
527 }
528 
llsec_recover_addr(struct mac802154_llsec * sec,struct ieee802154_addr * addr)529 static int llsec_recover_addr(struct mac802154_llsec *sec,
530 			      struct ieee802154_addr *addr)
531 {
532 	__le16 caddr = sec->params.coord_shortaddr;
533 
534 	addr->pan_id = sec->params.pan_id;
535 
536 	if (caddr == cpu_to_le16(IEEE802154_ADDR_BROADCAST)) {
537 		return -EINVAL;
538 	} else if (caddr == cpu_to_le16(IEEE802154_ADDR_UNDEF)) {
539 		addr->extended_addr = sec->params.coord_hwaddr;
540 		addr->mode = IEEE802154_ADDR_LONG;
541 	} else {
542 		addr->short_addr = sec->params.coord_shortaddr;
543 		addr->mode = IEEE802154_ADDR_SHORT;
544 	}
545 
546 	return 0;
547 }
548 
549 static struct mac802154_llsec_key*
llsec_lookup_key(struct mac802154_llsec * sec,const struct ieee802154_hdr * hdr,const struct ieee802154_addr * addr,struct ieee802154_llsec_key_id * key_id)550 llsec_lookup_key(struct mac802154_llsec *sec,
551 		 const struct ieee802154_hdr *hdr,
552 		 const struct ieee802154_addr *addr,
553 		 struct ieee802154_llsec_key_id *key_id)
554 {
555 	struct ieee802154_addr devaddr = *addr;
556 	u8 key_id_mode = hdr->sec.key_id_mode;
557 	struct ieee802154_llsec_key_entry *key_entry;
558 	struct mac802154_llsec_key *key;
559 
560 	if (key_id_mode == IEEE802154_SCF_KEY_IMPLICIT &&
561 	    devaddr.mode == IEEE802154_ADDR_NONE) {
562 		if (hdr->fc.type == IEEE802154_FC_TYPE_BEACON) {
563 			devaddr.extended_addr = sec->params.coord_hwaddr;
564 			devaddr.mode = IEEE802154_ADDR_LONG;
565 		} else if (llsec_recover_addr(sec, &devaddr) < 0) {
566 			return NULL;
567 		}
568 	}
569 
570 	list_for_each_entry_rcu(key_entry, &sec->table.keys, list) {
571 		const struct ieee802154_llsec_key_id *id = &key_entry->id;
572 
573 		if (!(key_entry->key->frame_types & BIT(hdr->fc.type)))
574 			continue;
575 
576 		if (id->mode != key_id_mode)
577 			continue;
578 
579 		if (key_id_mode == IEEE802154_SCF_KEY_IMPLICIT) {
580 			if (ieee802154_addr_equal(&devaddr, &id->device_addr))
581 				goto found;
582 		} else {
583 			if (id->id != hdr->sec.key_id)
584 				continue;
585 
586 			if ((key_id_mode == IEEE802154_SCF_KEY_INDEX) ||
587 			    (key_id_mode == IEEE802154_SCF_KEY_SHORT_INDEX &&
588 			     id->short_source == hdr->sec.short_src) ||
589 			    (key_id_mode == IEEE802154_SCF_KEY_HW_INDEX &&
590 			     id->extended_source == hdr->sec.extended_src))
591 				goto found;
592 		}
593 	}
594 
595 	return NULL;
596 
597 found:
598 	key = container_of(key_entry->key, struct mac802154_llsec_key, key);
599 	if (key_id)
600 		*key_id = key_entry->id;
601 	return llsec_key_get(key);
602 }
603 
llsec_geniv(u8 iv[16],__le64 addr,const struct ieee802154_sechdr * sec)604 static void llsec_geniv(u8 iv[16], __le64 addr,
605 			const struct ieee802154_sechdr *sec)
606 {
607 	__be64 addr_bytes = (__force __be64) swab64((__force u64) addr);
608 	__be32 frame_counter = (__force __be32) swab32((__force u32) sec->frame_counter);
609 
610 	iv[0] = 1; /* L' = L - 1 = 1 */
611 	memcpy(iv + 1, &addr_bytes, sizeof(addr_bytes));
612 	memcpy(iv + 9, &frame_counter, sizeof(frame_counter));
613 	iv[13] = sec->level;
614 	iv[14] = 0;
615 	iv[15] = 1;
616 }
617 
618 static int
llsec_do_encrypt_unauth(struct sk_buff * skb,const struct mac802154_llsec * sec,const struct ieee802154_hdr * hdr,struct mac802154_llsec_key * key)619 llsec_do_encrypt_unauth(struct sk_buff *skb, const struct mac802154_llsec *sec,
620 			const struct ieee802154_hdr *hdr,
621 			struct mac802154_llsec_key *key)
622 {
623 	u8 iv[16];
624 	struct scatterlist src;
625 	SYNC_SKCIPHER_REQUEST_ON_STACK(req, key->tfm0);
626 	int err, datalen;
627 	unsigned char *data;
628 
629 	llsec_geniv(iv, sec->params.hwaddr, &hdr->sec);
630 	/* Compute data payload offset and data length */
631 	data = skb_mac_header(skb) + skb->mac_len;
632 	datalen = skb_tail_pointer(skb) - data;
633 	sg_init_one(&src, data, datalen);
634 
635 	skcipher_request_set_sync_tfm(req, key->tfm0);
636 	skcipher_request_set_callback(req, 0, NULL, NULL);
637 	skcipher_request_set_crypt(req, &src, &src, datalen, iv);
638 	err = crypto_skcipher_encrypt(req);
639 	skcipher_request_zero(req);
640 	return err;
641 }
642 
643 static struct crypto_aead*
llsec_tfm_by_len(struct mac802154_llsec_key * key,int authlen)644 llsec_tfm_by_len(struct mac802154_llsec_key *key, int authlen)
645 {
646 	int i;
647 
648 	for (i = 0; i < ARRAY_SIZE(key->tfm); i++)
649 		if (crypto_aead_authsize(key->tfm[i]) == authlen)
650 			return key->tfm[i];
651 
652 	BUG();
653 }
654 
655 static int
llsec_do_encrypt_auth(struct sk_buff * skb,const struct mac802154_llsec * sec,const struct ieee802154_hdr * hdr,struct mac802154_llsec_key * key)656 llsec_do_encrypt_auth(struct sk_buff *skb, const struct mac802154_llsec *sec,
657 		      const struct ieee802154_hdr *hdr,
658 		      struct mac802154_llsec_key *key)
659 {
660 	u8 iv[16];
661 	unsigned char *data;
662 	int authlen, assoclen, datalen, rc;
663 	struct scatterlist sg;
664 	struct aead_request *req;
665 
666 	authlen = ieee802154_sechdr_authtag_len(&hdr->sec);
667 	llsec_geniv(iv, sec->params.hwaddr, &hdr->sec);
668 
669 	req = aead_request_alloc(llsec_tfm_by_len(key, authlen), GFP_ATOMIC);
670 	if (!req)
671 		return -ENOMEM;
672 
673 	assoclen = skb->mac_len;
674 
675 	data = skb_mac_header(skb) + skb->mac_len;
676 	datalen = skb_tail_pointer(skb) - data;
677 
678 	skb_put(skb, authlen);
679 
680 	sg_init_one(&sg, skb_mac_header(skb), assoclen + datalen + authlen);
681 
682 	if (!(hdr->sec.level & IEEE802154_SCF_SECLEVEL_ENC)) {
683 		assoclen += datalen;
684 		datalen = 0;
685 	}
686 
687 	aead_request_set_callback(req, 0, NULL, NULL);
688 	aead_request_set_crypt(req, &sg, &sg, datalen, iv);
689 	aead_request_set_ad(req, assoclen);
690 
691 	rc = crypto_aead_encrypt(req);
692 
693 	kfree_sensitive(req);
694 
695 	return rc;
696 }
697 
llsec_do_encrypt(struct sk_buff * skb,const struct mac802154_llsec * sec,const struct ieee802154_hdr * hdr,struct mac802154_llsec_key * key)698 static int llsec_do_encrypt(struct sk_buff *skb,
699 			    const struct mac802154_llsec *sec,
700 			    const struct ieee802154_hdr *hdr,
701 			    struct mac802154_llsec_key *key)
702 {
703 	if (hdr->sec.level == IEEE802154_SCF_SECLEVEL_ENC)
704 		return llsec_do_encrypt_unauth(skb, sec, hdr, key);
705 	else
706 		return llsec_do_encrypt_auth(skb, sec, hdr, key);
707 }
708 
mac802154_llsec_encrypt(struct mac802154_llsec * sec,struct sk_buff * skb)709 int mac802154_llsec_encrypt(struct mac802154_llsec *sec, struct sk_buff *skb)
710 {
711 	struct ieee802154_hdr hdr;
712 	int rc, authlen, hlen;
713 	struct mac802154_llsec_key *key;
714 	u32 frame_ctr;
715 
716 	hlen = ieee802154_hdr_pull(skb, &hdr);
717 
718 	/* TODO: control frames security support */
719 	if (hlen < 0 ||
720 	    (hdr.fc.type != IEEE802154_FC_TYPE_DATA &&
721 	     hdr.fc.type != IEEE802154_FC_TYPE_BEACON))
722 		return -EINVAL;
723 
724 	if (!hdr.fc.security_enabled ||
725 	    (hdr.sec.level == IEEE802154_SCF_SECLEVEL_NONE)) {
726 		skb_push(skb, hlen);
727 		return 0;
728 	}
729 
730 	authlen = ieee802154_sechdr_authtag_len(&hdr.sec);
731 
732 	if (skb->len + hlen + authlen + IEEE802154_MFR_SIZE > IEEE802154_MTU)
733 		return -EMSGSIZE;
734 
735 	rcu_read_lock();
736 
737 	read_lock_bh(&sec->lock);
738 
739 	if (!sec->params.enabled) {
740 		rc = -EINVAL;
741 		goto fail_read;
742 	}
743 
744 	key = llsec_lookup_key(sec, &hdr, &hdr.dest, NULL);
745 	if (!key) {
746 		rc = -ENOKEY;
747 		goto fail_read;
748 	}
749 
750 	read_unlock_bh(&sec->lock);
751 
752 	write_lock_bh(&sec->lock);
753 
754 	frame_ctr = be32_to_cpu(sec->params.frame_counter);
755 	hdr.sec.frame_counter = cpu_to_le32(frame_ctr);
756 	if (frame_ctr == 0xFFFFFFFF) {
757 		write_unlock_bh(&sec->lock);
758 		llsec_key_put(key);
759 		rc = -EOVERFLOW;
760 		goto fail;
761 	}
762 
763 	sec->params.frame_counter = cpu_to_be32(frame_ctr + 1);
764 
765 	write_unlock_bh(&sec->lock);
766 
767 	rcu_read_unlock();
768 
769 	skb->mac_len = ieee802154_hdr_push(skb, &hdr);
770 	skb_reset_mac_header(skb);
771 
772 	rc = llsec_do_encrypt(skb, sec, &hdr, key);
773 	llsec_key_put(key);
774 
775 	return rc;
776 
777 fail_read:
778 	read_unlock_bh(&sec->lock);
779 fail:
780 	rcu_read_unlock();
781 	return rc;
782 }
783 
784 static struct mac802154_llsec_device*
llsec_lookup_dev(struct mac802154_llsec * sec,const struct ieee802154_addr * addr)785 llsec_lookup_dev(struct mac802154_llsec *sec,
786 		 const struct ieee802154_addr *addr)
787 {
788 	struct ieee802154_addr devaddr = *addr;
789 	struct mac802154_llsec_device *dev = NULL;
790 
791 	if (devaddr.mode == IEEE802154_ADDR_NONE &&
792 	    llsec_recover_addr(sec, &devaddr) < 0)
793 		return NULL;
794 
795 	if (devaddr.mode == IEEE802154_ADDR_SHORT) {
796 		u32 key = llsec_dev_hash_short(devaddr.short_addr,
797 					       devaddr.pan_id);
798 
799 		hash_for_each_possible_rcu(sec->devices_short, dev,
800 					   bucket_s, key) {
801 			if (dev->dev.pan_id == devaddr.pan_id &&
802 			    dev->dev.short_addr == devaddr.short_addr)
803 				return dev;
804 		}
805 	} else {
806 		u64 key = llsec_dev_hash_long(devaddr.extended_addr);
807 
808 		hash_for_each_possible_rcu(sec->devices_hw, dev,
809 					   bucket_hw, key) {
810 			if (dev->dev.hwaddr == devaddr.extended_addr)
811 				return dev;
812 		}
813 	}
814 
815 	return NULL;
816 }
817 
818 static int
llsec_lookup_seclevel(const struct mac802154_llsec * sec,u8 frame_type,u8 cmd_frame_id,struct ieee802154_llsec_seclevel * rlevel)819 llsec_lookup_seclevel(const struct mac802154_llsec *sec,
820 		      u8 frame_type, u8 cmd_frame_id,
821 		      struct ieee802154_llsec_seclevel *rlevel)
822 {
823 	struct ieee802154_llsec_seclevel *level;
824 
825 	list_for_each_entry_rcu(level, &sec->table.security_levels, list) {
826 		if (level->frame_type == frame_type &&
827 		    (frame_type != IEEE802154_FC_TYPE_MAC_CMD ||
828 		     level->cmd_frame_id == cmd_frame_id)) {
829 			*rlevel = *level;
830 			return 0;
831 		}
832 	}
833 
834 	return -EINVAL;
835 }
836 
837 static int
llsec_do_decrypt_unauth(struct sk_buff * skb,const struct mac802154_llsec * sec,const struct ieee802154_hdr * hdr,struct mac802154_llsec_key * key,__le64 dev_addr)838 llsec_do_decrypt_unauth(struct sk_buff *skb, const struct mac802154_llsec *sec,
839 			const struct ieee802154_hdr *hdr,
840 			struct mac802154_llsec_key *key, __le64 dev_addr)
841 {
842 	u8 iv[16];
843 	unsigned char *data;
844 	int datalen;
845 	struct scatterlist src;
846 	SYNC_SKCIPHER_REQUEST_ON_STACK(req, key->tfm0);
847 	int err;
848 
849 	llsec_geniv(iv, dev_addr, &hdr->sec);
850 	data = skb_mac_header(skb) + skb->mac_len;
851 	datalen = skb_tail_pointer(skb) - data;
852 
853 	sg_init_one(&src, data, datalen);
854 
855 	skcipher_request_set_sync_tfm(req, key->tfm0);
856 	skcipher_request_set_callback(req, 0, NULL, NULL);
857 	skcipher_request_set_crypt(req, &src, &src, datalen, iv);
858 
859 	err = crypto_skcipher_decrypt(req);
860 	skcipher_request_zero(req);
861 	return err;
862 }
863 
864 static int
llsec_do_decrypt_auth(struct sk_buff * skb,const struct mac802154_llsec * sec,const struct ieee802154_hdr * hdr,struct mac802154_llsec_key * key,__le64 dev_addr)865 llsec_do_decrypt_auth(struct sk_buff *skb, const struct mac802154_llsec *sec,
866 		      const struct ieee802154_hdr *hdr,
867 		      struct mac802154_llsec_key *key, __le64 dev_addr)
868 {
869 	u8 iv[16];
870 	unsigned char *data;
871 	int authlen, datalen, assoclen, rc;
872 	struct scatterlist sg;
873 	struct aead_request *req;
874 
875 	authlen = ieee802154_sechdr_authtag_len(&hdr->sec);
876 	llsec_geniv(iv, dev_addr, &hdr->sec);
877 
878 	req = aead_request_alloc(llsec_tfm_by_len(key, authlen), GFP_ATOMIC);
879 	if (!req)
880 		return -ENOMEM;
881 
882 	assoclen = skb->mac_len;
883 
884 	data = skb_mac_header(skb) + skb->mac_len;
885 	datalen = skb_tail_pointer(skb) - data;
886 
887 	sg_init_one(&sg, skb_mac_header(skb), assoclen + datalen);
888 
889 	if (!(hdr->sec.level & IEEE802154_SCF_SECLEVEL_ENC)) {
890 		assoclen += datalen - authlen;
891 		datalen = authlen;
892 	}
893 
894 	aead_request_set_callback(req, 0, NULL, NULL);
895 	aead_request_set_crypt(req, &sg, &sg, datalen, iv);
896 	aead_request_set_ad(req, assoclen);
897 
898 	rc = crypto_aead_decrypt(req);
899 
900 	kfree_sensitive(req);
901 	skb_trim(skb, skb->len - authlen);
902 
903 	return rc;
904 }
905 
906 static int
llsec_do_decrypt(struct sk_buff * skb,const struct mac802154_llsec * sec,const struct ieee802154_hdr * hdr,struct mac802154_llsec_key * key,__le64 dev_addr)907 llsec_do_decrypt(struct sk_buff *skb, const struct mac802154_llsec *sec,
908 		 const struct ieee802154_hdr *hdr,
909 		 struct mac802154_llsec_key *key, __le64 dev_addr)
910 {
911 	if (hdr->sec.level == IEEE802154_SCF_SECLEVEL_ENC)
912 		return llsec_do_decrypt_unauth(skb, sec, hdr, key, dev_addr);
913 	else
914 		return llsec_do_decrypt_auth(skb, sec, hdr, key, dev_addr);
915 }
916 
917 static int
llsec_update_devkey_record(struct mac802154_llsec_device * dev,const struct ieee802154_llsec_key_id * in_key)918 llsec_update_devkey_record(struct mac802154_llsec_device *dev,
919 			   const struct ieee802154_llsec_key_id *in_key)
920 {
921 	struct mac802154_llsec_device_key *devkey;
922 
923 	devkey = llsec_devkey_find(dev, in_key);
924 
925 	if (!devkey) {
926 		struct mac802154_llsec_device_key *next;
927 
928 		next = kzalloc(sizeof(*devkey), GFP_ATOMIC);
929 		if (!next)
930 			return -ENOMEM;
931 
932 		next->devkey.key_id = *in_key;
933 
934 		spin_lock_bh(&dev->lock);
935 
936 		devkey = llsec_devkey_find(dev, in_key);
937 		if (!devkey)
938 			list_add_rcu(&next->devkey.list, &dev->dev.keys);
939 		else
940 			kfree_sensitive(next);
941 
942 		spin_unlock_bh(&dev->lock);
943 	}
944 
945 	return 0;
946 }
947 
948 static int
llsec_update_devkey_info(struct mac802154_llsec_device * dev,const struct ieee802154_llsec_key_id * in_key,u32 frame_counter)949 llsec_update_devkey_info(struct mac802154_llsec_device *dev,
950 			 const struct ieee802154_llsec_key_id *in_key,
951 			 u32 frame_counter)
952 {
953 	struct mac802154_llsec_device_key *devkey = NULL;
954 
955 	if (dev->dev.key_mode == IEEE802154_LLSEC_DEVKEY_RESTRICT) {
956 		devkey = llsec_devkey_find(dev, in_key);
957 		if (!devkey)
958 			return -ENOENT;
959 	}
960 
961 	if (dev->dev.key_mode == IEEE802154_LLSEC_DEVKEY_RECORD) {
962 		int rc = llsec_update_devkey_record(dev, in_key);
963 
964 		if (rc < 0)
965 			return rc;
966 	}
967 
968 	spin_lock_bh(&dev->lock);
969 
970 	if ((!devkey && frame_counter < dev->dev.frame_counter) ||
971 	    (devkey && frame_counter < devkey->devkey.frame_counter)) {
972 		spin_unlock_bh(&dev->lock);
973 		return -EINVAL;
974 	}
975 
976 	if (devkey)
977 		devkey->devkey.frame_counter = frame_counter + 1;
978 	else
979 		dev->dev.frame_counter = frame_counter + 1;
980 
981 	spin_unlock_bh(&dev->lock);
982 
983 	return 0;
984 }
985 
mac802154_llsec_decrypt(struct mac802154_llsec * sec,struct sk_buff * skb)986 int mac802154_llsec_decrypt(struct mac802154_llsec *sec, struct sk_buff *skb)
987 {
988 	struct ieee802154_hdr hdr;
989 	struct mac802154_llsec_key *key;
990 	struct ieee802154_llsec_key_id key_id;
991 	struct mac802154_llsec_device *dev;
992 	struct ieee802154_llsec_seclevel seclevel;
993 	int err;
994 	__le64 dev_addr;
995 	u32 frame_ctr;
996 
997 	if (ieee802154_hdr_peek(skb, &hdr) < 0)
998 		return -EINVAL;
999 	if (!hdr.fc.security_enabled)
1000 		return 0;
1001 	if (hdr.fc.version == 0)
1002 		return -EINVAL;
1003 
1004 	read_lock_bh(&sec->lock);
1005 	if (!sec->params.enabled) {
1006 		read_unlock_bh(&sec->lock);
1007 		return -EINVAL;
1008 	}
1009 	read_unlock_bh(&sec->lock);
1010 
1011 	rcu_read_lock();
1012 
1013 	key = llsec_lookup_key(sec, &hdr, &hdr.source, &key_id);
1014 	if (!key) {
1015 		err = -ENOKEY;
1016 		goto fail;
1017 	}
1018 
1019 	dev = llsec_lookup_dev(sec, &hdr.source);
1020 	if (!dev) {
1021 		err = -EINVAL;
1022 		goto fail_dev;
1023 	}
1024 
1025 	if (llsec_lookup_seclevel(sec, hdr.fc.type, 0, &seclevel) < 0) {
1026 		err = -EINVAL;
1027 		goto fail_dev;
1028 	}
1029 
1030 	if (!(seclevel.sec_levels & BIT(hdr.sec.level)) &&
1031 	    (hdr.sec.level == 0 && seclevel.device_override &&
1032 	     !dev->dev.seclevel_exempt)) {
1033 		err = -EINVAL;
1034 		goto fail_dev;
1035 	}
1036 
1037 	frame_ctr = le32_to_cpu(hdr.sec.frame_counter);
1038 
1039 	if (frame_ctr == 0xffffffff) {
1040 		err = -EOVERFLOW;
1041 		goto fail_dev;
1042 	}
1043 
1044 	err = llsec_update_devkey_info(dev, &key_id, frame_ctr);
1045 	if (err)
1046 		goto fail_dev;
1047 
1048 	dev_addr = dev->dev.hwaddr;
1049 
1050 	rcu_read_unlock();
1051 
1052 	err = llsec_do_decrypt(skb, sec, &hdr, key, dev_addr);
1053 	llsec_key_put(key);
1054 	return err;
1055 
1056 fail_dev:
1057 	llsec_key_put(key);
1058 fail:
1059 	rcu_read_unlock();
1060 	return err;
1061 }
1062