~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/mac802154/llsec.c

Version: ~ [ linux-5.19-rc3 ] ~ [ linux-5.18.5 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.48 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.123 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.199 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.248 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.284 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.319 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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                 kzfree(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                 kzfree(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 (key->tfm[i])
156                         crypto_free_aead(key->tfm[i]);
157 
158         kzfree(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         kzfree(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         kzfree(new);
265         return -ENOMEM;
266 }
267 
268 int mac802154_llsec_key_del(struct mac802154_llsec *sec,
269                             const struct ieee802154_llsec_key_id *key)
270 {
271         struct ieee802154_llsec_key_entry *pos;
272 
273         list_for_each_entry(pos, &sec->table.keys, list) {
274                 struct mac802154_llsec_key *mkey;
275 
276                 mkey = container_of(pos->key, struct mac802154_llsec_key, key);
277 
278                 if (llsec_key_id_equal(&pos->id, key)) {
279                         list_del_rcu(&pos->list);
280                         llsec_key_put(mkey);
281                         return 0;
282                 }
283         }
284 
285         return -ENOENT;
286 }
287 
288 static bool llsec_dev_use_shortaddr(__le16 short_addr)
289 {
290         return short_addr != cpu_to_le16(IEEE802154_ADDR_UNDEF) &&
291                 short_addr != cpu_to_le16(0xffff);
292 }
293 
294 static u32 llsec_dev_hash_short(__le16 short_addr, __le16 pan_id)
295 {
296         return ((__force u16)short_addr) << 16 | (__force u16)pan_id;
297 }
298 
299 static u64 llsec_dev_hash_long(__le64 hwaddr)
300 {
301         return (__force u64)hwaddr;
302 }
303 
304 static struct mac802154_llsec_device*
305 llsec_dev_find_short(struct mac802154_llsec *sec, __le16 short_addr,
306                      __le16 pan_id)
307 {
308         struct mac802154_llsec_device *dev;
309         u32 key = llsec_dev_hash_short(short_addr, pan_id);
310 
311         hash_for_each_possible_rcu(sec->devices_short, dev, bucket_s, key) {
312                 if (dev->dev.short_addr == short_addr &&
313                     dev->dev.pan_id == pan_id)
314                         return dev;
315         }
316 
317         return NULL;
318 }
319 
320 static struct mac802154_llsec_device*
321 llsec_dev_find_long(struct mac802154_llsec *sec, __le64 hwaddr)
322 {
323         struct mac802154_llsec_device *dev;
324         u64 key = llsec_dev_hash_long(hwaddr);
325 
326         hash_for_each_possible_rcu(sec->devices_hw, dev, bucket_hw, key) {
327                 if (dev->dev.hwaddr == hwaddr)
328                         return dev;
329         }
330 
331         return NULL;
332 }
333 
334 static void llsec_dev_free(struct mac802154_llsec_device *dev)
335 {
336         struct ieee802154_llsec_device_key *pos, *pn;
337         struct mac802154_llsec_device_key *devkey;
338 
339         list_for_each_entry_safe(pos, pn, &dev->dev.keys, list) {
340                 devkey = container_of(pos, struct mac802154_llsec_device_key,
341                                       devkey);
342 
343                 list_del(&pos->list);
344                 kzfree(devkey);
345         }
346 
347         kzfree(dev);
348 }
349 
350 int mac802154_llsec_dev_add(struct mac802154_llsec *sec,
351                             const struct ieee802154_llsec_device *dev)
352 {
353         struct mac802154_llsec_device *entry;
354         u32 skey = llsec_dev_hash_short(dev->short_addr, dev->pan_id);
355         u64 hwkey = llsec_dev_hash_long(dev->hwaddr);
356 
357         BUILD_BUG_ON(sizeof(hwkey) != IEEE802154_ADDR_LEN);
358 
359         if ((llsec_dev_use_shortaddr(dev->short_addr) &&
360              llsec_dev_find_short(sec, dev->short_addr, dev->pan_id)) ||
361              llsec_dev_find_long(sec, dev->hwaddr))
362                 return -EEXIST;
363 
364         entry = kmalloc(sizeof(*entry), GFP_KERNEL);
365         if (!entry)
366                 return -ENOMEM;
367 
368         entry->dev = *dev;
369         spin_lock_init(&entry->lock);
370         INIT_LIST_HEAD(&entry->dev.keys);
371 
372         if (llsec_dev_use_shortaddr(dev->short_addr))
373                 hash_add_rcu(sec->devices_short, &entry->bucket_s, skey);
374         else
375                 INIT_HLIST_NODE(&entry->bucket_s);
376 
377         hash_add_rcu(sec->devices_hw, &entry->bucket_hw, hwkey);
378         list_add_tail_rcu(&entry->dev.list, &sec->table.devices);
379 
380         return 0;
381 }
382 
383 static void llsec_dev_free_rcu(struct rcu_head *rcu)
384 {
385         llsec_dev_free(container_of(rcu, struct mac802154_llsec_device, rcu));
386 }
387 
388 int mac802154_llsec_dev_del(struct mac802154_llsec *sec, __le64 device_addr)
389 {
390         struct mac802154_llsec_device *pos;
391 
392         pos = llsec_dev_find_long(sec, device_addr);
393         if (!pos)
394                 return -ENOENT;
395 
396         hash_del_rcu(&pos->bucket_s);
397         hash_del_rcu(&pos->bucket_hw);
398         list_del_rcu(&pos->dev.list);
399         call_rcu(&pos->rcu, llsec_dev_free_rcu);
400 
401         return 0;
402 }
403 
404 static struct mac802154_llsec_device_key*
405 llsec_devkey_find(struct mac802154_llsec_device *dev,
406                   const struct ieee802154_llsec_key_id *key)
407 {
408         struct ieee802154_llsec_device_key *devkey;
409 
410         list_for_each_entry_rcu(devkey, &dev->dev.keys, list) {
411                 if (!llsec_key_id_equal(key, &devkey->key_id))
412                         continue;
413 
414                 return container_of(devkey, struct mac802154_llsec_device_key,
415                                     devkey);
416         }
417 
418         return NULL;
419 }
420 
421 int mac802154_llsec_devkey_add(struct mac802154_llsec *sec,
422                                __le64 dev_addr,
423                                const struct ieee802154_llsec_device_key *key)
424 {
425         struct mac802154_llsec_device *dev;
426         struct mac802154_llsec_device_key *devkey;
427 
428         dev = llsec_dev_find_long(sec, dev_addr);
429 
430         if (!dev)
431                 return -ENOENT;
432 
433         if (llsec_devkey_find(dev, &key->key_id))
434                 return -EEXIST;
435 
436         devkey = kmalloc(sizeof(*devkey), GFP_KERNEL);
437         if (!devkey)
438                 return -ENOMEM;
439 
440         devkey->devkey = *key;
441         list_add_tail_rcu(&devkey->devkey.list, &dev->dev.keys);
442         return 0;
443 }
444 
445 int mac802154_llsec_devkey_del(struct mac802154_llsec *sec,
446                                __le64 dev_addr,
447                                const struct ieee802154_llsec_device_key *key)
448 {
449         struct mac802154_llsec_device *dev;
450         struct mac802154_llsec_device_key *devkey;
451 
452         dev = llsec_dev_find_long(sec, dev_addr);
453 
454         if (!dev)
455                 return -ENOENT;
456 
457         devkey = llsec_devkey_find(dev, &key->key_id);
458         if (!devkey)
459                 return -ENOENT;
460 
461         list_del_rcu(&devkey->devkey.list);
462         kfree_rcu(devkey, rcu);
463         return 0;
464 }
465 
466 static struct mac802154_llsec_seclevel*
467 llsec_find_seclevel(const struct mac802154_llsec *sec,
468                     const struct ieee802154_llsec_seclevel *sl)
469 {
470         struct ieee802154_llsec_seclevel *pos;
471 
472         list_for_each_entry(pos, &sec->table.security_levels, list) {
473                 if (pos->frame_type != sl->frame_type ||
474                     (pos->frame_type == IEEE802154_FC_TYPE_MAC_CMD &&
475                      pos->cmd_frame_id != sl->cmd_frame_id) ||
476                     pos->device_override != sl->device_override ||
477                     pos->sec_levels != sl->sec_levels)
478                         continue;
479 
480                 return container_of(pos, struct mac802154_llsec_seclevel,
481                                     level);
482         }
483 
484         return NULL;
485 }
486 
487 int mac802154_llsec_seclevel_add(struct mac802154_llsec *sec,
488                                  const struct ieee802154_llsec_seclevel *sl)
489 {
490         struct mac802154_llsec_seclevel *entry;
491 
492         if (llsec_find_seclevel(sec, sl))
493                 return -EEXIST;
494 
495         entry = kmalloc(sizeof(*entry), GFP_KERNEL);
496         if (!entry)
497                 return -ENOMEM;
498 
499         entry->level = *sl;
500 
501         list_add_tail_rcu(&entry->level.list, &sec->table.security_levels);
502 
503         return 0;
504 }
505 
506 int mac802154_llsec_seclevel_del(struct mac802154_llsec *sec,
507                                  const struct ieee802154_llsec_seclevel *sl)
508 {
509         struct mac802154_llsec_seclevel *pos;
510 
511         pos = llsec_find_seclevel(sec, sl);
512         if (!pos)
513                 return -ENOENT;
514 
515         list_del_rcu(&pos->level.list);
516         kfree_rcu(pos, rcu);
517 
518         return 0;
519 }
520 
521 static int llsec_recover_addr(struct mac802154_llsec *sec,
522                               struct ieee802154_addr *addr)
523 {
524         __le16 caddr = sec->params.coord_shortaddr;
525 
526         addr->pan_id = sec->params.pan_id;
527 
528         if (caddr == cpu_to_le16(IEEE802154_ADDR_BROADCAST)) {
529                 return -EINVAL;
530         } else if (caddr == cpu_to_le16(IEEE802154_ADDR_UNDEF)) {
531                 addr->extended_addr = sec->params.coord_hwaddr;
532                 addr->mode = IEEE802154_ADDR_LONG;
533         } else {
534                 addr->short_addr = sec->params.coord_shortaddr;
535                 addr->mode = IEEE802154_ADDR_SHORT;
536         }
537 
538         return 0;
539 }
540 
541 static struct mac802154_llsec_key*
542 llsec_lookup_key(struct mac802154_llsec *sec,
543                  const struct ieee802154_hdr *hdr,
544                  const struct ieee802154_addr *addr,
545                  struct ieee802154_llsec_key_id *key_id)
546 {
547         struct ieee802154_addr devaddr = *addr;
548         u8 key_id_mode = hdr->sec.key_id_mode;
549         struct ieee802154_llsec_key_entry *key_entry;
550         struct mac802154_llsec_key *key;
551 
552         if (key_id_mode == IEEE802154_SCF_KEY_IMPLICIT &&
553             devaddr.mode == IEEE802154_ADDR_NONE) {
554                 if (hdr->fc.type == IEEE802154_FC_TYPE_BEACON) {
555                         devaddr.extended_addr = sec->params.coord_hwaddr;
556                         devaddr.mode = IEEE802154_ADDR_LONG;
557                 } else if (llsec_recover_addr(sec, &devaddr) < 0) {
558                         return NULL;
559                 }
560         }
561 
562         list_for_each_entry_rcu(key_entry, &sec->table.keys, list) {
563                 const struct ieee802154_llsec_key_id *id = &key_entry->id;
564 
565                 if (!(key_entry->key->frame_types & BIT(hdr->fc.type)))
566                         continue;
567 
568                 if (id->mode != key_id_mode)
569                         continue;
570 
571                 if (key_id_mode == IEEE802154_SCF_KEY_IMPLICIT) {
572                         if (ieee802154_addr_equal(&devaddr, &id->device_addr))
573                                 goto found;
574                 } else {
575                         if (id->id != hdr->sec.key_id)
576                                 continue;
577 
578                         if ((key_id_mode == IEEE802154_SCF_KEY_INDEX) ||
579                             (key_id_mode == IEEE802154_SCF_KEY_SHORT_INDEX &&
580                              id->short_source == hdr->sec.short_src) ||
581                             (key_id_mode == IEEE802154_SCF_KEY_HW_INDEX &&
582                              id->extended_source == hdr->sec.extended_src))
583                                 goto found;
584                 }
585         }
586 
587         return NULL;
588 
589 found:
590         key = container_of(key_entry->key, struct mac802154_llsec_key, key);
591         if (key_id)
592                 *key_id = key_entry->id;
593         return llsec_key_get(key);
594 }
595 
596 static void llsec_geniv(u8 iv[16], __le64 addr,
597                         const struct ieee802154_sechdr *sec)
598 {
599         __be64 addr_bytes = (__force __be64) swab64((__force u64) addr);
600         __be32 frame_counter = (__force __be32) swab32((__force u32) sec->frame_counter);
601 
602         iv[0] = 1; /* L' = L - 1 = 1 */
603         memcpy(iv + 1, &addr_bytes, sizeof(addr_bytes));
604         memcpy(iv + 9, &frame_counter, sizeof(frame_counter));
605         iv[13] = sec->level;
606         iv[14] = 0;
607         iv[15] = 1;
608 }
609 
610 static int
611 llsec_do_encrypt_unauth(struct sk_buff *skb, const struct mac802154_llsec *sec,
612                         const struct ieee802154_hdr *hdr,
613                         struct mac802154_llsec_key *key)
614 {
615         u8 iv[16];
616         struct scatterlist src;
617         SYNC_SKCIPHER_REQUEST_ON_STACK(req, key->tfm0);
618         int err, datalen;
619         unsigned char *data;
620 
621         llsec_geniv(iv, sec->params.hwaddr, &hdr->sec);
622         /* Compute data payload offset and data length */
623         data = skb_mac_header(skb) + skb->mac_len;
624         datalen = skb_tail_pointer(skb) - data;
625         sg_init_one(&src, data, datalen);
626 
627         skcipher_request_set_sync_tfm(req, key->tfm0);
628         skcipher_request_set_callback(req, 0, NULL, NULL);
629         skcipher_request_set_crypt(req, &src, &src, datalen, iv);
630         err = crypto_skcipher_encrypt(req);
631         skcipher_request_zero(req);
632         return err;
633 }
634 
635 static struct crypto_aead*
636 llsec_tfm_by_len(struct mac802154_llsec_key *key, int authlen)
637 {
638         int i;
639 
640         for (i = 0; i < ARRAY_SIZE(key->tfm); i++)
641                 if (crypto_aead_authsize(key->tfm[i]) == authlen)
642                         return key->tfm[i];
643 
644         BUG();
645 }
646 
647 static int
648 llsec_do_encrypt_auth(struct sk_buff *skb, const struct mac802154_llsec *sec,
649                       const struct ieee802154_hdr *hdr,
650                       struct mac802154_llsec_key *key)
651 {
652         u8 iv[16];
653         unsigned char *data;
654         int authlen, assoclen, datalen, rc;
655         struct scatterlist sg;
656         struct aead_request *req;
657 
658         authlen = ieee802154_sechdr_authtag_len(&hdr->sec);
659         llsec_geniv(iv, sec->params.hwaddr, &hdr->sec);
660 
661         req = aead_request_alloc(llsec_tfm_by_len(key, authlen), GFP_ATOMIC);
662         if (!req)
663                 return -ENOMEM;
664 
665         assoclen = skb->mac_len;
666 
667         data = skb_mac_header(skb) + skb->mac_len;
668         datalen = skb_tail_pointer(skb) - data;
669 
670         skb_put(skb, authlen);
671 
672         sg_init_one(&sg, skb_mac_header(skb), assoclen + datalen + authlen);
673 
674         if (!(hdr->sec.level & IEEE802154_SCF_SECLEVEL_ENC)) {
675                 assoclen += datalen;
676                 datalen = 0;
677         }
678 
679         aead_request_set_callback(req, 0, NULL, NULL);
680         aead_request_set_crypt(req, &sg, &sg, datalen, iv);
681         aead_request_set_ad(req, assoclen);
682 
683         rc = crypto_aead_encrypt(req);
684 
685         kzfree(req);
686 
687         return rc;
688 }
689 
690 static int llsec_do_encrypt(struct sk_buff *skb,
691                             const struct mac802154_llsec *sec,
692                             const struct ieee802154_hdr *hdr,
693                             struct mac802154_llsec_key *key)
694 {
695         if (hdr->sec.level == IEEE802154_SCF_SECLEVEL_ENC)
696                 return llsec_do_encrypt_unauth(skb, sec, hdr, key);
697         else
698                 return llsec_do_encrypt_auth(skb, sec, hdr, key);
699 }
700 
701 int mac802154_llsec_encrypt(struct mac802154_llsec *sec, struct sk_buff *skb)
702 {
703         struct ieee802154_hdr hdr;
704         int rc, authlen, hlen;
705         struct mac802154_llsec_key *key;
706         u32 frame_ctr;
707 
708         hlen = ieee802154_hdr_pull(skb, &hdr);
709 
710         if (hlen < 0 || hdr.fc.type != IEEE802154_FC_TYPE_DATA)
711                 return -EINVAL;
712 
713         if (!hdr.fc.security_enabled ||
714             (hdr.sec.level == IEEE802154_SCF_SECLEVEL_NONE)) {
715                 skb_push(skb, hlen);
716                 return 0;
717         }
718 
719         authlen = ieee802154_sechdr_authtag_len(&hdr.sec);
720 
721         if (skb->len + hlen + authlen + IEEE802154_MFR_SIZE > IEEE802154_MTU)
722                 return -EMSGSIZE;
723 
724         rcu_read_lock();
725 
726         read_lock_bh(&sec->lock);
727 
728         if (!sec->params.enabled) {
729                 rc = -EINVAL;
730                 goto fail_read;
731         }
732 
733         key = llsec_lookup_key(sec, &hdr, &hdr.dest, NULL);
734         if (!key) {
735                 rc = -ENOKEY;
736                 goto fail_read;
737         }
738 
739         read_unlock_bh(&sec->lock);
740 
741         write_lock_bh(&sec->lock);
742 
743         frame_ctr = be32_to_cpu(sec->params.frame_counter);
744         hdr.sec.frame_counter = cpu_to_le32(frame_ctr);
745         if (frame_ctr == 0xFFFFFFFF) {
746                 write_unlock_bh(&sec->lock);
747                 llsec_key_put(key);
748                 rc = -EOVERFLOW;
749                 goto fail;
750         }
751 
752         sec->params.frame_counter = cpu_to_be32(frame_ctr + 1);
753 
754         write_unlock_bh(&sec->lock);
755 
756         rcu_read_unlock();
757 
758         skb->mac_len = ieee802154_hdr_push(skb, &hdr);
759         skb_reset_mac_header(skb);
760 
761         rc = llsec_do_encrypt(skb, sec, &hdr, key);
762         llsec_key_put(key);
763 
764         return rc;
765 
766 fail_read:
767         read_unlock_bh(&sec->lock);
768 fail:
769         rcu_read_unlock();
770         return rc;
771 }
772 
773 static struct mac802154_llsec_device*
774 llsec_lookup_dev(struct mac802154_llsec *sec,
775                  const struct ieee802154_addr *addr)
776 {
777         struct ieee802154_addr devaddr = *addr;
778         struct mac802154_llsec_device *dev = NULL;
779 
780         if (devaddr.mode == IEEE802154_ADDR_NONE &&
781             llsec_recover_addr(sec, &devaddr) < 0)
782                 return NULL;
783 
784         if (devaddr.mode == IEEE802154_ADDR_SHORT) {
785                 u32 key = llsec_dev_hash_short(devaddr.short_addr,
786                                                devaddr.pan_id);
787 
788                 hash_for_each_possible_rcu(sec->devices_short, dev,
789                                            bucket_s, key) {
790                         if (dev->dev.pan_id == devaddr.pan_id &&
791                             dev->dev.short_addr == devaddr.short_addr)
792                                 return dev;
793                 }
794         } else {
795                 u64 key = llsec_dev_hash_long(devaddr.extended_addr);
796 
797                 hash_for_each_possible_rcu(sec->devices_hw, dev,
798                                            bucket_hw, key) {
799                         if (dev->dev.hwaddr == devaddr.extended_addr)
800                                 return dev;
801                 }
802         }
803 
804         return NULL;
805 }
806 
807 static int
808 llsec_lookup_seclevel(const struct mac802154_llsec *sec,
809                       u8 frame_type, u8 cmd_frame_id,
810                       struct ieee802154_llsec_seclevel *rlevel)
811 {
812         struct ieee802154_llsec_seclevel *level;
813 
814         list_for_each_entry_rcu(level, &sec->table.security_levels, list) {
815                 if (level->frame_type == frame_type &&
816                     (frame_type != IEEE802154_FC_TYPE_MAC_CMD ||
817                      level->cmd_frame_id == cmd_frame_id)) {
818                         *rlevel = *level;
819                         return 0;
820                 }
821         }
822 
823         return -EINVAL;
824 }
825 
826 static int
827 llsec_do_decrypt_unauth(struct sk_buff *skb, const struct mac802154_llsec *sec,
828                         const struct ieee802154_hdr *hdr,
829                         struct mac802154_llsec_key *key, __le64 dev_addr)
830 {
831         u8 iv[16];
832         unsigned char *data;
833         int datalen;
834         struct scatterlist src;
835         SYNC_SKCIPHER_REQUEST_ON_STACK(req, key->tfm0);
836         int err;
837 
838         llsec_geniv(iv, dev_addr, &hdr->sec);
839         data = skb_mac_header(skb) + skb->mac_len;
840         datalen = skb_tail_pointer(skb) - data;
841 
842         sg_init_one(&src, data, datalen);
843 
844         skcipher_request_set_sync_tfm(req, key->tfm0);
845         skcipher_request_set_callback(req, 0, NULL, NULL);
846         skcipher_request_set_crypt(req, &src, &src, datalen, iv);
847 
848         err = crypto_skcipher_decrypt(req);
849         skcipher_request_zero(req);
850         return err;
851 }
852 
853 static int
854 llsec_do_decrypt_auth(struct sk_buff *skb, const struct mac802154_llsec *sec,
855                       const struct ieee802154_hdr *hdr,
856                       struct mac802154_llsec_key *key, __le64 dev_addr)
857 {
858         u8 iv[16];
859         unsigned char *data;
860         int authlen, datalen, assoclen, rc;
861         struct scatterlist sg;
862         struct aead_request *req;
863 
864         authlen = ieee802154_sechdr_authtag_len(&hdr->sec);
865         llsec_geniv(iv, dev_addr, &hdr->sec);
866 
867         req = aead_request_alloc(llsec_tfm_by_len(key, authlen), GFP_ATOMIC);
868         if (!req)
869                 return -ENOMEM;
870 
871         assoclen = skb->mac_len;
872 
873         data = skb_mac_header(skb) + skb->mac_len;
874         datalen = skb_tail_pointer(skb) - data;
875 
876         sg_init_one(&sg, skb_mac_header(skb), assoclen + datalen);
877 
878         if (!(hdr->sec.level & IEEE802154_SCF_SECLEVEL_ENC)) {
879                 assoclen += datalen - authlen;
880                 datalen = authlen;
881         }
882 
883         aead_request_set_callback(req, 0, NULL, NULL);
884         aead_request_set_crypt(req, &sg, &sg, datalen, iv);
885         aead_request_set_ad(req, assoclen);
886 
887         rc = crypto_aead_decrypt(req);
888 
889         kzfree(req);
890         skb_trim(skb, skb->len - authlen);
891 
892         return rc;
893 }
894 
895 static int
896 llsec_do_decrypt(struct sk_buff *skb, const struct mac802154_llsec *sec,
897                  const struct ieee802154_hdr *hdr,
898                  struct mac802154_llsec_key *key, __le64 dev_addr)
899 {
900         if (hdr->sec.level == IEEE802154_SCF_SECLEVEL_ENC)
901                 return llsec_do_decrypt_unauth(skb, sec, hdr, key, dev_addr);
902         else
903                 return llsec_do_decrypt_auth(skb, sec, hdr, key, dev_addr);
904 }
905 
906 static int
907 llsec_update_devkey_record(struct mac802154_llsec_device *dev,
908                            const struct ieee802154_llsec_key_id *in_key)
909 {
910         struct mac802154_llsec_device_key *devkey;
911 
912         devkey = llsec_devkey_find(dev, in_key);
913 
914         if (!devkey) {
915                 struct mac802154_llsec_device_key *next;
916 
917                 next = kzalloc(sizeof(*devkey), GFP_ATOMIC);
918                 if (!next)
919                         return -ENOMEM;
920 
921                 next->devkey.key_id = *in_key;
922 
923                 spin_lock_bh(&dev->lock);
924 
925                 devkey = llsec_devkey_find(dev, in_key);
926                 if (!devkey)
927                         list_add_rcu(&next->devkey.list, &dev->dev.keys);
928                 else
929                         kzfree(next);
930 
931                 spin_unlock_bh(&dev->lock);
932         }
933 
934         return 0;
935 }
936 
937 static int
938 llsec_update_devkey_info(struct mac802154_llsec_device *dev,
939                          const struct ieee802154_llsec_key_id *in_key,
940                          u32 frame_counter)
941 {
942         struct mac802154_llsec_device_key *devkey = NULL;
943 
944         if (dev->dev.key_mode == IEEE802154_LLSEC_DEVKEY_RESTRICT) {
945                 devkey = llsec_devkey_find(dev, in_key);
946                 if (!devkey)
947                         return -ENOENT;
948         }
949 
950         if (dev->dev.key_mode == IEEE802154_LLSEC_DEVKEY_RECORD) {
951                 int rc = llsec_update_devkey_record(dev, in_key);
952 
953                 if (rc < 0)
954                         return rc;
955         }
956 
957         spin_lock_bh(&dev->lock);
958 
959         if ((!devkey && frame_counter < dev->dev.frame_counter) ||
960             (devkey && frame_counter < devkey->devkey.frame_counter)) {
961                 spin_unlock_bh(&dev->lock);
962                 return -EINVAL;
963         }
964 
965         if (devkey)
966                 devkey->devkey.frame_counter = frame_counter + 1;
967         else
968                 dev->dev.frame_counter = frame_counter + 1;
969 
970         spin_unlock_bh(&dev->lock);
971 
972         return 0;
973 }
974 
975 int mac802154_llsec_decrypt(struct mac802154_llsec *sec, struct sk_buff *skb)
976 {
977         struct ieee802154_hdr hdr;
978         struct mac802154_llsec_key *key;
979         struct ieee802154_llsec_key_id key_id;
980         struct mac802154_llsec_device *dev;
981         struct ieee802154_llsec_seclevel seclevel;
982         int err;
983         __le64 dev_addr;
984         u32 frame_ctr;
985 
986         if (ieee802154_hdr_peek(skb, &hdr) < 0)
987                 return -EINVAL;
988         if (!hdr.fc.security_enabled)
989                 return 0;
990         if (hdr.fc.version == 0)
991                 return -EINVAL;
992 
993         read_lock_bh(&sec->lock);
994         if (!sec->params.enabled) {
995                 read_unlock_bh(&sec->lock);
996                 return -EINVAL;
997         }
998         read_unlock_bh(&sec->lock);
999 
1000         rcu_read_lock();
1001 
1002         key = llsec_lookup_key(sec, &hdr, &hdr.source, &key_id);
1003         if (!key) {
1004                 err = -ENOKEY;
1005                 goto fail;
1006         }
1007 
1008         dev = llsec_lookup_dev(sec, &hdr.source);
1009         if (!dev) {
1010                 err = -EINVAL;
1011                 goto fail_dev;
1012         }
1013 
1014         if (llsec_lookup_seclevel(sec, hdr.fc.type, 0, &seclevel) < 0) {
1015                 err = -EINVAL;
1016                 goto fail_dev;
1017         }
1018 
1019         if (!(seclevel.sec_levels & BIT(hdr.sec.level)) &&
1020             (hdr.sec.level == 0 && seclevel.device_override &&
1021              !dev->dev.seclevel_exempt)) {
1022                 err = -EINVAL;
1023                 goto fail_dev;
1024         }
1025 
1026         frame_ctr = le32_to_cpu(hdr.sec.frame_counter);
1027 
1028         if (frame_ctr == 0xffffffff) {
1029                 err = -EOVERFLOW;
1030                 goto fail_dev;
1031         }
1032 
1033         err = llsec_update_devkey_info(dev, &key_id, frame_ctr);
1034         if (err)
1035                 goto fail_dev;
1036 
1037         dev_addr = dev->dev.hwaddr;
1038 
1039         rcu_read_unlock();
1040 
1041         err = llsec_do_decrypt(skb, sec, &hdr, key, dev_addr);
1042         llsec_key_put(key);
1043         return err;
1044 
1045 fail_dev:
1046         llsec_key_put(key);
1047 fail:
1048         rcu_read_unlock();
1049         return err;
1050 }
1051 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp