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