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
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
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
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
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*
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
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*
177 llsec_key_get(struct mac802154_llsec_key *key)
178 {
179 kref_get(&key->ref);
180 return key;
181 }
182
183 static void llsec_key_put(struct mac802154_llsec_key *key)
184 {
185 kref_put(&key->ref, llsec_key_release);
186 }
187
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
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
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
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
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
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
307 static u64 llsec_dev_hash_long(__le64 hwaddr)
308 {
309 return (__force u64)hwaddr;
310 }
311
312 static struct mac802154_llsec_device*
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*
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
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
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
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
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*
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
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
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*
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
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
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
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*
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
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
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*
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
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
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
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*
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
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
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
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
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
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
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
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
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.