]> Git Repo - linux.git/blame - net/mac802154/llsec.c
projects / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
devinet_ioctl(): take copyin/copyout to caller
[linux.git] / net / mac802154 / llsec.c
CommitLineData
5d637d5a
PB		 1/*
2 * Copyright (C) 2014 Fraunhofer ITWM
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2
6 * as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * Written by:
14 * Phoebe Buckheister <[email protected]>
15 */
16
17#include <linux/err.h>
18#include <linux/bug.h>
19#include <linux/completion.h>
4ca24aca 20#include <linux/ieee802154.h>
b2d09103
IM		 21#include <linux/rculist.h>
22
8a1a2b71 23#include <crypto/aead.h>
96953718 24#include <crypto/skcipher.h>
5d637d5a 25
0f1556bc 26#include "ieee802154_i.h"
5d637d5a
PB		 27#include "llsec.h"
28
29static void llsec_key_put(struct mac802154_llsec_key *key);
30static bool llsec_key_id_equal(const struct ieee802154_llsec_key_id *a,
31 const struct ieee802154_llsec_key_id *b);
32
33static void llsec_dev_free(struct mac802154_llsec_device *dev);
34
35void mac802154_llsec_init(struct mac802154_llsec *sec)
36{
37 memset(sec, 0, sizeof(*sec));
38
39 memset(&sec->params.default_key_source, 0xFF, IEEE802154_ADDR_LEN);
40
41 INIT_LIST_HEAD(&sec->table.security_levels);
42 INIT_LIST_HEAD(&sec->table.devices);
43 INIT_LIST_HEAD(&sec->table.keys);
44 hash_init(sec->devices_short);
45 hash_init(sec->devices_hw);
46 rwlock_init(&sec->lock);
47}
48
49void mac802154_llsec_destroy(struct mac802154_llsec *sec)
50{
51 struct ieee802154_llsec_seclevel *sl, *sn;
52 struct ieee802154_llsec_device *dev, *dn;
53 struct ieee802154_llsec_key_entry *key, *kn;
54
55 list_for_each_entry_safe(sl, sn, &sec->table.security_levels, list) {
56 struct mac802154_llsec_seclevel *msl;
57
58 msl = container_of(sl, struct mac802154_llsec_seclevel, level);
59 list_del(&sl->list);
71cd2aa5 60 kzfree(msl);
5d637d5a
PB		 61 }
62
63 list_for_each_entry_safe(dev, dn, &sec->table.devices, list) {
64 struct mac802154_llsec_device *mdev;
65
66 mdev = container_of(dev, struct mac802154_llsec_device, dev);
67 list_del(&dev->list);
68 llsec_dev_free(mdev);
69 }
70
71 list_for_each_entry_safe(key, kn, &sec->table.keys, list) {
72 struct mac802154_llsec_key *mkey;
73
74 mkey = container_of(key->key, struct mac802154_llsec_key, key);
75 list_del(&key->list);
76 llsec_key_put(mkey);
71cd2aa5 77 kzfree(key);
5d637d5a
PB		 78 }
79}
80
5d637d5a
PB		 81int mac802154_llsec_get_params(struct mac802154_llsec *sec,
82 struct ieee802154_llsec_params *params)
83{
84 read_lock_bh(&sec->lock);
85 *params = sec->params;
86 read_unlock_bh(&sec->lock);
87
88 return 0;
89}
90
91int mac802154_llsec_set_params(struct mac802154_llsec *sec,
92 const struct ieee802154_llsec_params *params,
93 int changed)
94{
95 write_lock_bh(&sec->lock);
96
97 if (changed & IEEE802154_LLSEC_PARAM_ENABLED)
98 sec->params.enabled = params->enabled;
99 if (changed & IEEE802154_LLSEC_PARAM_FRAME_COUNTER)
100 sec->params.frame_counter = params->frame_counter;
101 if (changed & IEEE802154_LLSEC_PARAM_OUT_LEVEL)
102 sec->params.out_level = params->out_level;
103 if (changed & IEEE802154_LLSEC_PARAM_OUT_KEY)
104 sec->params.out_key = params->out_key;
105 if (changed & IEEE802154_LLSEC_PARAM_KEY_SOURCE)
106 sec->params.default_key_source = params->default_key_source;
107 if (changed & IEEE802154_LLSEC_PARAM_PAN_ID)
108 sec->params.pan_id = params->pan_id;
109 if (changed & IEEE802154_LLSEC_PARAM_HWADDR)
110 sec->params.hwaddr = params->hwaddr;
111 if (changed & IEEE802154_LLSEC_PARAM_COORD_HWADDR)
112 sec->params.coord_hwaddr = params->coord_hwaddr;
113 if (changed & IEEE802154_LLSEC_PARAM_COORD_SHORTADDR)
114 sec->params.coord_shortaddr = params->coord_shortaddr;
115
116 write_unlock_bh(&sec->lock);
117
118 return 0;
119}
120
5d637d5a
PB		 121static struct mac802154_llsec_key*
122llsec_key_alloc(const struct ieee802154_llsec_key *template)
123{
124 const int authsizes[3] = { 4, 8, 16 };
125 struct mac802154_llsec_key *key;
126 int i;
127
128 key = kzalloc(sizeof(*key), GFP_KERNEL);
129 if (!key)
130 return NULL;
131
132 kref_init(&key->ref);
133 key->key = *template;
134
135 BUILD_BUG_ON(ARRAY_SIZE(authsizes) != ARRAY_SIZE(key->tfm));
136
137 for (i = 0; i < ARRAY_SIZE(key->tfm); i++) {
138 key->tfm[i] = crypto_alloc_aead("ccm(aes)", 0,
139 CRYPTO_ALG_ASYNC);
89eb6d06 140 if (IS_ERR(key->tfm[i]))
5d637d5a
PB		 141 goto err_tfm;
142 if (crypto_aead_setkey(key->tfm[i], template->key,
143 IEEE802154_LLSEC_KEY_SIZE))
144 goto err_tfm;
145 if (crypto_aead_setauthsize(key->tfm[i], authsizes[i]))
146 goto err_tfm;
147 }
148
96953718 149 key->tfm0 = crypto_alloc_skcipher("ctr(aes)", 0, CRYPTO_ALG_ASYNC);
89eb6d06 150 if (IS_ERR(key->tfm0))
5d637d5a
PB		 151 goto err_tfm;
152
96953718
HX		 153 if (crypto_skcipher_setkey(key->tfm0, template->key,
154 IEEE802154_LLSEC_KEY_SIZE))
5d637d5a
PB		 155 goto err_tfm0;
156
157 return key;
158
159err_tfm0:
96953718 160 crypto_free_skcipher(key->tfm0);
5d637d5a
PB		 161err_tfm:
162 for (i = 0; i < ARRAY_SIZE(key->tfm); i++)
163 if (key->tfm[i])
164 crypto_free_aead(key->tfm[i]);
165
71cd2aa5 166 kzfree(key);
5d637d5a
PB		 167 return NULL;
168}
169
170static void llsec_key_release(struct kref *ref)
171{
172 struct mac802154_llsec_key *key;
173 int i;
174
175 key = container_of(ref, struct mac802154_llsec_key, ref);
176
177 for (i = 0; i < ARRAY_SIZE(key->tfm); i++)
178 crypto_free_aead(key->tfm[i]);
179
96953718 180 crypto_free_skcipher(key->tfm0);
71cd2aa5 181 kzfree(key);
5d637d5a
PB		 182}
183
184static struct mac802154_llsec_key*
185llsec_key_get(struct mac802154_llsec_key *key)
186{
187 kref_get(&key->ref);
188 return key;
189}
190
191static void llsec_key_put(struct mac802154_llsec_key *key)
192{
193 kref_put(&key->ref, llsec_key_release);
194}
195
196static bool llsec_key_id_equal(const struct ieee802154_llsec_key_id *a,
197 const struct ieee802154_llsec_key_id *b)
198{
199 if (a->mode != b->mode)
200 return false;
201
202 if (a->mode == IEEE802154_SCF_KEY_IMPLICIT)
203 return ieee802154_addr_equal(&a->device_addr, &b->device_addr);
204
205 if (a->id != b->id)
206 return false;
207
208 switch (a->mode) {
53819a6c
PB		 209 case IEEE802154_SCF_KEY_INDEX:
210 return true;
5d637d5a
PB		 211 case IEEE802154_SCF_KEY_SHORT_INDEX:
212 return a->short_source == b->short_source;
213 case IEEE802154_SCF_KEY_HW_INDEX:
214 return a->extended_source == b->extended_source;
215 }
216
217 return false;
218}
219
220int mac802154_llsec_key_add(struct mac802154_llsec *sec,
221 const struct ieee802154_llsec_key_id *id,
222 const struct ieee802154_llsec_key *key)
223{
224 struct mac802154_llsec_key *mkey = NULL;
225 struct ieee802154_llsec_key_entry *pos, *new;
226
227 if (!(key->frame_types & (1 << IEEE802154_FC_TYPE_MAC_CMD)) &&
228 key->cmd_frame_ids)
229 return -EINVAL;
230
231 list_for_each_entry(pos, &sec->table.keys, list) {
232 if (llsec_key_id_equal(&pos->id, id))
233 return -EEXIST;
234
235 if (memcmp(pos->key->key, key->key,
236 IEEE802154_LLSEC_KEY_SIZE))
237 continue;
238
239 mkey = container_of(pos->key, struct mac802154_llsec_key, key);
240
241 /* Don't allow multiple instances of the same AES key to have
242 * different allowed frame types/command frame ids, as this is
243 * not possible in the 802.15.4 PIB.
244 */
245 if (pos->key->frame_types != key->frame_types ||
246 pos->key->cmd_frame_ids != key->cmd_frame_ids)
247 return -EEXIST;
248
249 break;
250 }
251
252 new = kzalloc(sizeof(*new), GFP_KERNEL);
253 if (!new)
254 return -ENOMEM;
255
256 if (!mkey)
257 mkey = llsec_key_alloc(key);
258 else
259 mkey = llsec_key_get(mkey);
260
261 if (!mkey)
262 goto fail;
263
264 new->id = *id;
265 new->key = &mkey->key;
266
267 list_add_rcu(&new->list, &sec->table.keys);
268
269 return 0;
270
271fail:
71cd2aa5 272 kzfree(new);
5d637d5a
PB		 273 return -ENOMEM;
274}
275
276int mac802154_llsec_key_del(struct mac802154_llsec *sec,
277 const struct ieee802154_llsec_key_id *key)
278{
279 struct ieee802154_llsec_key_entry *pos;
280
281 list_for_each_entry(pos, &sec->table.keys, list) {
282 struct mac802154_llsec_key *mkey;
283
284 mkey = container_of(pos->key, struct mac802154_llsec_key, key);
285
286 if (llsec_key_id_equal(&pos->id, key)) {
fff1f59b 287 list_del_rcu(&pos->list);
5d637d5a
PB		 288 llsec_key_put(mkey);
289 return 0;
290 }
291 }
292
293 return -ENOENT;
294}
295
5d637d5a
PB		 296static 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
302static u32 llsec_dev_hash_short(__le16 short_addr, __le16 pan_id)
303{
1db99604 304 return ((__force u16)short_addr) << 16 | (__force u16)pan_id;
5d637d5a
PB		 305}
306
307static u64 llsec_dev_hash_long(__le64 hwaddr)
308{
1db99604 309 return (__force u64)hwaddr;
5d637d5a
PB		 310}
311
312static struct mac802154_llsec_device*
313llsec_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
328static struct mac802154_llsec_device*
329llsec_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
342static 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);
71cd2aa5 352 kzfree(devkey);
5d637d5a
PB		 353 }
354
71cd2aa5 355 kzfree(dev);
5d637d5a
PB		 356}
357
358int 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
391static void llsec_dev_free_rcu(struct rcu_head *rcu)
392{
393 llsec_dev_free(container_of(rcu, struct mac802154_llsec_device, rcu));
394}
395
396int 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);
cdd38b21 406 list_del_rcu(&pos->dev.list);
5d637d5a
PB		 407 call_rcu(&pos->rcu, llsec_dev_free_rcu);
408
409 return 0;
410}
411
5d637d5a
PB		 412static struct mac802154_llsec_device_key*
413llsec_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
429int 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
453int 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
5d637d5a
PB		 474static struct mac802154_llsec_seclevel*
475llsec_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
495int 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
514int 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}
03556e4d 528
03556e4d
PB		 529static int llsec_recover_addr(struct mac802154_llsec *sec,
530 struct ieee802154_addr *addr)
531{
532 __le16 caddr = sec->params.coord_shortaddr;
4710d806 533
03556e4d
PB		 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
549static struct mac802154_llsec_key*
550llsec_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
597found:
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
03556e4d
PB		 604static 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
618static int
619llsec_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;
96953718 625 SKCIPHER_REQUEST_ON_STACK(req, key->tfm0);
3e496266
DP		 626 int err, datalen;
627 unsigned char *data;
03556e4d
PB		 628
629 llsec_geniv(iv, sec->params.hwaddr, &hdr->sec);
3e496266
DP		 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
96953718
HX		 635 skcipher_request_set_tfm(req, key->tfm0);
636 skcipher_request_set_callback(req, 0, NULL, NULL);
3e496266 637 skcipher_request_set_crypt(req, &src, &src, datalen, iv);
96953718
HX		 638 err = crypto_skcipher_encrypt(req);
639 skcipher_request_zero(req);
640 return err;
03556e4d
PB		 641}
642
643static struct crypto_aead*
644llsec_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
655static int
656llsec_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;
25528fda 663 struct scatterlist sg;
03556e4d
PB		 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
03556e4d
PB		 673 assoclen = skb->mac_len;
674
675 data = skb_mac_header(skb) + skb->mac_len;
676 datalen = skb_tail_pointer(skb) - data;
677
25528fda
HX		 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)) {
03556e4d
PB		 683 assoclen += datalen;
684 datalen = 0;
685 }
686
03556e4d 687 aead_request_set_callback(req, 0, NULL, NULL);
25528fda
HX		 688 aead_request_set_crypt(req, &sg, &sg, datalen, iv);
689 aead_request_set_ad(req, assoclen);
03556e4d
PB		 690
691 rc = crypto_aead_encrypt(req);
692
71cd2aa5 693 kzfree(req);
03556e4d
PB		 694
695 return rc;
696}
697
698static 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
709int 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 if (hlen < 0 || hdr.fc.type != IEEE802154_FC_TYPE_DATA)
719 return -EINVAL;
720
91f4aa97
DP		 721 if (!hdr.fc.security_enabled ||
722 (hdr.sec.level == IEEE802154_SCF_SECLEVEL_NONE)) {
03556e4d
PB		 723 skb_push(skb, hlen);
724 return 0;
725 }
726
727 authlen = ieee802154_sechdr_authtag_len(&hdr.sec);
728
729 if (skb->len + hlen + authlen + IEEE802154_MFR_SIZE > IEEE802154_MTU)
730 return -EMSGSIZE;
731
732 rcu_read_lock();
733
734 read_lock_bh(&sec->lock);
735
736 if (!sec->params.enabled) {
737 rc = -EINVAL;
738 goto fail_read;
739 }
740
741 key = llsec_lookup_key(sec, &hdr, &hdr.dest, NULL);
742 if (!key) {
743 rc = -ENOKEY;
744 goto fail_read;
745 }
746
747 read_unlock_bh(&sec->lock);
748
749 write_lock_bh(&sec->lock);
750
751 frame_ctr = be32_to_cpu(sec->params.frame_counter);
752 hdr.sec.frame_counter = cpu_to_le32(frame_ctr);
753 if (frame_ctr == 0xFFFFFFFF) {
754 write_unlock_bh(&sec->lock);
755 llsec_key_put(key);
756 rc = -EOVERFLOW;
757 goto fail;
758 }
759
760 sec->params.frame_counter = cpu_to_be32(frame_ctr + 1);
761
762 write_unlock_bh(&sec->lock);
763
764 rcu_read_unlock();
765
766 skb->mac_len = ieee802154_hdr_push(skb, &hdr);
767 skb_reset_mac_header(skb);
768
769 rc = llsec_do_encrypt(skb, sec, &hdr, key);
770 llsec_key_put(key);
771
62e9c117 772 return rc;
03556e4d
PB		 773
774fail_read:
6f3eabcd 775 read_unlock_bh(&sec->lock);
03556e4d
PB		 776fail:
777 rcu_read_unlock();
778 return rc;
779}
4c14a2fb 780
4c14a2fb
PB		 781static struct mac802154_llsec_device*
782llsec_lookup_dev(struct mac802154_llsec *sec,
783 const struct ieee802154_addr *addr)
784{
785 struct ieee802154_addr devaddr = *addr;
786 struct mac802154_llsec_device *dev = NULL;
787
788 if (devaddr.mode == IEEE802154_ADDR_NONE &&
789 llsec_recover_addr(sec, &devaddr) < 0)
790 return NULL;
791
792 if (devaddr.mode == IEEE802154_ADDR_SHORT) {
793 u32 key = llsec_dev_hash_short(devaddr.short_addr,
794 devaddr.pan_id);
795
796 hash_for_each_possible_rcu(sec->devices_short, dev,
797 bucket_s, key) {
798 if (dev->dev.pan_id == devaddr.pan_id &&
799 dev->dev.short_addr == devaddr.short_addr)
800 return dev;
801 }
802 } else {
803 u64 key = llsec_dev_hash_long(devaddr.extended_addr);
804
805 hash_for_each_possible_rcu(sec->devices_hw, dev,
806 bucket_hw, key) {
807 if (dev->dev.hwaddr == devaddr.extended_addr)
808 return dev;
809 }
810 }
811
812 return NULL;
813}
814
815static int
816llsec_lookup_seclevel(const struct mac802154_llsec *sec,
817 u8 frame_type, u8 cmd_frame_id,
818 struct ieee802154_llsec_seclevel *rlevel)
819{
820 struct ieee802154_llsec_seclevel *level;
821
822 list_for_each_entry_rcu(level, &sec->table.security_levels, list) {
823 if (level->frame_type == frame_type &&
824 (frame_type != IEEE802154_FC_TYPE_MAC_CMD ||
825 level->cmd_frame_id == cmd_frame_id)) {
826 *rlevel = *level;
827 return 0;
828 }
829 }
830
831 return -EINVAL;
832}
833
834static int
835llsec_do_decrypt_unauth(struct sk_buff *skb, const struct mac802154_llsec *sec,
836 const struct ieee802154_hdr *hdr,
837 struct mac802154_llsec_key *key, __le64 dev_addr)
838{
839 u8 iv[16];
840 unsigned char *data;
841 int datalen;
842 struct scatterlist src;
96953718
HX		 843 SKCIPHER_REQUEST_ON_STACK(req, key->tfm0);
844 int err;
4c14a2fb
PB		 845
846 llsec_geniv(iv, dev_addr, &hdr->sec);
847 data = skb_mac_header(skb) + skb->mac_len;
848 datalen = skb_tail_pointer(skb) - data;
849
850 sg_init_one(&src, data, datalen);
851
96953718
HX		 852 skcipher_request_set_tfm(req, key->tfm0);
853 skcipher_request_set_callback(req, 0, NULL, NULL);
854 skcipher_request_set_crypt(req, &src, &src, datalen, iv);
855
856 err = crypto_skcipher_decrypt(req);
857 skcipher_request_zero(req);
858 return err;
4c14a2fb
PB		 859}
860
861static int
862llsec_do_decrypt_auth(struct sk_buff *skb, const struct mac802154_llsec *sec,
863 const struct ieee802154_hdr *hdr,
864 struct mac802154_llsec_key *key, __le64 dev_addr)
865{
866 u8 iv[16];
867 unsigned char *data;
868 int authlen, datalen, assoclen, rc;
25528fda 869 struct scatterlist sg;
4c14a2fb
PB		 870 struct aead_request *req;
871
872 authlen = ieee802154_sechdr_authtag_len(&hdr->sec);
873 llsec_geniv(iv, dev_addr, &hdr->sec);
874
875 req = aead_request_alloc(llsec_tfm_by_len(key, authlen), GFP_ATOMIC);
876 if (!req)
877 return -ENOMEM;
878
4c14a2fb
PB		 879 assoclen = skb->mac_len;
880
881 data = skb_mac_header(skb) + skb->mac_len;
882 datalen = skb_tail_pointer(skb) - data;
883
25528fda
HX		 884 sg_init_one(&sg, skb_mac_header(skb), assoclen + datalen);
885
886 if (!(hdr->sec.level & IEEE802154_SCF_SECLEVEL_ENC)) {
4c14a2fb 887 assoclen += datalen - authlen;
4c14a2fb
PB		 888 datalen = authlen;
889 }
890
4c14a2fb 891 aead_request_set_callback(req, 0, NULL, NULL);
25528fda
HX		 892 aead_request_set_crypt(req, &sg, &sg, datalen, iv);
893 aead_request_set_ad(req, assoclen);
4c14a2fb
PB		 894
895 rc = crypto_aead_decrypt(req);
896
71cd2aa5 897 kzfree(req);
4c14a2fb
PB		 898 skb_trim(skb, skb->len - authlen);
899
900 return rc;
901}
902
903static int
904llsec_do_decrypt(struct sk_buff *skb, const struct mac802154_llsec *sec,
905 const struct ieee802154_hdr *hdr,
906 struct mac802154_llsec_key *key, __le64 dev_addr)
907{
908 if (hdr->sec.level == IEEE802154_SCF_SECLEVEL_ENC)
909 return llsec_do_decrypt_unauth(skb, sec, hdr, key, dev_addr);
910 else
911 return llsec_do_decrypt_auth(skb, sec, hdr, key, dev_addr);
912}
913
f0f77dc6
PB		 914static int
915llsec_update_devkey_record(struct mac802154_llsec_device *dev,
916 const struct ieee802154_llsec_key_id *in_key)
917{
918 struct mac802154_llsec_device_key *devkey;
919
920 devkey = llsec_devkey_find(dev, in_key);
921
922 if (!devkey) {
923 struct mac802154_llsec_device_key *next;
924
925 next = kzalloc(sizeof(*devkey), GFP_ATOMIC);
926 if (!next)
927 return -ENOMEM;
928
929 next->devkey.key_id = *in_key;
930
931 spin_lock_bh(&dev->lock);
932
933 devkey = llsec_devkey_find(dev, in_key);
934 if (!devkey)
935 list_add_rcu(&next->devkey.list, &dev->dev.keys);
936 else
71cd2aa5 937 kzfree(next);
f0f77dc6
PB		 938
939 spin_unlock_bh(&dev->lock);
940 }
941
942 return 0;
943}
944
4c14a2fb
PB		 945static int
946llsec_update_devkey_info(struct mac802154_llsec_device *dev,
947 const struct ieee802154_llsec_key_id *in_key,
948 u32 frame_counter)
949{
950 struct mac802154_llsec_device_key *devkey = NULL;
951
952 if (dev->dev.key_mode == IEEE802154_LLSEC_DEVKEY_RESTRICT) {
953 devkey = llsec_devkey_find(dev, in_key);
954 if (!devkey)
955 return -ENOENT;
956 }
957
f0f77dc6
PB		 958 if (dev->dev.key_mode == IEEE802154_LLSEC_DEVKEY_RECORD) {
959 int rc = llsec_update_devkey_record(dev, in_key);
960
961 if (rc < 0)
962 return rc;
963 }
964
4c14a2fb
PB		 965 spin_lock_bh(&dev->lock);
966
967 if ((!devkey && frame_counter < dev->dev.frame_counter) ||
968 (devkey && frame_counter < devkey->devkey.frame_counter)) {
969 spin_unlock_bh(&dev->lock);
970 return -EINVAL;
971 }
972
973 if (devkey)
974 devkey->devkey.frame_counter = frame_counter + 1;
975 else
976 dev->dev.frame_counter = frame_counter + 1;
977
978 spin_unlock_bh(&dev->lock);
979
980 return 0;
981}
982
983int mac802154_llsec_decrypt(struct mac802154_llsec *sec, struct sk_buff *skb)
984{
985 struct ieee802154_hdr hdr;
986 struct mac802154_llsec_key *key;
987 struct ieee802154_llsec_key_id key_id;
988 struct mac802154_llsec_device *dev;
989 struct ieee802154_llsec_seclevel seclevel;
990 int err;
991 __le64 dev_addr;
992 u32 frame_ctr;
993
994 if (ieee802154_hdr_peek(skb, &hdr) < 0)
995 return -EINVAL;
996 if (!hdr.fc.security_enabled)
997 return 0;
998 if (hdr.fc.version == 0)
999 return -EINVAL;
1000
1001 read_lock_bh(&sec->lock);
1002 if (!sec->params.enabled) {
1003 read_unlock_bh(&sec->lock);
1004 return -EINVAL;
1005 }
1006 read_unlock_bh(&sec->lock);
1007
1008 rcu_read_lock();
1009
1010 key = llsec_lookup_key(sec, &hdr, &hdr.source, &key_id);
1011 if (!key) {
1012 err = -ENOKEY;
1013 goto fail;
1014 }
1015
1016 dev = llsec_lookup_dev(sec, &hdr.source);
1017 if (!dev) {
1018 err = -EINVAL;
1019 goto fail_dev;
1020 }
1021
1022 if (llsec_lookup_seclevel(sec, hdr.fc.type, 0, &seclevel) < 0) {
1023 err = -EINVAL;
1024 goto fail_dev;
1025 }
1026
1027 if (!(seclevel.sec_levels & BIT(hdr.sec.level)) &&
1028 (hdr.sec.level == 0 && seclevel.device_override &&
1029 !dev->dev.seclevel_exempt)) {
1030 err = -EINVAL;
1031 goto fail_dev;
1032 }
1033
1034 frame_ctr = le32_to_cpu(hdr.sec.frame_counter);
1035
1036 if (frame_ctr == 0xffffffff) {
1037 err = -EOVERFLOW;
1038 goto fail_dev;
1039 }
1040
1041 err = llsec_update_devkey_info(dev, &key_id, frame_ctr);
1042 if (err)
1043 goto fail_dev;
1044
1045 dev_addr = dev->dev.hwaddr;
1046
1047 rcu_read_unlock();
1048
1049 err = llsec_do_decrypt(skb, sec, &hdr, key, dev_addr);
1050 llsec_key_put(key);
1051 return err;
1052
1053fail_dev:
1054 llsec_key_put(key);
1055fail:
1056 rcu_read_unlock();
1057 return err;
1058}
Empty description
This page took 0.389963 seconds and 4 git commands to generate.