1 /*- 2 * Copyright (c) 2001-2007, by Cisco Systems, Inc. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are met: 6 * 7 * a) Redistributions of source code must retain the above copyright notice, 8 * this list of conditions and the following disclaimer. 9 * 10 * b) Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in 12 * the documentation and/or other materials provided with the distribution. 13 * 14 * c) Neither the name of Cisco Systems, Inc. nor the names of its 15 * contributors may be used to endorse or promote products derived 16 * from this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 20 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 28 * THE POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31 #include <sys/cdefs.h> 32 __FBSDID("$FreeBSD$"); 33 34 #include <netinet/sctp_os.h> 35 #include <netinet/sctp.h> 36 #include <netinet/sctp_header.h> 37 #include <netinet/sctp_pcb.h> 38 #include <netinet/sctp_var.h> 39 #include <netinet/sctp_sysctl.h> 40 #include <netinet/sctputil.h> 41 #include <netinet/sctp_indata.h> 42 #include <netinet/sctp_output.h> 43 #include <netinet/sctp_auth.h> 44 45 #ifdef SCTP_DEBUG 46 #define SCTP_AUTH_DEBUG (sctp_debug_on & SCTP_DEBUG_AUTH1) 47 #define SCTP_AUTH_DEBUG2 (sctp_debug_on & SCTP_DEBUG_AUTH2) 48 #endif /* SCTP_DEBUG */ 49 50 51 inline void 52 sctp_clear_chunklist(sctp_auth_chklist_t * chklist) 53 { 54 bzero(chklist, sizeof(*chklist)); 55 /* chklist->num_chunks = 0; */ 56 } 57 58 sctp_auth_chklist_t * 59 sctp_alloc_chunklist(void) 60 { 61 sctp_auth_chklist_t *chklist; 62 63 SCTP_MALLOC(chklist, sctp_auth_chklist_t *, sizeof(*chklist), 64 SCTP_M_AUTH_CL); 65 if (chklist == NULL) { 66 SCTPDBG(SCTP_DEBUG_AUTH1, "sctp_alloc_chunklist: failed to get memory!\n"); 67 } else { 68 sctp_clear_chunklist(chklist); 69 } 70 return (chklist); 71 } 72 73 void 74 sctp_free_chunklist(sctp_auth_chklist_t * list) 75 { 76 if (list != NULL) 77 SCTP_FREE(list, SCTP_M_AUTH_CL); 78 } 79 80 sctp_auth_chklist_t * 81 sctp_copy_chunklist(sctp_auth_chklist_t * list) 82 { 83 sctp_auth_chklist_t *new_list; 84 85 if (list == NULL) 86 return (NULL); 87 88 /* get a new list */ 89 new_list = sctp_alloc_chunklist(); 90 if (new_list == NULL) 91 return (NULL); 92 /* copy it */ 93 bcopy(list, new_list, sizeof(*new_list)); 94 95 return (new_list); 96 } 97 98 99 /* 100 * add a chunk to the required chunks list 101 */ 102 int 103 sctp_auth_add_chunk(uint8_t chunk, sctp_auth_chklist_t * list) 104 { 105 if (list == NULL) 106 return (-1); 107 108 /* is chunk restricted? */ 109 if ((chunk == SCTP_INITIATION) || 110 (chunk == SCTP_INITIATION_ACK) || 111 (chunk == SCTP_SHUTDOWN_COMPLETE) || 112 (chunk == SCTP_AUTHENTICATION)) { 113 return (-1); 114 } 115 if (list->chunks[chunk] == 0) { 116 list->chunks[chunk] = 1; 117 list->num_chunks++; 118 SCTPDBG(SCTP_DEBUG_AUTH1, 119 "SCTP: added chunk %u (0x%02x) to Auth list\n", 120 chunk, chunk); 121 } 122 return (0); 123 } 124 125 /* 126 * delete a chunk from the required chunks list 127 */ 128 int 129 sctp_auth_delete_chunk(uint8_t chunk, sctp_auth_chklist_t * list) 130 { 131 if (list == NULL) 132 return (-1); 133 134 /* is chunk restricted? */ 135 if ((chunk == SCTP_ASCONF) || 136 (chunk == SCTP_ASCONF_ACK)) { 137 return (-1); 138 } 139 if (list->chunks[chunk] == 1) { 140 list->chunks[chunk] = 0; 141 list->num_chunks--; 142 SCTPDBG(SCTP_DEBUG_AUTH1, 143 "SCTP: deleted chunk %u (0x%02x) from Auth list\n", 144 chunk, chunk); 145 } 146 return (0); 147 } 148 149 inline size_t 150 sctp_auth_get_chklist_size(const sctp_auth_chklist_t * list) 151 { 152 if (list == NULL) 153 return (0); 154 else 155 return (list->num_chunks); 156 } 157 158 /* 159 * set the default list of chunks requiring AUTH 160 */ 161 void 162 sctp_auth_set_default_chunks(sctp_auth_chklist_t * list) 163 { 164 (void)sctp_auth_add_chunk(SCTP_ASCONF, list); 165 (void)sctp_auth_add_chunk(SCTP_ASCONF_ACK, list); 166 } 167 168 /* 169 * return the current number and list of required chunks caller must 170 * guarantee ptr has space for up to 256 bytes 171 */ 172 int 173 sctp_serialize_auth_chunks(const sctp_auth_chklist_t * list, uint8_t * ptr) 174 { 175 int i, count = 0; 176 177 if (list == NULL) 178 return (0); 179 180 for (i = 0; i < 256; i++) { 181 if (list->chunks[i] != 0) { 182 *ptr++ = i; 183 count++; 184 } 185 } 186 return (count); 187 } 188 189 int 190 sctp_pack_auth_chunks(const sctp_auth_chklist_t * list, uint8_t * ptr) 191 { 192 int i, size = 0; 193 194 if (list == NULL) 195 return (0); 196 197 if (list->num_chunks <= 32) { 198 /* just list them, one byte each */ 199 for (i = 0; i < 256; i++) { 200 if (list->chunks[i] != 0) { 201 *ptr++ = i; 202 size++; 203 } 204 } 205 } else { 206 int index, offset; 207 208 /* pack into a 32 byte bitfield */ 209 for (i = 0; i < 256; i++) { 210 if (list->chunks[i] != 0) { 211 index = i / 8; 212 offset = i % 8; 213 ptr[index] |= (1 << offset); 214 } 215 } 216 size = 32; 217 } 218 return (size); 219 } 220 221 int 222 sctp_unpack_auth_chunks(const uint8_t * ptr, uint8_t num_chunks, 223 sctp_auth_chklist_t * list) 224 { 225 int i; 226 int size; 227 228 if (list == NULL) 229 return (0); 230 231 if (num_chunks <= 32) { 232 /* just pull them, one byte each */ 233 for (i = 0; i < num_chunks; i++) { 234 (void)sctp_auth_add_chunk(*ptr++, list); 235 } 236 size = num_chunks; 237 } else { 238 int index, offset; 239 240 /* unpack from a 32 byte bitfield */ 241 for (index = 0; index < 32; index++) { 242 for (offset = 0; offset < 8; offset++) { 243 if (ptr[index] & (1 << offset)) { 244 (void)sctp_auth_add_chunk((index * 8) + offset, list); 245 } 246 } 247 } 248 size = 32; 249 } 250 return (size); 251 } 252 253 254 /* 255 * allocate structure space for a key of length keylen 256 */ 257 sctp_key_t * 258 sctp_alloc_key(uint32_t keylen) 259 { 260 sctp_key_t *new_key; 261 262 SCTP_MALLOC(new_key, sctp_key_t *, sizeof(*new_key) + keylen, 263 SCTP_M_AUTH_KY); 264 if (new_key == NULL) { 265 /* out of memory */ 266 return (NULL); 267 } 268 new_key->keylen = keylen; 269 return (new_key); 270 } 271 272 void 273 sctp_free_key(sctp_key_t * key) 274 { 275 if (key != NULL) 276 SCTP_FREE(key, SCTP_M_AUTH_KY); 277 } 278 279 void 280 sctp_print_key(sctp_key_t * key, const char *str) 281 { 282 uint32_t i; 283 284 if (key == NULL) { 285 printf("%s: [Null key]\n", str); 286 return; 287 } 288 printf("%s: len %u, ", str, key->keylen); 289 if (key->keylen) { 290 for (i = 0; i < key->keylen; i++) 291 printf("%02x", key->key[i]); 292 printf("\n"); 293 } else { 294 printf("[Null key]\n"); 295 } 296 } 297 298 void 299 sctp_show_key(sctp_key_t * key, const char *str) 300 { 301 uint32_t i; 302 303 if (key == NULL) { 304 printf("%s: [Null key]\n", str); 305 return; 306 } 307 printf("%s: len %u, ", str, key->keylen); 308 if (key->keylen) { 309 for (i = 0; i < key->keylen; i++) 310 printf("%02x", key->key[i]); 311 printf("\n"); 312 } else { 313 printf("[Null key]\n"); 314 } 315 } 316 317 static inline uint32_t 318 sctp_get_keylen(sctp_key_t * key) 319 { 320 if (key != NULL) 321 return (key->keylen); 322 else 323 return (0); 324 } 325 326 /* 327 * generate a new random key of length 'keylen' 328 */ 329 sctp_key_t * 330 sctp_generate_random_key(uint32_t keylen) 331 { 332 sctp_key_t *new_key; 333 334 /* validate keylen */ 335 if (keylen > SCTP_AUTH_RANDOM_SIZE_MAX) 336 keylen = SCTP_AUTH_RANDOM_SIZE_MAX; 337 338 new_key = sctp_alloc_key(keylen); 339 if (new_key == NULL) { 340 /* out of memory */ 341 return (NULL); 342 } 343 SCTP_READ_RANDOM(new_key->key, keylen); 344 new_key->keylen = keylen; 345 return (new_key); 346 } 347 348 sctp_key_t * 349 sctp_set_key(uint8_t * key, uint32_t keylen) 350 { 351 sctp_key_t *new_key; 352 353 new_key = sctp_alloc_key(keylen); 354 if (new_key == NULL) { 355 /* out of memory */ 356 return (NULL); 357 } 358 bcopy(key, new_key->key, keylen); 359 return (new_key); 360 } 361 362 /* 363 * given two keys of variable size, compute which key is "larger/smaller" 364 * returns: 1 if key1 > key2 -1 if key1 < key2 0 if key1 = key2 365 */ 366 static int 367 sctp_compare_key(sctp_key_t * key1, sctp_key_t * key2) 368 { 369 uint32_t maxlen; 370 uint32_t i; 371 uint32_t key1len, key2len; 372 uint8_t *key_1, *key_2; 373 uint8_t temp[SCTP_AUTH_RANDOM_SIZE_MAX]; 374 375 /* sanity/length check */ 376 key1len = sctp_get_keylen(key1); 377 key2len = sctp_get_keylen(key2); 378 if ((key1len == 0) && (key2len == 0)) 379 return (0); 380 else if (key1len == 0) 381 return (-1); 382 else if (key2len == 0) 383 return (1); 384 385 if (key1len != key2len) { 386 if (key1len >= key2len) 387 maxlen = key1len; 388 else 389 maxlen = key2len; 390 bzero(temp, maxlen); 391 if (key1len < maxlen) { 392 /* prepend zeroes to key1 */ 393 bcopy(key1->key, temp + (maxlen - key1len), key1len); 394 key_1 = temp; 395 key_2 = key2->key; 396 } else { 397 /* prepend zeroes to key2 */ 398 bcopy(key2->key, temp + (maxlen - key2len), key2len); 399 key_1 = key1->key; 400 key_2 = temp; 401 } 402 } else { 403 maxlen = key1len; 404 key_1 = key1->key; 405 key_2 = key2->key; 406 } 407 408 for (i = 0; i < maxlen; i++) { 409 if (*key_1 > *key_2) 410 return (1); 411 else if (*key_1 < *key_2) 412 return (-1); 413 key_1++; 414 key_2++; 415 } 416 417 /* keys are equal value, so check lengths */ 418 if (key1len == key2len) 419 return (0); 420 else if (key1len < key2len) 421 return (-1); 422 else 423 return (1); 424 } 425 426 /* 427 * generate the concatenated keying material based on the two keys and the 428 * shared key (if available). draft-ietf-tsvwg-auth specifies the specific 429 * order for concatenation 430 */ 431 sctp_key_t * 432 sctp_compute_hashkey(sctp_key_t * key1, sctp_key_t * key2, sctp_key_t * shared) 433 { 434 uint32_t keylen; 435 sctp_key_t *new_key; 436 uint8_t *key_ptr; 437 438 keylen = sctp_get_keylen(key1) + sctp_get_keylen(key2) + 439 sctp_get_keylen(shared); 440 441 if (keylen > 0) { 442 /* get space for the new key */ 443 new_key = sctp_alloc_key(keylen); 444 if (new_key == NULL) { 445 /* out of memory */ 446 return (NULL); 447 } 448 new_key->keylen = keylen; 449 key_ptr = new_key->key; 450 } else { 451 /* all keys empty/null?! */ 452 return (NULL); 453 } 454 455 /* concatenate the keys */ 456 if (sctp_compare_key(key1, key2) <= 0) { 457 /* key is key1 + shared + key2 */ 458 if (sctp_get_keylen(key1)) { 459 bcopy(key1->key, key_ptr, key1->keylen); 460 key_ptr += key1->keylen; 461 } 462 if (sctp_get_keylen(shared)) { 463 bcopy(shared->key, key_ptr, shared->keylen); 464 key_ptr += shared->keylen; 465 } 466 if (sctp_get_keylen(key2)) { 467 bcopy(key2->key, key_ptr, key2->keylen); 468 key_ptr += key2->keylen; 469 } 470 } else { 471 /* key is key2 + shared + key1 */ 472 if (sctp_get_keylen(key2)) { 473 bcopy(key2->key, key_ptr, key2->keylen); 474 key_ptr += key2->keylen; 475 } 476 if (sctp_get_keylen(shared)) { 477 bcopy(shared->key, key_ptr, shared->keylen); 478 key_ptr += shared->keylen; 479 } 480 if (sctp_get_keylen(key1)) { 481 bcopy(key1->key, key_ptr, key1->keylen); 482 key_ptr += key1->keylen; 483 } 484 } 485 return (new_key); 486 } 487 488 489 sctp_sharedkey_t * 490 sctp_alloc_sharedkey(void) 491 { 492 sctp_sharedkey_t *new_key; 493 494 SCTP_MALLOC(new_key, sctp_sharedkey_t *, sizeof(*new_key), 495 SCTP_M_AUTH_KY); 496 if (new_key == NULL) { 497 /* out of memory */ 498 return (NULL); 499 } 500 new_key->keyid = 0; 501 new_key->key = NULL; 502 return (new_key); 503 } 504 505 void 506 sctp_free_sharedkey(sctp_sharedkey_t * skey) 507 { 508 if (skey != NULL) { 509 if (skey->key != NULL) 510 sctp_free_key(skey->key); 511 SCTP_FREE(skey, SCTP_M_AUTH_KY); 512 } 513 } 514 515 sctp_sharedkey_t * 516 sctp_find_sharedkey(struct sctp_keyhead *shared_keys, uint16_t key_id) 517 { 518 sctp_sharedkey_t *skey; 519 520 LIST_FOREACH(skey, shared_keys, next) { 521 if (skey->keyid == key_id) 522 return (skey); 523 } 524 return (NULL); 525 } 526 527 void 528 sctp_insert_sharedkey(struct sctp_keyhead *shared_keys, 529 sctp_sharedkey_t * new_skey) 530 { 531 sctp_sharedkey_t *skey; 532 533 if ((shared_keys == NULL) || (new_skey == NULL)) 534 return; 535 536 /* insert into an empty list? */ 537 if (SCTP_LIST_EMPTY(shared_keys)) { 538 LIST_INSERT_HEAD(shared_keys, new_skey, next); 539 return; 540 } 541 /* insert into the existing list, ordered by key id */ 542 LIST_FOREACH(skey, shared_keys, next) { 543 if (new_skey->keyid < skey->keyid) { 544 /* insert it before here */ 545 LIST_INSERT_BEFORE(skey, new_skey, next); 546 return; 547 } else if (new_skey->keyid == skey->keyid) { 548 /* replace the existing key */ 549 SCTPDBG(SCTP_DEBUG_AUTH1, 550 "replacing shared key id %u\n", 551 new_skey->keyid); 552 LIST_INSERT_BEFORE(skey, new_skey, next); 553 LIST_REMOVE(skey, next); 554 sctp_free_sharedkey(skey); 555 return; 556 } 557 if (LIST_NEXT(skey, next) == NULL) { 558 /* belongs at the end of the list */ 559 LIST_INSERT_AFTER(skey, new_skey, next); 560 return; 561 } 562 } 563 } 564 565 static sctp_sharedkey_t * 566 sctp_copy_sharedkey(const sctp_sharedkey_t * skey) 567 { 568 sctp_sharedkey_t *new_skey; 569 570 if (skey == NULL) 571 return (NULL); 572 new_skey = sctp_alloc_sharedkey(); 573 if (new_skey == NULL) 574 return (NULL); 575 if (skey->key != NULL) 576 new_skey->key = sctp_set_key(skey->key->key, skey->key->keylen); 577 else 578 new_skey->key = NULL; 579 new_skey->keyid = skey->keyid; 580 return (new_skey); 581 } 582 583 int 584 sctp_copy_skeylist(const struct sctp_keyhead *src, struct sctp_keyhead *dest) 585 { 586 sctp_sharedkey_t *skey, *new_skey; 587 int count = 0; 588 589 if ((src == NULL) || (dest == NULL)) 590 return (0); 591 LIST_FOREACH(skey, src, next) { 592 new_skey = sctp_copy_sharedkey(skey); 593 if (new_skey != NULL) { 594 sctp_insert_sharedkey(dest, new_skey); 595 count++; 596 } 597 } 598 return (count); 599 } 600 601 602 sctp_hmaclist_t * 603 sctp_alloc_hmaclist(uint8_t num_hmacs) 604 { 605 sctp_hmaclist_t *new_list; 606 int alloc_size; 607 608 alloc_size = sizeof(*new_list) + num_hmacs * sizeof(new_list->hmac[0]); 609 SCTP_MALLOC(new_list, sctp_hmaclist_t *, alloc_size, 610 SCTP_M_AUTH_HL); 611 if (new_list == NULL) { 612 /* out of memory */ 613 return (NULL); 614 } 615 new_list->max_algo = num_hmacs; 616 new_list->num_algo = 0; 617 return (new_list); 618 } 619 620 void 621 sctp_free_hmaclist(sctp_hmaclist_t * list) 622 { 623 if (list != NULL) { 624 SCTP_FREE(list, SCTP_M_AUTH_HL); 625 list = NULL; 626 } 627 } 628 629 int 630 sctp_auth_add_hmacid(sctp_hmaclist_t * list, uint16_t hmac_id) 631 { 632 int i; 633 634 if (list == NULL) 635 return (-1); 636 if (list->num_algo == list->max_algo) { 637 SCTPDBG(SCTP_DEBUG_AUTH1, 638 "SCTP: HMAC id list full, ignoring add %u\n", hmac_id); 639 return (-1); 640 } 641 if ((hmac_id != SCTP_AUTH_HMAC_ID_SHA1) && 642 #ifdef HAVE_SHA224 643 (hmac_id != SCTP_AUTH_HMAC_ID_SHA224) && 644 #endif 645 #ifdef HAVE_SHA2 646 (hmac_id != SCTP_AUTH_HMAC_ID_SHA256) && 647 (hmac_id != SCTP_AUTH_HMAC_ID_SHA384) && 648 (hmac_id != SCTP_AUTH_HMAC_ID_SHA512) && 649 #endif 650 (hmac_id != SCTP_AUTH_HMAC_ID_MD5)) { 651 return (-1); 652 } 653 /* Now is it already in the list */ 654 for (i = 0; i < list->num_algo; i++) { 655 if (list->hmac[i] == hmac_id) { 656 /* already in list */ 657 return (-1); 658 } 659 } 660 SCTPDBG(SCTP_DEBUG_AUTH1, "SCTP: add HMAC id %u to list\n", hmac_id); 661 list->hmac[list->num_algo++] = hmac_id; 662 return (0); 663 } 664 665 sctp_hmaclist_t * 666 sctp_copy_hmaclist(sctp_hmaclist_t * list) 667 { 668 sctp_hmaclist_t *new_list; 669 int i; 670 671 if (list == NULL) 672 return (NULL); 673 /* get a new list */ 674 new_list = sctp_alloc_hmaclist(list->max_algo); 675 if (new_list == NULL) 676 return (NULL); 677 /* copy it */ 678 new_list->max_algo = list->max_algo; 679 new_list->num_algo = list->num_algo; 680 for (i = 0; i < list->num_algo; i++) 681 new_list->hmac[i] = list->hmac[i]; 682 return (new_list); 683 } 684 685 sctp_hmaclist_t * 686 sctp_default_supported_hmaclist(void) 687 { 688 sctp_hmaclist_t *new_list; 689 690 new_list = sctp_alloc_hmaclist(2); 691 if (new_list == NULL) 692 return (NULL); 693 (void)sctp_auth_add_hmacid(new_list, SCTP_AUTH_HMAC_ID_SHA1); 694 (void)sctp_auth_add_hmacid(new_list, SCTP_AUTH_HMAC_ID_SHA256); 695 return (new_list); 696 } 697 698 /* 699 * HMAC algos are listed in priority/preference order find the best HMAC id 700 * to use for the peer based on local support 701 */ 702 uint16_t 703 sctp_negotiate_hmacid(sctp_hmaclist_t * peer, sctp_hmaclist_t * local) 704 { 705 int i, j; 706 707 if ((local == NULL) || (peer == NULL)) 708 return (SCTP_AUTH_HMAC_ID_RSVD); 709 710 for (i = 0; i < peer->num_algo; i++) { 711 for (j = 0; j < local->num_algo; j++) { 712 if (peer->hmac[i] == local->hmac[j]) { 713 #ifndef SCTP_AUTH_DRAFT_04 714 /* "skip" MD5 as it's been deprecated */ 715 if (peer->hmac[i] == SCTP_AUTH_HMAC_ID_MD5) 716 continue; 717 #endif 718 719 /* found the "best" one */ 720 SCTPDBG(SCTP_DEBUG_AUTH1, 721 "SCTP: negotiated peer HMAC id %u\n", 722 peer->hmac[i]); 723 return (peer->hmac[i]); 724 } 725 } 726 } 727 /* didn't find one! */ 728 return (SCTP_AUTH_HMAC_ID_RSVD); 729 } 730 731 /* 732 * serialize the HMAC algo list and return space used caller must guarantee 733 * ptr has appropriate space 734 */ 735 int 736 sctp_serialize_hmaclist(sctp_hmaclist_t * list, uint8_t * ptr) 737 { 738 int i; 739 uint16_t hmac_id; 740 741 if (list == NULL) 742 return (0); 743 744 for (i = 0; i < list->num_algo; i++) { 745 hmac_id = htons(list->hmac[i]); 746 bcopy(&hmac_id, ptr, sizeof(hmac_id)); 747 ptr += sizeof(hmac_id); 748 } 749 return (list->num_algo * sizeof(hmac_id)); 750 } 751 752 int 753 sctp_verify_hmac_param(struct sctp_auth_hmac_algo *hmacs, uint32_t num_hmacs) 754 { 755 uint32_t i; 756 uint16_t hmac_id; 757 uint32_t sha1_supported = 0; 758 759 for (i = 0; i < num_hmacs; i++) { 760 hmac_id = ntohs(hmacs->hmac_ids[i]); 761 if (hmac_id == SCTP_AUTH_HMAC_ID_SHA1) 762 sha1_supported = 1; 763 } 764 /* all HMAC id's are supported */ 765 if (sha1_supported == 0) 766 return (-1); 767 else 768 return (0); 769 } 770 771 sctp_authinfo_t * 772 sctp_alloc_authinfo(void) 773 { 774 sctp_authinfo_t *new_authinfo; 775 776 SCTP_MALLOC(new_authinfo, sctp_authinfo_t *, sizeof(*new_authinfo), 777 SCTP_M_AUTH_IF); 778 779 if (new_authinfo == NULL) { 780 /* out of memory */ 781 return (NULL); 782 } 783 bzero(&new_authinfo, sizeof(*new_authinfo)); 784 return (new_authinfo); 785 } 786 787 void 788 sctp_free_authinfo(sctp_authinfo_t * authinfo) 789 { 790 if (authinfo == NULL) 791 return; 792 793 if (authinfo->random != NULL) 794 sctp_free_key(authinfo->random); 795 if (authinfo->peer_random != NULL) 796 sctp_free_key(authinfo->peer_random); 797 if (authinfo->assoc_key != NULL) 798 sctp_free_key(authinfo->assoc_key); 799 if (authinfo->recv_key != NULL) 800 sctp_free_key(authinfo->recv_key); 801 802 /* We are NOT dynamically allocating authinfo's right now... */ 803 /* SCTP_FREE(authinfo, SCTP_M_AUTH_??); */ 804 } 805 806 807 inline uint32_t 808 sctp_get_auth_chunk_len(uint16_t hmac_algo) 809 { 810 int size; 811 812 size = sizeof(struct sctp_auth_chunk) + sctp_get_hmac_digest_len(hmac_algo); 813 return (SCTP_SIZE32(size)); 814 } 815 816 uint32_t 817 sctp_get_hmac_digest_len(uint16_t hmac_algo) 818 { 819 switch (hmac_algo) { 820 case SCTP_AUTH_HMAC_ID_SHA1: 821 return (SCTP_AUTH_DIGEST_LEN_SHA1); 822 case SCTP_AUTH_HMAC_ID_MD5: 823 return (SCTP_AUTH_DIGEST_LEN_MD5); 824 #ifdef HAVE_SHA224 825 case SCTP_AUTH_HMAC_ID_SHA224: 826 return (SCTP_AUTH_DIGEST_LEN_SHA224); 827 #endif 828 #ifdef HAVE_SHA2 829 case SCTP_AUTH_HMAC_ID_SHA256: 830 return (SCTP_AUTH_DIGEST_LEN_SHA256); 831 case SCTP_AUTH_HMAC_ID_SHA384: 832 return (SCTP_AUTH_DIGEST_LEN_SHA384); 833 case SCTP_AUTH_HMAC_ID_SHA512: 834 return (SCTP_AUTH_DIGEST_LEN_SHA512); 835 #endif 836 default: 837 /* unknown HMAC algorithm: can't do anything */ 838 return (0); 839 } /* end switch */ 840 } 841 842 static inline int 843 sctp_get_hmac_block_len(uint16_t hmac_algo) 844 { 845 switch (hmac_algo) { 846 case SCTP_AUTH_HMAC_ID_SHA1: 847 case SCTP_AUTH_HMAC_ID_MD5: 848 #ifdef HAVE_SHA224 849 case SCTP_AUTH_HMAC_ID_SHA224: 850 #endif 851 return (64); 852 #ifdef HAVE_SHA2 853 case SCTP_AUTH_HMAC_ID_SHA256: 854 return (64); 855 case SCTP_AUTH_HMAC_ID_SHA384: 856 case SCTP_AUTH_HMAC_ID_SHA512: 857 return (128); 858 #endif 859 case SCTP_AUTH_HMAC_ID_RSVD: 860 default: 861 /* unknown HMAC algorithm: can't do anything */ 862 return (0); 863 } /* end switch */ 864 } 865 866 static void 867 sctp_hmac_init(uint16_t hmac_algo, sctp_hash_context_t * ctx) 868 { 869 switch (hmac_algo) { 870 case SCTP_AUTH_HMAC_ID_SHA1: 871 SHA1_Init(&ctx->sha1); 872 break; 873 case SCTP_AUTH_HMAC_ID_MD5: 874 MD5_Init(&ctx->md5); 875 break; 876 #ifdef HAVE_SHA224 877 case SCTP_AUTH_HMAC_ID_SHA224: 878 break; 879 #endif 880 #ifdef HAVE_SHA2 881 case SCTP_AUTH_HMAC_ID_SHA256: 882 SHA256_Init(&ctx->sha256); 883 break; 884 case SCTP_AUTH_HMAC_ID_SHA384: 885 SHA384_Init(&ctx->sha384); 886 break; 887 case SCTP_AUTH_HMAC_ID_SHA512: 888 SHA512_Init(&ctx->sha512); 889 break; 890 #endif 891 case SCTP_AUTH_HMAC_ID_RSVD: 892 default: 893 /* unknown HMAC algorithm: can't do anything */ 894 return; 895 } /* end switch */ 896 } 897 898 static void 899 sctp_hmac_update(uint16_t hmac_algo, sctp_hash_context_t * ctx, 900 uint8_t * text, uint32_t textlen) 901 { 902 switch (hmac_algo) { 903 case SCTP_AUTH_HMAC_ID_SHA1: 904 SHA1_Update(&ctx->sha1, text, textlen); 905 break; 906 case SCTP_AUTH_HMAC_ID_MD5: 907 MD5_Update(&ctx->md5, text, textlen); 908 break; 909 #ifdef HAVE_SHA224 910 case SCTP_AUTH_HMAC_ID_SHA224: 911 break; 912 #endif 913 #ifdef HAVE_SHA2 914 case SCTP_AUTH_HMAC_ID_SHA256: 915 SHA256_Update(&ctx->sha256, text, textlen); 916 break; 917 case SCTP_AUTH_HMAC_ID_SHA384: 918 SHA384_Update(&ctx->sha384, text, textlen); 919 break; 920 case SCTP_AUTH_HMAC_ID_SHA512: 921 SHA512_Update(&ctx->sha512, text, textlen); 922 break; 923 #endif 924 case SCTP_AUTH_HMAC_ID_RSVD: 925 default: 926 /* unknown HMAC algorithm: can't do anything */ 927 return; 928 } /* end switch */ 929 } 930 931 static void 932 sctp_hmac_final(uint16_t hmac_algo, sctp_hash_context_t * ctx, 933 uint8_t * digest) 934 { 935 switch (hmac_algo) { 936 case SCTP_AUTH_HMAC_ID_SHA1: 937 SHA1_Final(digest, &ctx->sha1); 938 break; 939 case SCTP_AUTH_HMAC_ID_MD5: 940 MD5_Final(digest, &ctx->md5); 941 break; 942 #ifdef HAVE_SHA224 943 case SCTP_AUTH_HMAC_ID_SHA224: 944 break; 945 #endif 946 #ifdef HAVE_SHA2 947 case SCTP_AUTH_HMAC_ID_SHA256: 948 SHA256_Final(digest, &ctx->sha256); 949 break; 950 case SCTP_AUTH_HMAC_ID_SHA384: 951 /* SHA384 is truncated SHA512 */ 952 SHA384_Final(digest, &ctx->sha384); 953 break; 954 case SCTP_AUTH_HMAC_ID_SHA512: 955 SHA512_Final(digest, &ctx->sha512); 956 break; 957 #endif 958 case SCTP_AUTH_HMAC_ID_RSVD: 959 default: 960 /* unknown HMAC algorithm: can't do anything */ 961 return; 962 } /* end switch */ 963 } 964 965 /* 966 * Keyed-Hashing for Message Authentication: FIPS 198 (RFC 2104) 967 * 968 * Compute the HMAC digest using the desired hash key, text, and HMAC 969 * algorithm. Resulting digest is placed in 'digest' and digest length 970 * is returned, if the HMAC was performed. 971 * 972 * WARNING: it is up to the caller to supply sufficient space to hold the 973 * resultant digest. 974 */ 975 uint32_t 976 sctp_hmac(uint16_t hmac_algo, uint8_t * key, uint32_t keylen, 977 uint8_t * text, uint32_t textlen, uint8_t * digest) 978 { 979 uint32_t digestlen; 980 uint32_t blocklen; 981 sctp_hash_context_t ctx; 982 uint8_t ipad[128], opad[128]; /* keyed hash inner/outer pads */ 983 uint8_t temp[SCTP_AUTH_DIGEST_LEN_MAX]; 984 uint32_t i; 985 986 /* sanity check the material and length */ 987 if ((key == NULL) || (keylen == 0) || (text == NULL) || 988 (textlen == 0) || (digest == NULL)) { 989 /* can't do HMAC with empty key or text or digest store */ 990 return (0); 991 } 992 /* validate the hmac algo and get the digest length */ 993 digestlen = sctp_get_hmac_digest_len(hmac_algo); 994 if (digestlen == 0) 995 return (0); 996 997 /* hash the key if it is longer than the hash block size */ 998 blocklen = sctp_get_hmac_block_len(hmac_algo); 999 if (keylen > blocklen) { 1000 sctp_hmac_init(hmac_algo, &ctx); 1001 sctp_hmac_update(hmac_algo, &ctx, key, keylen); 1002 sctp_hmac_final(hmac_algo, &ctx, temp); 1003 /* set the hashed key as the key */ 1004 keylen = digestlen; 1005 key = temp; 1006 } 1007 /* initialize the inner/outer pads with the key and "append" zeroes */ 1008 bzero(ipad, blocklen); 1009 bzero(opad, blocklen); 1010 bcopy(key, ipad, keylen); 1011 bcopy(key, opad, keylen); 1012 1013 /* XOR the key with ipad and opad values */ 1014 for (i = 0; i < blocklen; i++) { 1015 ipad[i] ^= 0x36; 1016 opad[i] ^= 0x5c; 1017 } 1018 1019 /* perform inner hash */ 1020 sctp_hmac_init(hmac_algo, &ctx); 1021 sctp_hmac_update(hmac_algo, &ctx, ipad, blocklen); 1022 sctp_hmac_update(hmac_algo, &ctx, text, textlen); 1023 sctp_hmac_final(hmac_algo, &ctx, temp); 1024 1025 /* perform outer hash */ 1026 sctp_hmac_init(hmac_algo, &ctx); 1027 sctp_hmac_update(hmac_algo, &ctx, opad, blocklen); 1028 sctp_hmac_update(hmac_algo, &ctx, temp, digestlen); 1029 sctp_hmac_final(hmac_algo, &ctx, digest); 1030 1031 return (digestlen); 1032 } 1033 1034 /* mbuf version */ 1035 uint32_t 1036 sctp_hmac_m(uint16_t hmac_algo, uint8_t * key, uint32_t keylen, 1037 struct mbuf *m, uint32_t m_offset, uint8_t * digest, uint32_t trailer) 1038 { 1039 uint32_t digestlen; 1040 uint32_t blocklen; 1041 sctp_hash_context_t ctx; 1042 uint8_t ipad[128], opad[128]; /* keyed hash inner/outer pads */ 1043 uint8_t temp[SCTP_AUTH_DIGEST_LEN_MAX]; 1044 uint32_t i; 1045 struct mbuf *m_tmp; 1046 1047 /* sanity check the material and length */ 1048 if ((key == NULL) || (keylen == 0) || (m == NULL) || (digest == NULL)) { 1049 /* can't do HMAC with empty key or text or digest store */ 1050 return (0); 1051 } 1052 /* validate the hmac algo and get the digest length */ 1053 digestlen = sctp_get_hmac_digest_len(hmac_algo); 1054 if (digestlen == 0) 1055 return (0); 1056 1057 /* hash the key if it is longer than the hash block size */ 1058 blocklen = sctp_get_hmac_block_len(hmac_algo); 1059 if (keylen > blocklen) { 1060 sctp_hmac_init(hmac_algo, &ctx); 1061 sctp_hmac_update(hmac_algo, &ctx, key, keylen); 1062 sctp_hmac_final(hmac_algo, &ctx, temp); 1063 /* set the hashed key as the key */ 1064 keylen = digestlen; 1065 key = temp; 1066 } 1067 /* initialize the inner/outer pads with the key and "append" zeroes */ 1068 bzero(ipad, blocklen); 1069 bzero(opad, blocklen); 1070 bcopy(key, ipad, keylen); 1071 bcopy(key, opad, keylen); 1072 1073 /* XOR the key with ipad and opad values */ 1074 for (i = 0; i < blocklen; i++) { 1075 ipad[i] ^= 0x36; 1076 opad[i] ^= 0x5c; 1077 } 1078 1079 /* perform inner hash */ 1080 sctp_hmac_init(hmac_algo, &ctx); 1081 sctp_hmac_update(hmac_algo, &ctx, ipad, blocklen); 1082 /* find the correct starting mbuf and offset (get start of text) */ 1083 m_tmp = m; 1084 while ((m_tmp != NULL) && (m_offset >= (uint32_t) SCTP_BUF_LEN(m_tmp))) { 1085 m_offset -= SCTP_BUF_LEN(m_tmp); 1086 m_tmp = SCTP_BUF_NEXT(m_tmp); 1087 } 1088 /* now use the rest of the mbuf chain for the text */ 1089 while (m_tmp != NULL) { 1090 if ((SCTP_BUF_NEXT(m_tmp) == NULL) && trailer) { 1091 sctp_hmac_update(hmac_algo, &ctx, mtod(m_tmp, uint8_t *) + m_offset, 1092 SCTP_BUF_LEN(m_tmp) - (trailer + m_offset)); 1093 } else { 1094 sctp_hmac_update(hmac_algo, &ctx, mtod(m_tmp, uint8_t *) + m_offset, 1095 SCTP_BUF_LEN(m_tmp) - m_offset); 1096 } 1097 1098 /* clear the offset since it's only for the first mbuf */ 1099 m_offset = 0; 1100 m_tmp = SCTP_BUF_NEXT(m_tmp); 1101 } 1102 sctp_hmac_final(hmac_algo, &ctx, temp); 1103 1104 /* perform outer hash */ 1105 sctp_hmac_init(hmac_algo, &ctx); 1106 sctp_hmac_update(hmac_algo, &ctx, opad, blocklen); 1107 sctp_hmac_update(hmac_algo, &ctx, temp, digestlen); 1108 sctp_hmac_final(hmac_algo, &ctx, digest); 1109 1110 return (digestlen); 1111 } 1112 1113 /* 1114 * verify the HMAC digest using the desired hash key, text, and HMAC 1115 * algorithm. Returns -1 on error, 0 on success. 1116 */ 1117 int 1118 sctp_verify_hmac(uint16_t hmac_algo, uint8_t * key, uint32_t keylen, 1119 uint8_t * text, uint32_t textlen, 1120 uint8_t * digest, uint32_t digestlen) 1121 { 1122 uint32_t len; 1123 uint8_t temp[SCTP_AUTH_DIGEST_LEN_MAX]; 1124 1125 /* sanity check the material and length */ 1126 if ((key == NULL) || (keylen == 0) || 1127 (text == NULL) || (textlen == 0) || (digest == NULL)) { 1128 /* can't do HMAC with empty key or text or digest */ 1129 return (-1); 1130 } 1131 len = sctp_get_hmac_digest_len(hmac_algo); 1132 if ((len == 0) || (digestlen != len)) 1133 return (-1); 1134 1135 /* compute the expected hash */ 1136 if (sctp_hmac(hmac_algo, key, keylen, text, textlen, temp) != len) 1137 return (-1); 1138 1139 if (memcmp(digest, temp, digestlen) != 0) 1140 return (-1); 1141 else 1142 return (0); 1143 } 1144 1145 1146 /* 1147 * computes the requested HMAC using a key struct (which may be modified if 1148 * the keylen exceeds the HMAC block len). 1149 */ 1150 uint32_t 1151 sctp_compute_hmac(uint16_t hmac_algo, sctp_key_t * key, uint8_t * text, 1152 uint32_t textlen, uint8_t * digest) 1153 { 1154 uint32_t digestlen; 1155 uint32_t blocklen; 1156 sctp_hash_context_t ctx; 1157 uint8_t temp[SCTP_AUTH_DIGEST_LEN_MAX]; 1158 1159 /* sanity check */ 1160 if ((key == NULL) || (text == NULL) || (textlen == 0) || 1161 (digest == NULL)) { 1162 /* can't do HMAC with empty key or text or digest store */ 1163 return (0); 1164 } 1165 /* validate the hmac algo and get the digest length */ 1166 digestlen = sctp_get_hmac_digest_len(hmac_algo); 1167 if (digestlen == 0) 1168 return (0); 1169 1170 /* hash the key if it is longer than the hash block size */ 1171 blocklen = sctp_get_hmac_block_len(hmac_algo); 1172 if (key->keylen > blocklen) { 1173 sctp_hmac_init(hmac_algo, &ctx); 1174 sctp_hmac_update(hmac_algo, &ctx, key->key, key->keylen); 1175 sctp_hmac_final(hmac_algo, &ctx, temp); 1176 /* save the hashed key as the new key */ 1177 key->keylen = digestlen; 1178 bcopy(temp, key->key, key->keylen); 1179 } 1180 return (sctp_hmac(hmac_algo, key->key, key->keylen, text, textlen, 1181 digest)); 1182 } 1183 1184 /* mbuf version */ 1185 uint32_t 1186 sctp_compute_hmac_m(uint16_t hmac_algo, sctp_key_t * key, struct mbuf *m, 1187 uint32_t m_offset, uint8_t * digest) 1188 { 1189 uint32_t digestlen; 1190 uint32_t blocklen; 1191 sctp_hash_context_t ctx; 1192 uint8_t temp[SCTP_AUTH_DIGEST_LEN_MAX]; 1193 1194 /* sanity check */ 1195 if ((key == NULL) || (m == NULL) || (digest == NULL)) { 1196 /* can't do HMAC with empty key or text or digest store */ 1197 return (0); 1198 } 1199 /* validate the hmac algo and get the digest length */ 1200 digestlen = sctp_get_hmac_digest_len(hmac_algo); 1201 if (digestlen == 0) 1202 return (0); 1203 1204 /* hash the key if it is longer than the hash block size */ 1205 blocklen = sctp_get_hmac_block_len(hmac_algo); 1206 if (key->keylen > blocklen) { 1207 sctp_hmac_init(hmac_algo, &ctx); 1208 sctp_hmac_update(hmac_algo, &ctx, key->key, key->keylen); 1209 sctp_hmac_final(hmac_algo, &ctx, temp); 1210 /* save the hashed key as the new key */ 1211 key->keylen = digestlen; 1212 bcopy(temp, key->key, key->keylen); 1213 } 1214 return (sctp_hmac_m(hmac_algo, key->key, key->keylen, m, m_offset, digest, 0)); 1215 } 1216 1217 int 1218 sctp_auth_is_supported_hmac(sctp_hmaclist_t * list, uint16_t id) 1219 { 1220 int i; 1221 1222 if ((list == NULL) || (id == SCTP_AUTH_HMAC_ID_RSVD)) 1223 return (0); 1224 1225 for (i = 0; i < list->num_algo; i++) 1226 if (list->hmac[i] == id) 1227 return (1); 1228 1229 /* not in the list */ 1230 return (0); 1231 } 1232 1233 1234 /* 1235 * clear any cached key(s) if they match the given key id on an association 1236 * the cached key(s) will be recomputed and re-cached at next use. ASSUMES 1237 * TCB_LOCK is already held 1238 */ 1239 void 1240 sctp_clear_cachedkeys(struct sctp_tcb *stcb, uint16_t keyid) 1241 { 1242 if (stcb == NULL) 1243 return; 1244 1245 if (keyid == stcb->asoc.authinfo.assoc_keyid) { 1246 sctp_free_key(stcb->asoc.authinfo.assoc_key); 1247 stcb->asoc.authinfo.assoc_key = NULL; 1248 } 1249 if (keyid == stcb->asoc.authinfo.recv_keyid) { 1250 sctp_free_key(stcb->asoc.authinfo.recv_key); 1251 stcb->asoc.authinfo.recv_key = NULL; 1252 } 1253 } 1254 1255 /* 1256 * clear any cached key(s) if they match the given key id for all assocs on 1257 * an association ASSUMES INP_WLOCK is already held 1258 */ 1259 void 1260 sctp_clear_cachedkeys_ep(struct sctp_inpcb *inp, uint16_t keyid) 1261 { 1262 struct sctp_tcb *stcb; 1263 1264 if (inp == NULL) 1265 return; 1266 1267 /* clear the cached keys on all assocs on this instance */ 1268 LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) { 1269 SCTP_TCB_LOCK(stcb); 1270 sctp_clear_cachedkeys(stcb, keyid); 1271 SCTP_TCB_UNLOCK(stcb); 1272 } 1273 } 1274 1275 /* 1276 * delete a shared key from an association ASSUMES TCB_LOCK is already held 1277 */ 1278 int 1279 sctp_delete_sharedkey(struct sctp_tcb *stcb, uint16_t keyid) 1280 { 1281 sctp_sharedkey_t *skey; 1282 1283 if (stcb == NULL) 1284 return (-1); 1285 1286 /* is the keyid the assoc active sending key */ 1287 if (keyid == stcb->asoc.authinfo.assoc_keyid) 1288 return (-1); 1289 1290 /* does the key exist? */ 1291 skey = sctp_find_sharedkey(&stcb->asoc.shared_keys, keyid); 1292 if (skey == NULL) 1293 return (-1); 1294 1295 /* remove it */ 1296 LIST_REMOVE(skey, next); 1297 sctp_free_sharedkey(skey); /* frees skey->key as well */ 1298 1299 /* clear any cached keys */ 1300 sctp_clear_cachedkeys(stcb, keyid); 1301 return (0); 1302 } 1303 1304 /* 1305 * deletes a shared key from the endpoint ASSUMES INP_WLOCK is already held 1306 */ 1307 int 1308 sctp_delete_sharedkey_ep(struct sctp_inpcb *inp, uint16_t keyid) 1309 { 1310 sctp_sharedkey_t *skey; 1311 struct sctp_tcb *stcb; 1312 1313 if (inp == NULL) 1314 return (-1); 1315 1316 /* is the keyid the active sending key on the endpoint or any assoc */ 1317 if (keyid == inp->sctp_ep.default_keyid) 1318 return (-1); 1319 LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) { 1320 SCTP_TCB_LOCK(stcb); 1321 if (keyid == stcb->asoc.authinfo.assoc_keyid) { 1322 SCTP_TCB_UNLOCK(stcb); 1323 return (-1); 1324 } 1325 SCTP_TCB_UNLOCK(stcb); 1326 } 1327 1328 /* does the key exist? */ 1329 skey = sctp_find_sharedkey(&inp->sctp_ep.shared_keys, keyid); 1330 if (skey == NULL) 1331 return (-1); 1332 1333 /* remove it */ 1334 LIST_REMOVE(skey, next); 1335 sctp_free_sharedkey(skey); /* frees skey->key as well */ 1336 1337 /* clear any cached keys */ 1338 sctp_clear_cachedkeys_ep(inp, keyid); 1339 return (0); 1340 } 1341 1342 /* 1343 * set the active key on an association ASSUME TCB_LOCK is already held 1344 */ 1345 int 1346 sctp_auth_setactivekey(struct sctp_tcb *stcb, uint16_t keyid) 1347 { 1348 sctp_sharedkey_t *skey = NULL; 1349 sctp_key_t *key = NULL; 1350 int using_ep_key = 0; 1351 1352 /* find the key on the assoc */ 1353 skey = sctp_find_sharedkey(&stcb->asoc.shared_keys, keyid); 1354 if (skey == NULL) { 1355 /* if not on the assoc, find the key on the endpoint */ 1356 atomic_add_int(&stcb->asoc.refcnt, 1); 1357 SCTP_TCB_UNLOCK(stcb); 1358 SCTP_INP_RLOCK(stcb->sctp_ep); 1359 SCTP_TCB_LOCK(stcb); 1360 atomic_add_int(&stcb->asoc.refcnt, -1); 1361 skey = sctp_find_sharedkey(&stcb->sctp_ep->sctp_ep.shared_keys, 1362 keyid); 1363 using_ep_key = 1; 1364 } 1365 if (skey == NULL) { 1366 /* that key doesn't exist */ 1367 if (using_ep_key) { 1368 SCTP_INP_RUNLOCK(stcb->sctp_ep); 1369 } 1370 return (-1); 1371 } 1372 /* get the shared key text */ 1373 key = skey->key; 1374 1375 /* free any existing cached key */ 1376 if (stcb->asoc.authinfo.assoc_key != NULL) 1377 sctp_free_key(stcb->asoc.authinfo.assoc_key); 1378 /* compute a new assoc key and cache it */ 1379 stcb->asoc.authinfo.assoc_key = 1380 sctp_compute_hashkey(stcb->asoc.authinfo.random, 1381 stcb->asoc.authinfo.peer_random, key); 1382 stcb->asoc.authinfo.assoc_keyid = keyid; 1383 #ifdef SCTP_DEBUG 1384 if (SCTP_AUTH_DEBUG) 1385 sctp_print_key(stcb->asoc.authinfo.assoc_key, "Assoc Key"); 1386 #endif 1387 1388 if (using_ep_key) { 1389 SCTP_INP_RUNLOCK(stcb->sctp_ep); 1390 } 1391 return (0); 1392 } 1393 1394 /* 1395 * set the active key on an endpoint ASSUMES INP_WLOCK is already held 1396 */ 1397 int 1398 sctp_auth_setactivekey_ep(struct sctp_inpcb *inp, uint16_t keyid) 1399 { 1400 sctp_sharedkey_t *skey; 1401 1402 /* find the key */ 1403 skey = sctp_find_sharedkey(&inp->sctp_ep.shared_keys, keyid); 1404 if (skey == NULL) { 1405 /* that key doesn't exist */ 1406 return (-1); 1407 } 1408 inp->sctp_ep.default_keyid = keyid; 1409 return (0); 1410 } 1411 1412 /* 1413 * get local authentication parameters from cookie (from INIT-ACK) 1414 */ 1415 void 1416 sctp_auth_get_cookie_params(struct sctp_tcb *stcb, struct mbuf *m, 1417 uint32_t offset, uint32_t length) 1418 { 1419 struct sctp_paramhdr *phdr, tmp_param; 1420 uint16_t plen, ptype; 1421 uint8_t random_store[SCTP_PARAM_BUFFER_SIZE]; 1422 struct sctp_auth_random *p_random = NULL; 1423 uint16_t random_len = 0; 1424 uint8_t hmacs_store[SCTP_PARAM_BUFFER_SIZE]; 1425 struct sctp_auth_hmac_algo *hmacs = NULL; 1426 uint16_t hmacs_len = 0; 1427 uint8_t chunks_store[SCTP_PARAM_BUFFER_SIZE]; 1428 struct sctp_auth_chunk_list *chunks = NULL; 1429 uint16_t num_chunks = 0; 1430 sctp_key_t *new_key; 1431 uint32_t keylen; 1432 1433 /* convert to upper bound */ 1434 length += offset; 1435 1436 phdr = (struct sctp_paramhdr *)sctp_m_getptr(m, offset, 1437 sizeof(struct sctp_paramhdr), (uint8_t *) & tmp_param); 1438 while (phdr != NULL) { 1439 ptype = ntohs(phdr->param_type); 1440 plen = ntohs(phdr->param_length); 1441 1442 if ((plen == 0) || (offset + plen > length)) 1443 break; 1444 1445 if (ptype == SCTP_RANDOM) { 1446 if (plen > sizeof(random_store)) 1447 break; 1448 phdr = sctp_get_next_param(m, offset, 1449 (struct sctp_paramhdr *)random_store, min(plen, sizeof(random_store))); 1450 if (phdr == NULL) 1451 return; 1452 /* save the random and length for the key */ 1453 p_random = (struct sctp_auth_random *)phdr; 1454 random_len = plen - sizeof(*p_random); 1455 } else if (ptype == SCTP_HMAC_LIST) { 1456 int num_hmacs; 1457 int i; 1458 1459 if (plen > sizeof(hmacs_store)) 1460 break; 1461 phdr = sctp_get_next_param(m, offset, 1462 (struct sctp_paramhdr *)hmacs_store, min(plen, sizeof(hmacs_store))); 1463 if (phdr == NULL) 1464 return; 1465 /* save the hmacs list and num for the key */ 1466 hmacs = (struct sctp_auth_hmac_algo *)phdr; 1467 hmacs_len = plen - sizeof(*hmacs); 1468 num_hmacs = hmacs_len / sizeof(hmacs->hmac_ids[0]); 1469 if (stcb->asoc.local_hmacs != NULL) 1470 sctp_free_hmaclist(stcb->asoc.local_hmacs); 1471 stcb->asoc.local_hmacs = sctp_alloc_hmaclist(num_hmacs); 1472 if (stcb->asoc.local_hmacs != NULL) { 1473 for (i = 0; i < num_hmacs; i++) { 1474 (void)sctp_auth_add_hmacid(stcb->asoc.local_hmacs, 1475 ntohs(hmacs->hmac_ids[i])); 1476 } 1477 } 1478 } else if (ptype == SCTP_CHUNK_LIST) { 1479 int i; 1480 1481 if (plen > sizeof(chunks_store)) 1482 break; 1483 phdr = sctp_get_next_param(m, offset, 1484 (struct sctp_paramhdr *)chunks_store, min(plen, sizeof(chunks_store))); 1485 if (phdr == NULL) 1486 return; 1487 chunks = (struct sctp_auth_chunk_list *)phdr; 1488 num_chunks = plen - sizeof(*chunks); 1489 /* save chunks list and num for the key */ 1490 if (stcb->asoc.local_auth_chunks != NULL) 1491 sctp_clear_chunklist(stcb->asoc.local_auth_chunks); 1492 else 1493 stcb->asoc.local_auth_chunks = sctp_alloc_chunklist(); 1494 for (i = 0; i < num_chunks; i++) { 1495 (void)sctp_auth_add_chunk(chunks->chunk_types[i], 1496 stcb->asoc.local_auth_chunks); 1497 } 1498 } 1499 /* get next parameter */ 1500 offset += SCTP_SIZE32(plen); 1501 if (offset + sizeof(struct sctp_paramhdr) > length) 1502 break; 1503 phdr = (struct sctp_paramhdr *)sctp_m_getptr(m, offset, sizeof(struct sctp_paramhdr), 1504 (uint8_t *) & tmp_param); 1505 } 1506 /* concatenate the full random key */ 1507 #ifdef SCTP_AUTH_DRAFT_04 1508 keylen = random_len; 1509 new_key = sctp_alloc_key(keylen); 1510 if (new_key != NULL) { 1511 /* copy in the RANDOM */ 1512 if (p_random != NULL) 1513 bcopy(p_random->random_data, new_key->key, random_len); 1514 } 1515 #else 1516 keylen = sizeof(*p_random) + random_len + sizeof(*chunks) + num_chunks + 1517 sizeof(*hmacs) + hmacs_len; 1518 new_key = sctp_alloc_key(keylen); 1519 if (new_key != NULL) { 1520 /* copy in the RANDOM */ 1521 if (p_random != NULL) { 1522 keylen = sizeof(*p_random) + random_len; 1523 bcopy(p_random, new_key->key, keylen); 1524 } 1525 /* append in the AUTH chunks */ 1526 if (chunks != NULL) { 1527 bcopy(chunks, new_key->key + keylen, 1528 sizeof(*chunks) + num_chunks); 1529 keylen += sizeof(*chunks) + num_chunks; 1530 } 1531 /* append in the HMACs */ 1532 if (hmacs != NULL) { 1533 bcopy(hmacs, new_key->key + keylen, 1534 sizeof(*hmacs) + hmacs_len); 1535 } 1536 } 1537 #endif 1538 if (stcb->asoc.authinfo.random != NULL) 1539 sctp_free_key(stcb->asoc.authinfo.random); 1540 stcb->asoc.authinfo.random = new_key; 1541 stcb->asoc.authinfo.random_len = random_len; 1542 #ifdef SCTP_AUTH_DRAFT_04 1543 /* don't include the chunks and hmacs for draft -04 */ 1544 stcb->asoc.authinfo.random->keylen = random_len; 1545 #endif 1546 sctp_clear_cachedkeys(stcb, stcb->asoc.authinfo.assoc_keyid); 1547 sctp_clear_cachedkeys(stcb, stcb->asoc.authinfo.recv_keyid); 1548 1549 /* negotiate what HMAC to use for the peer */ 1550 stcb->asoc.peer_hmac_id = sctp_negotiate_hmacid(stcb->asoc.peer_hmacs, 1551 stcb->asoc.local_hmacs); 1552 /* copy defaults from the endpoint */ 1553 /* FIX ME: put in cookie? */ 1554 stcb->asoc.authinfo.assoc_keyid = stcb->sctp_ep->sctp_ep.default_keyid; 1555 } 1556 1557 /* 1558 * compute and fill in the HMAC digest for a packet 1559 */ 1560 void 1561 sctp_fill_hmac_digest_m(struct mbuf *m, uint32_t auth_offset, 1562 struct sctp_auth_chunk *auth, struct sctp_tcb *stcb) 1563 { 1564 uint32_t digestlen; 1565 sctp_sharedkey_t *skey; 1566 sctp_key_t *key; 1567 1568 if ((stcb == NULL) || (auth == NULL)) 1569 return; 1570 1571 /* zero the digest + chunk padding */ 1572 digestlen = sctp_get_hmac_digest_len(stcb->asoc.peer_hmac_id); 1573 bzero(auth->hmac, SCTP_SIZE32(digestlen)); 1574 /* is an assoc key cached? */ 1575 if (stcb->asoc.authinfo.assoc_key == NULL) { 1576 skey = sctp_find_sharedkey(&stcb->asoc.shared_keys, 1577 stcb->asoc.authinfo.assoc_keyid); 1578 if (skey == NULL) { 1579 /* not in the assoc list, so check the endpoint list */ 1580 skey = sctp_find_sharedkey(&stcb->sctp_ep->sctp_ep.shared_keys, 1581 stcb->asoc.authinfo.assoc_keyid); 1582 } 1583 /* the only way skey is NULL is if null key id 0 is used */ 1584 if (skey != NULL) 1585 key = skey->key; 1586 else 1587 key = NULL; 1588 /* compute a new assoc key and cache it */ 1589 stcb->asoc.authinfo.assoc_key = 1590 sctp_compute_hashkey(stcb->asoc.authinfo.random, 1591 stcb->asoc.authinfo.peer_random, key); 1592 SCTPDBG(SCTP_DEBUG_AUTH1, "caching key id %u\n", 1593 stcb->asoc.authinfo.assoc_keyid); 1594 #ifdef SCTP_DEBUG 1595 if (SCTP_AUTH_DEBUG) 1596 sctp_print_key(stcb->asoc.authinfo.assoc_key, 1597 "Assoc Key"); 1598 #endif 1599 } 1600 /* set in the active key id */ 1601 auth->shared_key_id = htons(stcb->asoc.authinfo.assoc_keyid); 1602 1603 /* compute and fill in the digest */ 1604 (void)sctp_compute_hmac_m(stcb->asoc.peer_hmac_id, 1605 stcb->asoc.authinfo.assoc_key, 1606 m, auth_offset, auth->hmac); 1607 } 1608 1609 1610 static void 1611 sctp_bzero_m(struct mbuf *m, uint32_t m_offset, uint32_t size) 1612 { 1613 struct mbuf *m_tmp; 1614 uint8_t *data; 1615 1616 /* sanity check */ 1617 if (m == NULL) 1618 return; 1619 1620 /* find the correct starting mbuf and offset (get start position) */ 1621 m_tmp = m; 1622 while ((m_tmp != NULL) && (m_offset >= (uint32_t) SCTP_BUF_LEN(m_tmp))) { 1623 m_offset -= SCTP_BUF_LEN(m_tmp); 1624 m_tmp = SCTP_BUF_NEXT(m_tmp); 1625 } 1626 /* now use the rest of the mbuf chain */ 1627 while ((m_tmp != NULL) && (size > 0)) { 1628 data = mtod(m_tmp, uint8_t *) + m_offset; 1629 if (size > (uint32_t) SCTP_BUF_LEN(m_tmp)) { 1630 bzero(data, SCTP_BUF_LEN(m_tmp)); 1631 size -= SCTP_BUF_LEN(m_tmp); 1632 } else { 1633 bzero(data, size); 1634 size = 0; 1635 } 1636 /* clear the offset since it's only for the first mbuf */ 1637 m_offset = 0; 1638 m_tmp = SCTP_BUF_NEXT(m_tmp); 1639 } 1640 } 1641 1642 /* 1643 * process the incoming Authentication chunk return codes: -1 on any 1644 * authentication error 0 on authentication verification 1645 */ 1646 int 1647 sctp_handle_auth(struct sctp_tcb *stcb, struct sctp_auth_chunk *auth, 1648 struct mbuf *m, uint32_t offset) 1649 { 1650 uint16_t chunklen; 1651 uint16_t shared_key_id; 1652 uint16_t hmac_id; 1653 sctp_sharedkey_t *skey; 1654 uint32_t digestlen; 1655 uint8_t digest[SCTP_AUTH_DIGEST_LEN_MAX]; 1656 uint8_t computed_digest[SCTP_AUTH_DIGEST_LEN_MAX]; 1657 1658 /* auth is checked for NULL by caller */ 1659 chunklen = ntohs(auth->ch.chunk_length); 1660 if (chunklen < sizeof(*auth)) { 1661 SCTP_STAT_INCR(sctps_recvauthfailed); 1662 return (-1); 1663 } 1664 SCTP_STAT_INCR(sctps_recvauth); 1665 1666 /* get the auth params */ 1667 shared_key_id = ntohs(auth->shared_key_id); 1668 hmac_id = ntohs(auth->hmac_id); 1669 SCTPDBG(SCTP_DEBUG_AUTH1, 1670 "SCTP AUTH Chunk: shared key %u, HMAC id %u\n", 1671 shared_key_id, hmac_id); 1672 1673 /* is the indicated HMAC supported? */ 1674 if (!sctp_auth_is_supported_hmac(stcb->asoc.local_hmacs, hmac_id)) { 1675 struct mbuf *m_err; 1676 struct sctp_auth_invalid_hmac *err; 1677 1678 SCTP_STAT_INCR(sctps_recvivalhmacid); 1679 SCTPDBG(SCTP_DEBUG_AUTH1, 1680 "SCTP Auth: unsupported HMAC id %u\n", 1681 hmac_id); 1682 /* 1683 * report this in an Error Chunk: Unsupported HMAC 1684 * Identifier 1685 */ 1686 m_err = sctp_get_mbuf_for_msg(sizeof(*err), 0, M_DONTWAIT, 1687 1, MT_HEADER); 1688 if (m_err != NULL) { 1689 /* pre-reserve some space */ 1690 SCTP_BUF_RESV_UF(m_err, sizeof(struct sctp_chunkhdr)); 1691 /* fill in the error */ 1692 err = mtod(m_err, struct sctp_auth_invalid_hmac *); 1693 bzero(err, sizeof(*err)); 1694 err->ph.param_type = htons(SCTP_CAUSE_UNSUPPORTED_HMACID); 1695 err->ph.param_length = htons(sizeof(*err)); 1696 err->hmac_id = ntohs(hmac_id); 1697 SCTP_BUF_LEN(m_err) = sizeof(*err); 1698 /* queue it */ 1699 sctp_queue_op_err(stcb, m_err); 1700 } 1701 return (-1); 1702 } 1703 /* get the indicated shared key, if available */ 1704 if ((stcb->asoc.authinfo.recv_key == NULL) || 1705 (stcb->asoc.authinfo.recv_keyid != shared_key_id)) { 1706 /* find the shared key on the assoc first */ 1707 skey = sctp_find_sharedkey(&stcb->asoc.shared_keys, shared_key_id); 1708 if (skey == NULL) { 1709 /* if not on the assoc, find it on the endpoint */ 1710 skey = sctp_find_sharedkey(&stcb->sctp_ep->sctp_ep.shared_keys, 1711 shared_key_id); 1712 } 1713 /* if the shared key isn't found, discard the chunk */ 1714 if (skey == NULL) { 1715 SCTP_STAT_INCR(sctps_recvivalkeyid); 1716 SCTPDBG(SCTP_DEBUG_AUTH1, 1717 "SCTP Auth: unknown key id %u\n", 1718 shared_key_id); 1719 return (-1); 1720 } 1721 /* generate a notification if this is a new key id */ 1722 if (stcb->asoc.authinfo.recv_keyid != shared_key_id) 1723 /* 1724 * sctp_ulp_notify(SCTP_NOTIFY_AUTH_NEW_KEY, stcb, 1725 * shared_key_id, (void 1726 * *)stcb->asoc.authinfo.recv_keyid); 1727 */ 1728 sctp_notify_authentication(stcb, SCTP_AUTH_NEWKEY, 1729 shared_key_id, stcb->asoc.authinfo.recv_keyid); 1730 /* compute a new recv assoc key and cache it */ 1731 if (stcb->asoc.authinfo.recv_key != NULL) 1732 sctp_free_key(stcb->asoc.authinfo.recv_key); 1733 stcb->asoc.authinfo.recv_key = 1734 sctp_compute_hashkey(stcb->asoc.authinfo.random, 1735 stcb->asoc.authinfo.peer_random, skey->key); 1736 stcb->asoc.authinfo.recv_keyid = shared_key_id; 1737 #ifdef SCTP_DEBUG 1738 if (SCTP_AUTH_DEBUG) 1739 sctp_print_key(stcb->asoc.authinfo.recv_key, "Recv Key"); 1740 #endif 1741 } 1742 /* validate the digest length */ 1743 digestlen = sctp_get_hmac_digest_len(hmac_id); 1744 if (chunklen < (sizeof(*auth) + digestlen)) { 1745 /* invalid digest length */ 1746 SCTP_STAT_INCR(sctps_recvauthfailed); 1747 SCTPDBG(SCTP_DEBUG_AUTH1, 1748 "SCTP Auth: chunk too short for HMAC\n"); 1749 return (-1); 1750 } 1751 /* save a copy of the digest, zero the pseudo header, and validate */ 1752 bcopy(auth->hmac, digest, digestlen); 1753 sctp_bzero_m(m, offset + sizeof(*auth), SCTP_SIZE32(digestlen)); 1754 (void)sctp_compute_hmac_m(hmac_id, stcb->asoc.authinfo.recv_key, 1755 m, offset, computed_digest); 1756 1757 /* compare the computed digest with the one in the AUTH chunk */ 1758 if (memcmp(digest, computed_digest, digestlen) != 0) { 1759 SCTP_STAT_INCR(sctps_recvauthfailed); 1760 SCTPDBG(SCTP_DEBUG_AUTH1, 1761 "SCTP Auth: HMAC digest check failed\n"); 1762 return (-1); 1763 } 1764 return (0); 1765 } 1766 1767 /* 1768 * Generate NOTIFICATION 1769 */ 1770 void 1771 sctp_notify_authentication(struct sctp_tcb *stcb, uint32_t indication, 1772 uint16_t keyid, uint16_t alt_keyid) 1773 { 1774 struct mbuf *m_notify; 1775 struct sctp_authkey_event *auth; 1776 struct sctp_queued_to_read *control; 1777 1778 if (sctp_is_feature_off(stcb->sctp_ep, SCTP_PCB_FLAGS_AUTHEVNT)) 1779 /* event not enabled */ 1780 return; 1781 1782 m_notify = sctp_get_mbuf_for_msg(sizeof(struct sctp_authkey_event), 1783 0, M_DONTWAIT, 1, MT_HEADER); 1784 if (m_notify == NULL) 1785 /* no space left */ 1786 return; 1787 1788 SCTP_BUF_LEN(m_notify) = 0; 1789 auth = mtod(m_notify, struct sctp_authkey_event *); 1790 auth->auth_type = SCTP_AUTHENTICATION_EVENT; 1791 auth->auth_flags = 0; 1792 auth->auth_length = sizeof(*auth); 1793 auth->auth_keynumber = keyid; 1794 auth->auth_altkeynumber = alt_keyid; 1795 auth->auth_indication = indication; 1796 auth->auth_assoc_id = sctp_get_associd(stcb); 1797 1798 SCTP_BUF_LEN(m_notify) = sizeof(*auth); 1799 SCTP_BUF_NEXT(m_notify) = NULL; 1800 1801 /* append to socket */ 1802 control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination, 1803 0, 0, 0, 0, 0, 0, m_notify); 1804 if (control == NULL) { 1805 /* no memory */ 1806 sctp_m_freem(m_notify); 1807 return; 1808 } 1809 control->spec_flags = M_NOTIFICATION; 1810 control->length = SCTP_BUF_LEN(m_notify); 1811 /* not that we need this */ 1812 control->tail_mbuf = m_notify; 1813 sctp_add_to_readq(stcb->sctp_ep, stcb, control, 1814 &stcb->sctp_socket->so_rcv, 1); 1815 } 1816 1817 1818 /* 1819 * validates the AUTHentication related parameters in an INIT/INIT-ACK 1820 * Note: currently only used for INIT as INIT-ACK is handled inline 1821 * with sctp_load_addresses_from_init() 1822 */ 1823 int 1824 sctp_validate_init_auth_params(struct mbuf *m, int offset, int limit) 1825 { 1826 struct sctp_paramhdr *phdr, parm_buf; 1827 uint16_t ptype, plen; 1828 int peer_supports_asconf = 0; 1829 int peer_supports_auth = 0; 1830 int got_random = 0, got_hmacs = 0, got_chklist = 0; 1831 1832 /* go through each of the params. */ 1833 phdr = sctp_get_next_param(m, offset, &parm_buf, sizeof(parm_buf)); 1834 while (phdr) { 1835 ptype = ntohs(phdr->param_type); 1836 plen = ntohs(phdr->param_length); 1837 1838 if (offset + plen > limit) { 1839 break; 1840 } 1841 if (plen == 0) { 1842 break; 1843 } 1844 if (ptype == SCTP_SUPPORTED_CHUNK_EXT) { 1845 /* A supported extension chunk */ 1846 struct sctp_supported_chunk_types_param *pr_supported; 1847 uint8_t local_store[SCTP_PARAM_BUFFER_SIZE]; 1848 int num_ent, i; 1849 1850 phdr = sctp_get_next_param(m, offset, 1851 (struct sctp_paramhdr *)&local_store, min(plen, sizeof(local_store))); 1852 if (phdr == NULL) { 1853 return (-1); 1854 } 1855 pr_supported = (struct sctp_supported_chunk_types_param *)phdr; 1856 num_ent = plen - sizeof(struct sctp_paramhdr); 1857 for (i = 0; i < num_ent; i++) { 1858 switch (pr_supported->chunk_types[i]) { 1859 case SCTP_ASCONF: 1860 case SCTP_ASCONF_ACK: 1861 peer_supports_asconf = 1; 1862 break; 1863 case SCTP_AUTHENTICATION: 1864 peer_supports_auth = 1; 1865 break; 1866 default: 1867 /* one we don't care about */ 1868 break; 1869 } 1870 } 1871 } else if (ptype == SCTP_RANDOM) { 1872 got_random = 1; 1873 /* enforce the random length */ 1874 if (plen != (sizeof(struct sctp_auth_random) + 1875 SCTP_AUTH_RANDOM_SIZE_REQUIRED)) { 1876 SCTPDBG(SCTP_DEBUG_AUTH1, 1877 "SCTP: invalid RANDOM len\n"); 1878 return (-1); 1879 } 1880 } else if (ptype == SCTP_HMAC_LIST) { 1881 uint8_t store[SCTP_PARAM_BUFFER_SIZE]; 1882 struct sctp_auth_hmac_algo *hmacs; 1883 int num_hmacs; 1884 1885 if (plen > sizeof(store)) 1886 break; 1887 phdr = sctp_get_next_param(m, offset, 1888 (struct sctp_paramhdr *)store, min(plen, sizeof(store))); 1889 if (phdr == NULL) 1890 return (-1); 1891 hmacs = (struct sctp_auth_hmac_algo *)phdr; 1892 num_hmacs = (plen - sizeof(*hmacs)) / 1893 sizeof(hmacs->hmac_ids[0]); 1894 /* validate the hmac list */ 1895 if (sctp_verify_hmac_param(hmacs, num_hmacs)) { 1896 SCTPDBG(SCTP_DEBUG_AUTH1, 1897 "SCTP: invalid HMAC param\n"); 1898 return (-1); 1899 } 1900 got_hmacs = 1; 1901 } else if (ptype == SCTP_CHUNK_LIST) { 1902 /* did the peer send a non-empty chunk list? */ 1903 if (plen > 0) 1904 got_chklist = 1; 1905 } 1906 offset += SCTP_SIZE32(plen); 1907 if (offset >= limit) { 1908 break; 1909 } 1910 phdr = sctp_get_next_param(m, offset, &parm_buf, 1911 sizeof(parm_buf)); 1912 } 1913 /* validate authentication required parameters */ 1914 if (got_random && got_hmacs) { 1915 peer_supports_auth = 1; 1916 } else { 1917 peer_supports_auth = 0; 1918 } 1919 if (!peer_supports_auth && got_chklist) { 1920 SCTPDBG(SCTP_DEBUG_AUTH1, 1921 "SCTP: peer sent chunk list w/o AUTH\n"); 1922 return (-1); 1923 } 1924 if (!sctp_asconf_auth_nochk && peer_supports_asconf && 1925 !peer_supports_auth) { 1926 SCTPDBG(SCTP_DEBUG_AUTH1, 1927 "SCTP: peer supports ASCONF but not AUTH\n"); 1928 return (-1); 1929 } 1930 return (0); 1931 } 1932 1933 void 1934 sctp_initialize_auth_params(struct sctp_inpcb *inp, struct sctp_tcb *stcb) 1935 { 1936 uint16_t chunks_len = 0; 1937 uint16_t hmacs_len = 0; 1938 uint16_t random_len = SCTP_AUTH_RANDOM_SIZE_DEFAULT; 1939 sctp_key_t *new_key; 1940 uint16_t keylen; 1941 1942 /* initialize hmac list from endpoint */ 1943 stcb->asoc.local_hmacs = sctp_copy_hmaclist(inp->sctp_ep.local_hmacs); 1944 if (stcb->asoc.local_hmacs != NULL) { 1945 hmacs_len = stcb->asoc.local_hmacs->num_algo * 1946 sizeof(stcb->asoc.local_hmacs->hmac[0]); 1947 } 1948 /* initialize auth chunks list from endpoint */ 1949 stcb->asoc.local_auth_chunks = 1950 sctp_copy_chunklist(inp->sctp_ep.local_auth_chunks); 1951 if (stcb->asoc.local_auth_chunks != NULL) { 1952 int i; 1953 1954 for (i = 0; i < 256; i++) { 1955 if (stcb->asoc.local_auth_chunks->chunks[i]) 1956 chunks_len++; 1957 } 1958 } 1959 /* copy defaults from the endpoint */ 1960 stcb->asoc.authinfo.assoc_keyid = inp->sctp_ep.default_keyid; 1961 1962 /* now set the concatenated key (random + chunks + hmacs) */ 1963 #ifdef SCTP_AUTH_DRAFT_04 1964 /* don't include the chunks and hmacs for draft -04 */ 1965 keylen = random_len; 1966 new_key = sctp_generate_random_key(keylen); 1967 #else 1968 /* key includes parameter headers */ 1969 keylen = (3 * sizeof(struct sctp_paramhdr)) + random_len + chunks_len + 1970 hmacs_len; 1971 new_key = sctp_alloc_key(keylen); 1972 if (new_key != NULL) { 1973 struct sctp_paramhdr *ph; 1974 int plen; 1975 1976 /* generate and copy in the RANDOM */ 1977 ph = (struct sctp_paramhdr *)new_key->key; 1978 ph->param_type = htons(SCTP_RANDOM); 1979 plen = sizeof(*ph) + random_len; 1980 ph->param_length = htons(plen); 1981 SCTP_READ_RANDOM(new_key->key + sizeof(*ph), random_len); 1982 keylen = plen; 1983 1984 /* append in the AUTH chunks */ 1985 /* NOTE: currently we always have chunks to list */ 1986 ph = (struct sctp_paramhdr *)(new_key->key + keylen); 1987 ph->param_type = htons(SCTP_CHUNK_LIST); 1988 plen = sizeof(*ph) + chunks_len; 1989 ph->param_length = htons(plen); 1990 keylen += sizeof(*ph); 1991 if (stcb->asoc.local_auth_chunks) { 1992 int i; 1993 1994 for (i = 0; i < 256; i++) { 1995 if (stcb->asoc.local_auth_chunks->chunks[i]) 1996 new_key->key[keylen++] = i; 1997 } 1998 } 1999 /* append in the HMACs */ 2000 ph = (struct sctp_paramhdr *)(new_key->key + keylen); 2001 ph->param_type = htons(SCTP_HMAC_LIST); 2002 plen = sizeof(*ph) + hmacs_len; 2003 ph->param_length = htons(plen); 2004 keylen += sizeof(*ph); 2005 (void)sctp_serialize_hmaclist(stcb->asoc.local_hmacs, 2006 new_key->key + keylen); 2007 } 2008 #endif 2009 if (stcb->asoc.authinfo.random != NULL) 2010 sctp_free_key(stcb->asoc.authinfo.random); 2011 stcb->asoc.authinfo.random = new_key; 2012 stcb->asoc.authinfo.random_len = random_len; 2013 } 2014 2015 2016 #ifdef SCTP_HMAC_TEST 2017 /* 2018 * HMAC and key concatenation tests 2019 */ 2020 static void 2021 sctp_print_digest(uint8_t * digest, uint32_t digestlen, const char *str) 2022 { 2023 uint32_t i; 2024 2025 printf("\n%s: 0x", str); 2026 if (digest == NULL) 2027 return; 2028 2029 for (i = 0; i < digestlen; i++) 2030 printf("%02x", digest[i]); 2031 } 2032 2033 static int 2034 sctp_test_hmac(const char *str, uint16_t hmac_id, uint8_t * key, 2035 uint32_t keylen, uint8_t * text, uint32_t textlen, 2036 uint8_t * digest, uint32_t digestlen) 2037 { 2038 uint8_t computed_digest[SCTP_AUTH_DIGEST_LEN_MAX]; 2039 2040 printf("\n%s:", str); 2041 sctp_hmac(hmac_id, key, keylen, text, textlen, computed_digest); 2042 sctp_print_digest(digest, digestlen, "Expected digest"); 2043 sctp_print_digest(computed_digest, digestlen, "Computed digest"); 2044 if (memcmp(digest, computed_digest, digestlen) != 0) { 2045 printf("\nFAILED"); 2046 return (-1); 2047 } else { 2048 printf("\nPASSED"); 2049 return (0); 2050 } 2051 } 2052 2053 2054 /* 2055 * RFC 2202: HMAC-SHA1 test cases 2056 */ 2057 void 2058 sctp_test_hmac_sha1(void) 2059 { 2060 uint8_t *digest; 2061 uint8_t key[128]; 2062 uint32_t keylen; 2063 uint8_t text[128]; 2064 uint32_t textlen; 2065 uint32_t digestlen = 20; 2066 int failed = 0; 2067 2068 /* 2069 * test_case = 1 key = 2070 * 0x0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b key_len = 20 2071 * data = "Hi There" data_len = 8 digest = 2072 * 0xb617318655057264e28bc0b6fb378c8ef146be00 2073 */ 2074 keylen = 20; 2075 memset(key, 0x0b, keylen); 2076 textlen = 8; 2077 strcpy(text, "Hi There"); 2078 digest = "\xb6\x17\x31\x86\x55\x05\x72\x64\xe2\x8b\xc0\xb6\xfb\x37\x8c\x8e\xf1\x46\xbe\x00"; 2079 if (sctp_test_hmac("SHA1 test case 1", SCTP_AUTH_HMAC_ID_SHA1, key, keylen, 2080 text, textlen, digest, digestlen) < 0) 2081 failed++; 2082 2083 /* 2084 * test_case = 2 key = "Jefe" key_len = 4 data = 2085 * "what do ya want for nothing?" data_len = 28 digest = 2086 * 0xeffcdf6ae5eb2fa2d27416d5f184df9c259a7c79 2087 */ 2088 keylen = 4; 2089 strcpy(key, "Jefe"); 2090 textlen = 28; 2091 strcpy(text, "what do ya want for nothing?"); 2092 digest = "\xef\xfc\xdf\x6a\xe5\xeb\x2f\xa2\xd2\x74\x16\xd5\xf1\x84\xdf\x9c\x25\x9a\x7c\x79"; 2093 if (sctp_test_hmac("SHA1 test case 2", SCTP_AUTH_HMAC_ID_SHA1, key, keylen, 2094 text, textlen, digest, digestlen) < 0) 2095 failed++; 2096 2097 /* 2098 * test_case = 3 key = 2099 * 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa key_len = 20 2100 * data = 0xdd repeated 50 times data_len = 50 digest 2101 * = 0x125d7342b9ac11cd91a39af48aa17b4f63f175d3 2102 */ 2103 keylen = 20; 2104 memset(key, 0xaa, keylen); 2105 textlen = 50; 2106 memset(text, 0xdd, textlen); 2107 digest = "\x12\x5d\x73\x42\xb9\xac\x11\xcd\x91\xa3\x9a\xf4\x8a\xa1\x7b\x4f\x63\xf1\x75\xd3"; 2108 if (sctp_test_hmac("SHA1 test case 3", SCTP_AUTH_HMAC_ID_SHA1, key, keylen, 2109 text, textlen, digest, digestlen) < 0) 2110 failed++; 2111 2112 /* 2113 * test_case = 4 key = 2114 * 0x0102030405060708090a0b0c0d0e0f10111213141516171819 key_len = 25 2115 * data = 0xcd repeated 50 times data_len = 50 digest 2116 * = 0x4c9007f4026250c6bc8414f9bf50c86c2d7235da 2117 */ 2118 keylen = 25; 2119 memcpy(key, "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19", keylen); 2120 textlen = 50; 2121 memset(text, 0xcd, textlen); 2122 digest = "\x4c\x90\x07\xf4\x02\x62\x50\xc6\xbc\x84\x14\xf9\xbf\x50\xc8\x6c\x2d\x72\x35\xda"; 2123 if (sctp_test_hmac("SHA1 test case 4", SCTP_AUTH_HMAC_ID_SHA1, key, keylen, 2124 text, textlen, digest, digestlen) < 0) 2125 failed++; 2126 2127 /* 2128 * test_case = 5 key = 2129 * 0x0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c key_len = 20 2130 * data = "Test With Truncation" data_len = 20 digest 2131 * = 0x4c1a03424b55e07fe7f27be1d58bb9324a9a5a04 digest-96 = 2132 * 0x4c1a03424b55e07fe7f27be1 2133 */ 2134 keylen = 20; 2135 memset(key, 0x0c, keylen); 2136 textlen = 20; 2137 strcpy(text, "Test With Truncation"); 2138 digest = "\x4c\x1a\x03\x42\x4b\x55\xe0\x7f\xe7\xf2\x7b\xe1\xd5\x8b\xb9\x32\x4a\x9a\x5a\x04"; 2139 if (sctp_test_hmac("SHA1 test case 5", SCTP_AUTH_HMAC_ID_SHA1, key, keylen, 2140 text, textlen, digest, digestlen) < 0) 2141 failed++; 2142 2143 /* 2144 * test_case = 6 key = 0xaa repeated 80 times key_len 2145 * = 80 data = "Test Using Larger Than Block-Size Key - 2146 * Hash Key First" data_len = 54 digest = 2147 * 0xaa4ae5e15272d00e95705637ce8a3b55ed402112 2148 */ 2149 keylen = 80; 2150 memset(key, 0xaa, keylen); 2151 textlen = 54; 2152 strcpy(text, "Test Using Larger Than Block-Size Key - Hash Key First"); 2153 digest = "\xaa\x4a\xe5\xe1\x52\x72\xd0\x0e\x95\x70\x56\x37\xce\x8a\x3b\x55\xed\x40\x21\x12"; 2154 if (sctp_test_hmac("SHA1 test case 6", SCTP_AUTH_HMAC_ID_SHA1, key, keylen, 2155 text, textlen, digest, digestlen) < 0) 2156 failed++; 2157 2158 /* 2159 * test_case = 7 key = 0xaa repeated 80 times key_len 2160 * = 80 data = "Test Using Larger Than Block-Size Key and 2161 * Larger Than One Block-Size Data" data_len = 73 digest = 2162 * 0xe8e99d0f45237d786d6bbaa7965c7808bbff1a91 2163 */ 2164 keylen = 80; 2165 memset(key, 0xaa, keylen); 2166 textlen = 73; 2167 strcpy(text, "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data"); 2168 digest = "\xe8\xe9\x9d\x0f\x45\x23\x7d\x78\x6d\x6b\xba\xa7\x96\x5c\x78\x08\xbb\xff\x1a\x91"; 2169 if (sctp_test_hmac("SHA1 test case 7", SCTP_AUTH_HMAC_ID_SHA1, key, keylen, 2170 text, textlen, digest, digestlen) < 0) 2171 failed++; 2172 2173 /* done with all tests */ 2174 if (failed) 2175 printf("\nSHA1 test results: %d cases failed", failed); 2176 else 2177 printf("\nSHA1 test results: all test cases passed"); 2178 } 2179 2180 /* 2181 * RFC 2202: HMAC-MD5 test cases 2182 */ 2183 void 2184 sctp_test_hmac_md5(void) 2185 { 2186 uint8_t *digest; 2187 uint8_t key[128]; 2188 uint32_t keylen; 2189 uint8_t text[128]; 2190 uint32_t textlen; 2191 uint32_t digestlen = 16; 2192 int failed = 0; 2193 2194 /* 2195 * test_case = 1 key = 0x0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b 2196 * key_len = 16 data = "Hi There" data_len = 8 digest = 2197 * 0x9294727a3638bb1c13f48ef8158bfc9d 2198 */ 2199 keylen = 16; 2200 memset(key, 0x0b, keylen); 2201 textlen = 8; 2202 strcpy(text, "Hi There"); 2203 digest = "\x92\x94\x72\x7a\x36\x38\xbb\x1c\x13\xf4\x8e\xf8\x15\x8b\xfc\x9d"; 2204 if (sctp_test_hmac("MD5 test case 1", SCTP_AUTH_HMAC_ID_MD5, key, keylen, 2205 text, textlen, digest, digestlen) < 0) 2206 failed++; 2207 2208 /* 2209 * test_case = 2 key = "Jefe" key_len = 4 data = 2210 * "what do ya want for nothing?" data_len = 28 digest = 2211 * 0x750c783e6ab0b503eaa86e310a5db738 2212 */ 2213 keylen = 4; 2214 strcpy(key, "Jefe"); 2215 textlen = 28; 2216 strcpy(text, "what do ya want for nothing?"); 2217 digest = "\x75\x0c\x78\x3e\x6a\xb0\xb5\x03\xea\xa8\x6e\x31\x0a\x5d\xb7\x38"; 2218 if (sctp_test_hmac("MD5 test case 2", SCTP_AUTH_HMAC_ID_MD5, key, keylen, 2219 text, textlen, digest, digestlen) < 0) 2220 failed++; 2221 2222 /* 2223 * test_case = 3 key = 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 2224 * key_len = 16 data = 0xdd repeated 50 times data_len = 50 2225 * digest = 0x56be34521d144c88dbb8c733f0e8b3f6 2226 */ 2227 keylen = 16; 2228 memset(key, 0xaa, keylen); 2229 textlen = 50; 2230 memset(text, 0xdd, textlen); 2231 digest = "\x56\xbe\x34\x52\x1d\x14\x4c\x88\xdb\xb8\xc7\x33\xf0\xe8\xb3\xf6"; 2232 if (sctp_test_hmac("MD5 test case 3", SCTP_AUTH_HMAC_ID_MD5, key, keylen, 2233 text, textlen, digest, digestlen) < 0) 2234 failed++; 2235 2236 /* 2237 * test_case = 4 key = 2238 * 0x0102030405060708090a0b0c0d0e0f10111213141516171819 key_len = 25 2239 * data = 0xcd repeated 50 times data_len = 50 digest 2240 * = 0x697eaf0aca3a3aea3a75164746ffaa79 2241 */ 2242 keylen = 25; 2243 memcpy(key, "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19", keylen); 2244 textlen = 50; 2245 memset(text, 0xcd, textlen); 2246 digest = "\x69\x7e\xaf\x0a\xca\x3a\x3a\xea\x3a\x75\x16\x47\x46\xff\xaa\x79"; 2247 if (sctp_test_hmac("MD5 test case 4", SCTP_AUTH_HMAC_ID_MD5, key, keylen, 2248 text, textlen, digest, digestlen) < 0) 2249 failed++; 2250 2251 /* 2252 * test_case = 5 key = 0x0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c 2253 * key_len = 16 data = "Test With Truncation" data_len = 20 2254 * digest = 0x56461ef2342edc00f9bab995690efd4c digest-96 2255 * 0x56461ef2342edc00f9bab995 2256 */ 2257 keylen = 16; 2258 memset(key, 0x0c, keylen); 2259 textlen = 20; 2260 strcpy(text, "Test With Truncation"); 2261 digest = "\x56\x46\x1e\xf2\x34\x2e\xdc\x00\xf9\xba\xb9\x95\x69\x0e\xfd\x4c"; 2262 if (sctp_test_hmac("MD5 test case 5", SCTP_AUTH_HMAC_ID_MD5, key, keylen, 2263 text, textlen, digest, digestlen) < 0) 2264 failed++; 2265 2266 /* 2267 * test_case = 6 key = 0xaa repeated 80 times key_len 2268 * = 80 data = "Test Using Larger Than Block-Size Key - 2269 * Hash Key First" data_len = 54 digest = 2270 * 0x6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd 2271 */ 2272 keylen = 80; 2273 memset(key, 0xaa, keylen); 2274 textlen = 54; 2275 strcpy(text, "Test Using Larger Than Block-Size Key - Hash Key First"); 2276 digest = "\x6b\x1a\xb7\xfe\x4b\xd7\xbf\x8f\x0b\x62\xe6\xce\x61\xb9\xd0\xcd"; 2277 if (sctp_test_hmac("MD5 test case 6", SCTP_AUTH_HMAC_ID_MD5, key, keylen, 2278 text, textlen, digest, digestlen) < 0) 2279 failed++; 2280 2281 /* 2282 * test_case = 7 key = 0xaa repeated 80 times key_len 2283 * = 80 data = "Test Using Larger Than Block-Size Key and 2284 * Larger Than One Block-Size Data" data_len = 73 digest = 2285 * 0x6f630fad67cda0ee1fb1f562db3aa53e 2286 */ 2287 keylen = 80; 2288 memset(key, 0xaa, keylen); 2289 textlen = 73; 2290 strcpy(text, "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data"); 2291 digest = "\x6f\x63\x0f\xad\x67\xcd\xa0\xee\x1f\xb1\xf5\x62\xdb\x3a\xa5\x3e"; 2292 if (sctp_test_hmac("MD5 test case 7", SCTP_AUTH_HMAC_ID_MD5, key, keylen, 2293 text, textlen, digest, digestlen) < 0) 2294 failed++; 2295 2296 /* done with all tests */ 2297 if (failed) 2298 printf("\nMD5 test results: %d cases failed", failed); 2299 else 2300 printf("\nMD5 test results: all test cases passed"); 2301 } 2302 2303 /* 2304 * test assoc key concatenation 2305 */ 2306 static int 2307 sctp_test_key_concatenation(sctp_key_t * key1, sctp_key_t * key2, 2308 sctp_key_t * expected_key) 2309 { 2310 sctp_key_t *key; 2311 int ret_val; 2312 2313 sctp_show_key(key1, "\nkey1"); 2314 sctp_show_key(key2, "\nkey2"); 2315 key = sctp_compute_hashkey(key1, key2, NULL); 2316 sctp_show_key(expected_key, "\nExpected"); 2317 sctp_show_key(key, "\nComputed"); 2318 if (memcmp(key, expected_key, expected_key->keylen) != 0) { 2319 printf("\nFAILED"); 2320 ret_val = -1; 2321 } else { 2322 printf("\nPASSED"); 2323 ret_val = 0; 2324 } 2325 sctp_free_key(key1); 2326 sctp_free_key(key2); 2327 sctp_free_key(expected_key); 2328 sctp_free_key(key); 2329 return (ret_val); 2330 } 2331 2332 2333 void 2334 sctp_test_authkey(void) 2335 { 2336 sctp_key_t *key1, *key2, *expected_key; 2337 int failed = 0; 2338 2339 /* test case 1 */ 2340 key1 = sctp_set_key("\x01\x01\x01\x01", 4); 2341 key2 = sctp_set_key("\x01\x02\x03\x04", 4); 2342 expected_key = sctp_set_key("\x01\x01\x01\x01\x01\x02\x03\x04", 8); 2343 if (sctp_test_key_concatenation(key1, key2, expected_key) < 0) 2344 failed++; 2345 2346 /* test case 2 */ 2347 key1 = sctp_set_key("\x00\x00\x00\x01", 4); 2348 key2 = sctp_set_key("\x02", 1); 2349 expected_key = sctp_set_key("\x00\x00\x00\x01\x02", 5); 2350 if (sctp_test_key_concatenation(key1, key2, expected_key) < 0) 2351 failed++; 2352 2353 /* test case 3 */ 2354 key1 = sctp_set_key("\x01", 1); 2355 key2 = sctp_set_key("\x00\x00\x00\x02", 4); 2356 expected_key = sctp_set_key("\x01\x00\x00\x00\x02", 5); 2357 if (sctp_test_key_concatenation(key1, key2, expected_key) < 0) 2358 failed++; 2359 2360 /* test case 4 */ 2361 key1 = sctp_set_key("\x00\x00\x00\x01", 4); 2362 key2 = sctp_set_key("\x01", 1); 2363 expected_key = sctp_set_key("\x01\x00\x00\x00\x01", 5); 2364 if (sctp_test_key_concatenation(key1, key2, expected_key) < 0) 2365 failed++; 2366 2367 /* test case 5 */ 2368 key1 = sctp_set_key("\x01", 1); 2369 key2 = sctp_set_key("\x00\x00\x00\x01", 4); 2370 expected_key = sctp_set_key("\x01\x00\x00\x00\x01", 5); 2371 if (sctp_test_key_concatenation(key1, key2, expected_key) < 0) 2372 failed++; 2373 2374 /* test case 6 */ 2375 key1 = sctp_set_key("\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06\x07", 11); 2376 key2 = sctp_set_key("\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06\x08", 11); 2377 expected_key = sctp_set_key("\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06\x07\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06\x08", 22); 2378 if (sctp_test_key_concatenation(key1, key2, expected_key) < 0) 2379 failed++; 2380 2381 /* test case 7 */ 2382 key1 = sctp_set_key("\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06\x08", 11); 2383 key2 = sctp_set_key("\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06\x07", 11); 2384 expected_key = sctp_set_key("\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06\x07\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06\x08", 22); 2385 if (sctp_test_key_concatenation(key1, key2, expected_key) < 0) 2386 failed++; 2387 2388 /* done with all tests */ 2389 if (failed) 2390 printf("\nKey concatenation test results: %d cases failed", failed); 2391 else 2392 printf("\nKey concatenation test results: all test cases passed"); 2393 } 2394 2395 2396 #if defined(STANDALONE_HMAC_TEST) 2397 int 2398 main(void) 2399 { 2400 sctp_test_hmac_sha1(); 2401 sctp_test_hmac_md5(); 2402 sctp_test_authkey(); 2403 } 2404 2405 #endif /* STANDALONE_HMAC_TEST */ 2406 2407 #endif /* SCTP_HMAC_TEST */ 2408