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

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

Version: ~ [ linux-5.16-rc3 ] ~ [ linux-5.15.5 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.82 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.162 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.218 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.256 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.291 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.293 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ 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.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 <phoebe.buckheister@itwm.fraunhofer.de>
 15  */
 16 
 17 #include <linux/err.h>
 18 #include <linux/bug.h>
 19 #include <linux/completion.h>
 20 #include <linux/ieee802154.h>
 21 #include <linux/rculist.h>
 22 
 23 #include <crypto/aead.h>
 24 #include <crypto/skcipher.h>
 25 
 26 #include "ieee802154_i.h"
 27 #include "llsec.h"
 28 
 29 static void llsec_key_put(struct mac802154_llsec_key *key);
 30 static bool llsec_key_id_equal(const struct ieee802154_llsec_key_id *a,
 31                                const struct ieee802154_llsec_key_id *b);
 32 
 33 static void llsec_dev_free(struct mac802154_llsec_device *dev);
 34 
 35 void 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 
 49 void 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);
 60                 kzfree(msl);
 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);
 77                 kzfree(key);
 78         }
 79 }
 80 
 81 int 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 
 91 int 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 
121 static struct mac802154_llsec_key*
122 llsec_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);
140                 if (IS_ERR(key->tfm[i]))
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 
149         key->tfm0 = crypto_alloc_skcipher("ctr(aes)", 0, CRYPTO_ALG_ASYNC);
150         if (IS_ERR(key->tfm0))
151                 goto err_tfm;
152 
153         if (crypto_skcipher_setkey(key->tfm0, template->key,
154                                    IEEE802154_LLSEC_KEY_SIZE))
155                 goto err_tfm0;
156 
157         return key;
158 
159 err_tfm0:
160         crypto_free_skcipher(key->tfm0);
161 err_tfm:
162         for (i = 0; i < ARRAY_SIZE(key->tfm); i++)
163                 if (key->tfm[i])
164                         crypto_free_aead(key->tfm[i]);
165 
166         kzfree(key);
167         return NULL;
168 }
169 
170 static 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 
180         crypto_free_skcipher(key->tfm0);
181         kzfree(key);
182 }
183 
184 static struct mac802154_llsec_key*
185 llsec_key_get(struct mac802154_llsec_key *key)
186 {
187         kref_get(&key->ref);
188         return key;
189 }
190 
191 static void llsec_key_put(struct mac802154_llsec_key *key)
192 {
193         kref_put(&key->ref, llsec_key_release);
194 }
195 
196 static 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) {
209         case IEEE802154_SCF_KEY_INDEX:
210                 return true;
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 
220 int 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 
271 fail:
272         kzfree(new);
273         return -ENOMEM;
274 }
275 
276 int 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)) {
287                         list_del_rcu(&pos->list);
288                         llsec_key_put(mkey);
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                 kzfree(devkey);
353         }
354 
355         kzfree(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         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_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         kzfree(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         if (hlen < 0 || hdr.fc.type != IEEE802154_FC_TYPE_DATA)
719                 return -EINVAL;
720 
721         if (!hdr.fc.security_enabled ||
722             (hdr.sec.level == IEEE802154_SCF_SECLEVEL_NONE)) {
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 
772         return rc;
773 
774 fail_read:
775         read_unlock_bh(&sec->lock);
776 fail:
777         rcu_read_unlock();
778         return rc;
779 }
780 
781 static struct mac802154_llsec_device*
782 llsec_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 
815 static int
816 llsec_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 
834 static int
835 llsec_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;
843         SKCIPHER_REQUEST_ON_STACK(req, key->tfm0);
844         int err;
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 
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;
859 }
860 
861 static int
862 llsec_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;
869         struct scatterlist sg;
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 
879         assoclen = skb->mac_len;
880 
881         data = skb_mac_header(skb) + skb->mac_len;
882         datalen = skb_tail_pointer(skb) - data;
883 
884         sg_init_one(&sg, skb_mac_header(skb), assoclen + datalen);
885 
886         if (!(hdr->sec.level & IEEE802154_SCF_SECLEVEL_ENC)) {
887                 assoclen += datalen - authlen;
888                 datalen = authlen;
889         }
890 
891         aead_request_set_callback(req, 0, NULL, NULL);
892         aead_request_set_crypt(req, &sg, &sg, datalen, iv);
893         aead_request_set_ad(req, assoclen);
894 
895         rc = crypto_aead_decrypt(req);
896 
897         kzfree(req);
898         skb_trim(skb, skb->len - authlen);
899 
900         return rc;
901 }
902 
903 static int
904 llsec_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 
914 static int
915 llsec_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
937                         kzfree(next);
938 
939                 spin_unlock_bh(&dev->lock);
940         }
941 
942         return 0;
943 }
944 
945 static int
946 llsec_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 
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 
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 
983 int 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 
1053 fail_dev:
1054         llsec_key_put(key);
1055 fail:
1056         rcu_read_unlock();
1057         return err;
1058 }
1059 

~ [ 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