1/*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 2001-2008, by Cisco Systems, Inc. All rights reserved. 5 * Copyright (c) 2008-2012, by Randall Stewart. All rights reserved. 6 * Copyright (c) 2008-2012, by Michael Tuexen. All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions are met: 10 * 11 * a) Redistributions of source code must retain the above copyright notice, 12 * this list of conditions and the following disclaimer. 13 * 14 * b) Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in 16 * the documentation and/or other materials provided with the distribution. 17 * 18 * c) Neither the name of Cisco Systems, Inc. nor the names of its 19 * contributors may be used to endorse or promote products derived 20 * from this software without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 23 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 24 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 26 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 32 * THE POSSIBILITY OF SUCH DAMAGE. 33 */ 34 35#include <netinet/sctp_os.h> 36#include <netinet/sctp.h> 37#include <netinet/sctp_header.h> 38#include <netinet/sctp_pcb.h> 39#include <netinet/sctp_var.h> 40#include <netinet/sctp_sysctl.h> 41#include <netinet/sctputil.h> 42#include <netinet/sctp_indata.h> 43#include <netinet/sctp_output.h> 44#include <netinet/sctp_auth.h> 45 46#ifdef SCTP_DEBUG 47#define SCTP_AUTH_DEBUG (SCTP_BASE_SYSCTL(sctp_debug_on) & SCTP_DEBUG_AUTH1) 48#define SCTP_AUTH_DEBUG2 (SCTP_BASE_SYSCTL(sctp_debug_on) & SCTP_DEBUG_AUTH2) 49#endif /* SCTP_DEBUG */ 50 51void 52sctp_clear_chunklist(sctp_auth_chklist_t *chklist) 53{ 54 memset(chklist, 0, sizeof(*chklist)); 55 /* chklist->num_chunks = 0; */ 56} 57 58sctp_auth_chklist_t * 59sctp_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 73void 74sctp_free_chunklist(sctp_auth_chklist_t *list) 75{ 76 if (list != NULL) 77 SCTP_FREE(list, SCTP_M_AUTH_CL); 78} 79 80sctp_auth_chklist_t * 81sctp_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 memcpy(new_list, list, sizeof(*new_list)); 94 95 return (new_list); 96} 97 98/* 99 * add a chunk to the required chunks list 100 */ 101int 102sctp_auth_add_chunk(uint8_t chunk, sctp_auth_chklist_t *list) 103{ 104 if (list == NULL) 105 return (-1); 106 107 /* is chunk restricted? */ 108 if ((chunk == SCTP_INITIATION) || 109 (chunk == SCTP_INITIATION_ACK) || 110 (chunk == SCTP_SHUTDOWN_COMPLETE) || 111 (chunk == SCTP_AUTHENTICATION)) { 112 return (-1); 113 } 114 if (list->chunks[chunk] == 0) { 115 list->chunks[chunk] = 1; 116 list->num_chunks++; 117 SCTPDBG(SCTP_DEBUG_AUTH1, 118 "SCTP: added chunk %u (0x%02x) to Auth list\n", 119 chunk, chunk); 120 } 121 return (0); 122} 123 124/* 125 * delete a chunk from the required chunks list 126 */ 127int 128sctp_auth_delete_chunk(uint8_t chunk, sctp_auth_chklist_t *list) 129{ 130 if (list == NULL) 131 return (-1); 132 133 if (list->chunks[chunk] == 1) { 134 list->chunks[chunk] = 0; 135 list->num_chunks--; 136 SCTPDBG(SCTP_DEBUG_AUTH1, 137 "SCTP: deleted chunk %u (0x%02x) from Auth list\n", 138 chunk, chunk); 139 } 140 return (0); 141} 142 143size_t 144sctp_auth_get_chklist_size(const sctp_auth_chklist_t *list) 145{ 146 if (list == NULL) 147 return (0); 148 else 149 return (list->num_chunks); 150} 151 152/* 153 * return the current number and list of required chunks caller must 154 * guarantee ptr has space for up to 256 bytes 155 */ 156int 157sctp_serialize_auth_chunks(const sctp_auth_chklist_t *list, uint8_t *ptr) 158{ 159 int i, count = 0; 160 161 if (list == NULL) 162 return (0); 163 164 for (i = 0; i < 256; i++) { 165 if (list->chunks[i] != 0) { 166 *ptr++ = i; 167 count++; 168 } 169 } 170 return (count); 171} 172 173int 174sctp_pack_auth_chunks(const sctp_auth_chklist_t *list, uint8_t *ptr) 175{ 176 int i, size = 0; 177 178 if (list == NULL) 179 return (0); 180 181 if (list->num_chunks <= 32) { 182 /* just list them, one byte each */ 183 for (i = 0; i < 256; i++) { 184 if (list->chunks[i] != 0) { 185 *ptr++ = i; 186 size++; 187 } 188 } 189 } else { 190 int index, offset; 191 192 /* pack into a 32 byte bitfield */ 193 for (i = 0; i < 256; i++) { 194 if (list->chunks[i] != 0) { 195 index = i / 8; 196 offset = i % 8; 197 ptr[index] |= (1 << offset); 198 } 199 } 200 size = 32; 201 } 202 return (size); 203} 204 205int 206sctp_unpack_auth_chunks(const uint8_t *ptr, uint8_t num_chunks, 207 sctp_auth_chklist_t *list) 208{ 209 int i; 210 int size; 211 212 if (list == NULL) 213 return (0); 214 215 if (num_chunks <= 32) { 216 /* just pull them, one byte each */ 217 for (i = 0; i < num_chunks; i++) { 218 (void)sctp_auth_add_chunk(*ptr++, list); 219 } 220 size = num_chunks; 221 } else { 222 int index, offset; 223 224 /* unpack from a 32 byte bitfield */ 225 for (index = 0; index < 32; index++) { 226 for (offset = 0; offset < 8; offset++) { 227 if (ptr[index] & (1 << offset)) { 228 (void)sctp_auth_add_chunk((index * 8) + offset, list); 229 } 230 } 231 } 232 size = 32; 233 } 234 return (size); 235} 236 237/* 238 * allocate structure space for a key of length keylen 239 */ 240sctp_key_t * 241sctp_alloc_key(uint32_t keylen) 242{ 243 sctp_key_t *new_key; 244 245 SCTP_MALLOC(new_key, sctp_key_t *, sizeof(*new_key) + keylen, 246 SCTP_M_AUTH_KY); 247 if (new_key == NULL) { 248 /* out of memory */ 249 return (NULL); 250 } 251 new_key->keylen = keylen; 252 return (new_key); 253} 254 255void 256sctp_free_key(sctp_key_t *key) 257{ 258 if (key != NULL) 259 SCTP_FREE(key, SCTP_M_AUTH_KY); 260} 261 262void 263sctp_print_key(sctp_key_t *key, const char *str) 264{ 265 uint32_t i; 266 267 if (key == NULL) { 268 SCTP_PRINTF("%s: [Null key]\n", str); 269 return; 270 } 271 SCTP_PRINTF("%s: len %u, ", str, key->keylen); 272 if (key->keylen) { 273 for (i = 0; i < key->keylen; i++) 274 SCTP_PRINTF("%02x", key->key[i]); 275 SCTP_PRINTF("\n"); 276 } else { 277 SCTP_PRINTF("[Null key]\n"); 278 } 279} 280 281void 282sctp_show_key(sctp_key_t *key, const char *str) 283{ 284 uint32_t i; 285 286 if (key == NULL) { 287 SCTP_PRINTF("%s: [Null key]\n", str); 288 return; 289 } 290 SCTP_PRINTF("%s: len %u, ", str, key->keylen); 291 if (key->keylen) { 292 for (i = 0; i < key->keylen; i++) 293 SCTP_PRINTF("%02x", key->key[i]); 294 SCTP_PRINTF("\n"); 295 } else { 296 SCTP_PRINTF("[Null key]\n"); 297 } 298} 299 300static uint32_t 301sctp_get_keylen(sctp_key_t *key) 302{ 303 if (key != NULL) 304 return (key->keylen); 305 else 306 return (0); 307} 308 309/* 310 * generate a new random key of length 'keylen' 311 */ 312sctp_key_t * 313sctp_generate_random_key(uint32_t keylen) 314{ 315 sctp_key_t *new_key; 316 317 new_key = sctp_alloc_key(keylen); 318 if (new_key == NULL) { 319 /* out of memory */ 320 return (NULL); 321 } 322 SCTP_READ_RANDOM(new_key->key, keylen); 323 new_key->keylen = keylen; 324 return (new_key); 325} 326 327sctp_key_t * 328sctp_set_key(uint8_t *key, uint32_t keylen) 329{ 330 sctp_key_t *new_key; 331 332 new_key = sctp_alloc_key(keylen); 333 if (new_key == NULL) { 334 /* out of memory */ 335 return (NULL); 336 } 337 memcpy(new_key->key, key, keylen); 338 return (new_key); 339} 340 341/*- 342 * given two keys of variable size, compute which key is "larger/smaller" 343 * returns: 1 if key1 > key2 344 * -1 if key1 < key2 345 * 0 if key1 = key2 346 */ 347static int 348sctp_compare_key(sctp_key_t *key1, sctp_key_t *key2) 349{ 350 uint32_t maxlen; 351 uint32_t i; 352 uint32_t key1len, key2len; 353 uint8_t *key_1, *key_2; 354 uint8_t val1, val2; 355 356 /* sanity/length check */ 357 key1len = sctp_get_keylen(key1); 358 key2len = sctp_get_keylen(key2); 359 if ((key1len == 0) && (key2len == 0)) 360 return (0); 361 else if (key1len == 0) 362 return (-1); 363 else if (key2len == 0) 364 return (1); 365 366 if (key1len < key2len) { 367 maxlen = key2len; 368 } else { 369 maxlen = key1len; 370 } 371 key_1 = key1->key; 372 key_2 = key2->key; 373 /* check for numeric equality */ 374 for (i = 0; i < maxlen; i++) { 375 /* left-pad with zeros */ 376 val1 = (i < (maxlen - key1len)) ? 0 : *(key_1++); 377 val2 = (i < (maxlen - key2len)) ? 0 : *(key_2++); 378 if (val1 > val2) { 379 return (1); 380 } else if (val1 < val2) { 381 return (-1); 382 } 383 } 384 /* keys are equal value, so check lengths */ 385 if (key1len == key2len) 386 return (0); 387 else if (key1len < key2len) 388 return (-1); 389 else 390 return (1); 391} 392 393/* 394 * generate the concatenated keying material based on the two keys and the 395 * shared key (if available). draft-ietf-tsvwg-auth specifies the specific 396 * order for concatenation 397 */ 398sctp_key_t * 399sctp_compute_hashkey(sctp_key_t *key1, sctp_key_t *key2, sctp_key_t *shared) 400{ 401 uint32_t keylen; 402 sctp_key_t *new_key; 403 uint8_t *key_ptr; 404 405 keylen = sctp_get_keylen(key1) + sctp_get_keylen(key2) + 406 sctp_get_keylen(shared); 407 408 if (keylen > 0) { 409 /* get space for the new key */ 410 new_key = sctp_alloc_key(keylen); 411 if (new_key == NULL) { 412 /* out of memory */ 413 return (NULL); 414 } 415 new_key->keylen = keylen; 416 key_ptr = new_key->key; 417 } else { 418 /* all keys empty/null?! */ 419 return (NULL); 420 } 421 422 /* concatenate the keys */ 423 if (sctp_compare_key(key1, key2) <= 0) { 424 /* key is shared + key1 + key2 */ 425 if (sctp_get_keylen(shared)) { 426 memcpy(key_ptr, shared->key, shared->keylen); 427 key_ptr += shared->keylen; 428 } 429 if (sctp_get_keylen(key1)) { 430 memcpy(key_ptr, key1->key, key1->keylen); 431 key_ptr += key1->keylen; 432 } 433 if (sctp_get_keylen(key2)) { 434 memcpy(key_ptr, key2->key, key2->keylen); 435 } 436 } else { 437 /* key is shared + key2 + key1 */ 438 if (sctp_get_keylen(shared)) { 439 memcpy(key_ptr, shared->key, shared->keylen); 440 key_ptr += shared->keylen; 441 } 442 if (sctp_get_keylen(key2)) { 443 memcpy(key_ptr, key2->key, key2->keylen); 444 key_ptr += key2->keylen; 445 } 446 if (sctp_get_keylen(key1)) { 447 memcpy(key_ptr, key1->key, key1->keylen); 448 } 449 } 450 return (new_key); 451} 452 453sctp_sharedkey_t * 454sctp_alloc_sharedkey(void) 455{ 456 sctp_sharedkey_t *new_key; 457 458 SCTP_MALLOC(new_key, sctp_sharedkey_t *, sizeof(*new_key), 459 SCTP_M_AUTH_KY); 460 if (new_key == NULL) { 461 /* out of memory */ 462 return (NULL); 463 } 464 new_key->keyid = 0; 465 new_key->key = NULL; 466 new_key->refcount = 1; 467 new_key->deactivated = 0; 468 return (new_key); 469} 470 471void 472sctp_free_sharedkey(sctp_sharedkey_t *skey) 473{ 474 if (skey == NULL) 475 return; 476 477 if (SCTP_DECREMENT_AND_CHECK_REFCOUNT(&skey->refcount)) { 478 if (skey->key != NULL) 479 sctp_free_key(skey->key); 480 SCTP_FREE(skey, SCTP_M_AUTH_KY); 481 } 482} 483 484sctp_sharedkey_t * 485sctp_find_sharedkey(struct sctp_keyhead *shared_keys, uint16_t key_id) 486{ 487 sctp_sharedkey_t *skey; 488 489 LIST_FOREACH(skey, shared_keys, next) { 490 if (skey->keyid == key_id) 491 return (skey); 492 } 493 return (NULL); 494} 495 496int 497sctp_insert_sharedkey(struct sctp_keyhead *shared_keys, 498 sctp_sharedkey_t *new_skey) 499{ 500 sctp_sharedkey_t *skey; 501 502 if ((shared_keys == NULL) || (new_skey == NULL)) 503 return (EINVAL); 504 505 /* insert into an empty list? */ 506 if (LIST_EMPTY(shared_keys)) { 507 LIST_INSERT_HEAD(shared_keys, new_skey, next); 508 return (0); 509 } 510 /* insert into the existing list, ordered by key id */ 511 LIST_FOREACH(skey, shared_keys, next) { 512 if (new_skey->keyid < skey->keyid) { 513 /* insert it before here */ 514 LIST_INSERT_BEFORE(skey, new_skey, next); 515 return (0); 516 } else if (new_skey->keyid == skey->keyid) { 517 /* replace the existing key */ 518 /* verify this key *can* be replaced */ 519 if ((skey->deactivated) || (skey->refcount > 1)) { 520 SCTPDBG(SCTP_DEBUG_AUTH1, 521 "can't replace shared key id %u\n", 522 new_skey->keyid); 523 return (EBUSY); 524 } 525 SCTPDBG(SCTP_DEBUG_AUTH1, 526 "replacing shared key id %u\n", 527 new_skey->keyid); 528 LIST_INSERT_BEFORE(skey, new_skey, next); 529 LIST_REMOVE(skey, next); 530 sctp_free_sharedkey(skey); 531 return (0); 532 } 533 if (LIST_NEXT(skey, next) == NULL) { 534 /* belongs at the end of the list */ 535 LIST_INSERT_AFTER(skey, new_skey, next); 536 return (0); 537 } 538 } 539 /* shouldn't reach here */ 540 return (EINVAL); 541} 542 543void 544sctp_auth_key_acquire(struct sctp_tcb *stcb, uint16_t key_id) 545{ 546 sctp_sharedkey_t *skey; 547 548 /* find the shared key */ 549 skey = sctp_find_sharedkey(&stcb->asoc.shared_keys, key_id); 550 551 /* bump the ref count */ 552 if (skey) { 553 atomic_add_int(&skey->refcount, 1); 554 SCTPDBG(SCTP_DEBUG_AUTH2, 555 "%s: stcb %p key %u refcount acquire to %d\n", 556 __func__, (void *)stcb, key_id, skey->refcount); 557 } 558} 559 560void 561sctp_auth_key_release(struct sctp_tcb *stcb, uint16_t key_id, int so_locked) 562{ 563 sctp_sharedkey_t *skey; 564 565 /* find the shared key */ 566 skey = sctp_find_sharedkey(&stcb->asoc.shared_keys, key_id); 567 568 /* decrement the ref count */ 569 if (skey) { 570 SCTPDBG(SCTP_DEBUG_AUTH2, 571 "%s: stcb %p key %u refcount release to %d\n", 572 __func__, (void *)stcb, key_id, skey->refcount); 573 574 /* see if a notification should be generated */ 575 if ((skey->refcount <= 2) && (skey->deactivated)) { 576 /* notify ULP that key is no longer used */ 577 sctp_ulp_notify(SCTP_NOTIFY_AUTH_FREE_KEY, stcb, 578 0, &key_id, so_locked); 579 SCTPDBG(SCTP_DEBUG_AUTH2, 580 "%s: stcb %p key %u no longer used, %d\n", 581 __func__, (void *)stcb, key_id, skey->refcount); 582 } 583 sctp_free_sharedkey(skey); 584 } 585} 586 587static sctp_sharedkey_t * 588sctp_copy_sharedkey(const sctp_sharedkey_t *skey) 589{ 590 sctp_sharedkey_t *new_skey; 591 592 if (skey == NULL) 593 return (NULL); 594 new_skey = sctp_alloc_sharedkey(); 595 if (new_skey == NULL) 596 return (NULL); 597 if (skey->key != NULL) 598 new_skey->key = sctp_set_key(skey->key->key, skey->key->keylen); 599 else 600 new_skey->key = NULL; 601 new_skey->keyid = skey->keyid; 602 return (new_skey); 603} 604 605int 606sctp_copy_skeylist(const struct sctp_keyhead *src, struct sctp_keyhead *dest) 607{ 608 sctp_sharedkey_t *skey, *new_skey; 609 int count = 0; 610 611 if ((src == NULL) || (dest == NULL)) 612 return (0); 613 LIST_FOREACH(skey, src, next) { 614 new_skey = sctp_copy_sharedkey(skey); 615 if (new_skey != NULL) { 616 if (sctp_insert_sharedkey(dest, new_skey)) { 617 sctp_free_sharedkey(new_skey); 618 } else { 619 count++; 620 } 621 } 622 } 623 return (count); 624} 625 626sctp_hmaclist_t * 627sctp_alloc_hmaclist(uint16_t num_hmacs) 628{ 629 sctp_hmaclist_t *new_list; 630 int alloc_size; 631 632 alloc_size = sizeof(*new_list) + num_hmacs * sizeof(new_list->hmac[0]); 633 SCTP_MALLOC(new_list, sctp_hmaclist_t *, alloc_size, 634 SCTP_M_AUTH_HL); 635 if (new_list == NULL) { 636 /* out of memory */ 637 return (NULL); 638 } 639 new_list->max_algo = num_hmacs; 640 new_list->num_algo = 0; 641 return (new_list); 642} 643 644void 645sctp_free_hmaclist(sctp_hmaclist_t *list) 646{ 647 if (list != NULL) { 648 SCTP_FREE(list, SCTP_M_AUTH_HL); 649 } 650} 651 652int 653sctp_auth_add_hmacid(sctp_hmaclist_t *list, uint16_t hmac_id) 654{ 655 int i; 656 657 if (list == NULL) 658 return (-1); 659 if (list->num_algo == list->max_algo) { 660 SCTPDBG(SCTP_DEBUG_AUTH1, 661 "SCTP: HMAC id list full, ignoring add %u\n", hmac_id); 662 return (-1); 663 } 664 if ((hmac_id != SCTP_AUTH_HMAC_ID_SHA1) && 665 (hmac_id != SCTP_AUTH_HMAC_ID_SHA256)) { 666 return (-1); 667 } 668 /* Now is it already in the list */ 669 for (i = 0; i < list->num_algo; i++) { 670 if (list->hmac[i] == hmac_id) { 671 /* already in list */ 672 return (-1); 673 } 674 } 675 SCTPDBG(SCTP_DEBUG_AUTH1, "SCTP: add HMAC id %u to list\n", hmac_id); 676 list->hmac[list->num_algo++] = hmac_id; 677 return (0); 678} 679 680sctp_hmaclist_t * 681sctp_copy_hmaclist(sctp_hmaclist_t *list) 682{ 683 sctp_hmaclist_t *new_list; 684 int i; 685 686 if (list == NULL) 687 return (NULL); 688 /* get a new list */ 689 new_list = sctp_alloc_hmaclist(list->max_algo); 690 if (new_list == NULL) 691 return (NULL); 692 /* copy it */ 693 new_list->max_algo = list->max_algo; 694 new_list->num_algo = list->num_algo; 695 for (i = 0; i < list->num_algo; i++) 696 new_list->hmac[i] = list->hmac[i]; 697 return (new_list); 698} 699 700sctp_hmaclist_t * 701sctp_default_supported_hmaclist(void) 702{ 703 sctp_hmaclist_t *new_list; 704 705 new_list = sctp_alloc_hmaclist(2); 706 if (new_list == NULL) 707 return (NULL); 708 /* We prefer SHA256, so list it first */ 709 (void)sctp_auth_add_hmacid(new_list, SCTP_AUTH_HMAC_ID_SHA256); 710 (void)sctp_auth_add_hmacid(new_list, SCTP_AUTH_HMAC_ID_SHA1); 711 return (new_list); 712} 713 714/*- 715 * HMAC algos are listed in priority/preference order 716 * find the best HMAC id to use for the peer based on local support 717 */ 718uint16_t 719sctp_negotiate_hmacid(sctp_hmaclist_t *peer, sctp_hmaclist_t *local) 720{ 721 int i, j; 722 723 if ((local == NULL) || (peer == NULL)) 724 return (SCTP_AUTH_HMAC_ID_RSVD); 725 726 for (i = 0; i < peer->num_algo; i++) { 727 for (j = 0; j < local->num_algo; j++) { 728 if (peer->hmac[i] == local->hmac[j]) { 729 /* found the "best" one */ 730 SCTPDBG(SCTP_DEBUG_AUTH1, 731 "SCTP: negotiated peer HMAC id %u\n", 732 peer->hmac[i]); 733 return (peer->hmac[i]); 734 } 735 } 736 } 737 /* didn't find one! */ 738 return (SCTP_AUTH_HMAC_ID_RSVD); 739} 740 741/*- 742 * serialize the HMAC algo list and return space used 743 * caller must guarantee ptr has appropriate space 744 */ 745int 746sctp_serialize_hmaclist(sctp_hmaclist_t *list, uint8_t *ptr) 747{ 748 int i; 749 uint16_t hmac_id; 750 751 if (list == NULL) 752 return (0); 753 754 for (i = 0; i < list->num_algo; i++) { 755 hmac_id = htons(list->hmac[i]); 756 memcpy(ptr, &hmac_id, sizeof(hmac_id)); 757 ptr += sizeof(hmac_id); 758 } 759 return (list->num_algo * sizeof(hmac_id)); 760} 761 762int 763sctp_verify_hmac_param(struct sctp_auth_hmac_algo *hmacs, uint32_t num_hmacs) 764{ 765 uint32_t i; 766 767 for (i = 0; i < num_hmacs; i++) { 768 if (ntohs(hmacs->hmac_ids[i]) == SCTP_AUTH_HMAC_ID_SHA1) { 769 return (0); 770 } 771 } 772 return (-1); 773} 774 775sctp_authinfo_t * 776sctp_alloc_authinfo(void) 777{ 778 sctp_authinfo_t *new_authinfo; 779 780 SCTP_MALLOC(new_authinfo, sctp_authinfo_t *, sizeof(*new_authinfo), 781 SCTP_M_AUTH_IF); 782 783 if (new_authinfo == NULL) { 784 /* out of memory */ 785 return (NULL); 786 } 787 memset(new_authinfo, 0, sizeof(*new_authinfo)); 788 return (new_authinfo); 789} 790 791void 792sctp_free_authinfo(sctp_authinfo_t *authinfo) 793{ 794 if (authinfo == NULL) 795 return; 796 797 if (authinfo->random != NULL) 798 sctp_free_key(authinfo->random); 799 if (authinfo->peer_random != NULL) 800 sctp_free_key(authinfo->peer_random); 801 if (authinfo->assoc_key != NULL) 802 sctp_free_key(authinfo->assoc_key); 803 if (authinfo->recv_key != NULL) 804 sctp_free_key(authinfo->recv_key); 805 806 /* We are NOT dynamically allocating authinfo's right now... */ 807 /* SCTP_FREE(authinfo, SCTP_M_AUTH_??); */ 808} 809 810uint32_t 811sctp_get_auth_chunk_len(uint16_t hmac_algo) 812{ 813 int size; 814 815 size = sizeof(struct sctp_auth_chunk) + sctp_get_hmac_digest_len(hmac_algo); 816 return (SCTP_SIZE32(size)); 817} 818 819uint32_t 820sctp_get_hmac_digest_len(uint16_t hmac_algo) 821{ 822 switch (hmac_algo) { 823 case SCTP_AUTH_HMAC_ID_SHA1: 824 return (SCTP_AUTH_DIGEST_LEN_SHA1); 825 case SCTP_AUTH_HMAC_ID_SHA256: 826 return (SCTP_AUTH_DIGEST_LEN_SHA256); 827 default: 828 /* unknown HMAC algorithm: can't do anything */ 829 return (0); 830 } /* end switch */ 831} 832 833static inline int 834sctp_get_hmac_block_len(uint16_t hmac_algo) 835{ 836 switch (hmac_algo) { 837 case SCTP_AUTH_HMAC_ID_SHA1: 838 return (64); 839 case SCTP_AUTH_HMAC_ID_SHA256: 840 return (64); 841 case SCTP_AUTH_HMAC_ID_RSVD: 842 default: 843 /* unknown HMAC algorithm: can't do anything */ 844 return (0); 845 } /* end switch */ 846} 847 848static void 849sctp_hmac_init(uint16_t hmac_algo, sctp_hash_context_t *ctx) 850{ 851 switch (hmac_algo) { 852 case SCTP_AUTH_HMAC_ID_SHA1: 853 SCTP_SHA1_INIT(&ctx->sha1); 854 break; 855 case SCTP_AUTH_HMAC_ID_SHA256: 856 SCTP_SHA256_INIT(&ctx->sha256); 857 break; 858 case SCTP_AUTH_HMAC_ID_RSVD: 859 default: 860 /* unknown HMAC algorithm: can't do anything */ 861 return; 862 } /* end switch */ 863} 864 865static void 866sctp_hmac_update(uint16_t hmac_algo, sctp_hash_context_t *ctx, 867 uint8_t *text, uint32_t textlen) 868{ 869 switch (hmac_algo) { 870 case SCTP_AUTH_HMAC_ID_SHA1: 871 SCTP_SHA1_UPDATE(&ctx->sha1, text, textlen); 872 break; 873 case SCTP_AUTH_HMAC_ID_SHA256: 874 SCTP_SHA256_UPDATE(&ctx->sha256, text, textlen); 875 break; 876 case SCTP_AUTH_HMAC_ID_RSVD: 877 default: 878 /* unknown HMAC algorithm: can't do anything */ 879 return; 880 } /* end switch */ 881} 882 883static void 884sctp_hmac_final(uint16_t hmac_algo, sctp_hash_context_t *ctx, 885 uint8_t *digest) 886{ 887 switch (hmac_algo) { 888 case SCTP_AUTH_HMAC_ID_SHA1: 889 SCTP_SHA1_FINAL(digest, &ctx->sha1); 890 break; 891 case SCTP_AUTH_HMAC_ID_SHA256: 892 SCTP_SHA256_FINAL(digest, &ctx->sha256); 893 break; 894 case SCTP_AUTH_HMAC_ID_RSVD: 895 default: 896 /* unknown HMAC algorithm: can't do anything */ 897 return; 898 } /* end switch */ 899} 900 901/*- 902 * Keyed-Hashing for Message Authentication: FIPS 198 (RFC 2104) 903 * 904 * Compute the HMAC digest using the desired hash key, text, and HMAC 905 * algorithm. Resulting digest is placed in 'digest' and digest length 906 * is returned, if the HMAC was performed. 907 * 908 * WARNING: it is up to the caller to supply sufficient space to hold the 909 * resultant digest. 910 */ 911uint32_t 912sctp_hmac(uint16_t hmac_algo, uint8_t *key, uint32_t keylen, 913 uint8_t *text, uint32_t textlen, uint8_t *digest) 914{ 915 uint32_t digestlen; 916 uint32_t blocklen; 917 sctp_hash_context_t ctx; 918 uint8_t ipad[128], opad[128]; /* keyed hash inner/outer pads */ 919 uint8_t temp[SCTP_AUTH_DIGEST_LEN_MAX]; 920 uint32_t i; 921 922 /* sanity check the material and length */ 923 if ((key == NULL) || (keylen == 0) || (text == NULL) || 924 (textlen == 0) || (digest == NULL)) { 925 /* can't do HMAC with empty key or text or digest store */ 926 return (0); 927 } 928 /* validate the hmac algo and get the digest length */ 929 digestlen = sctp_get_hmac_digest_len(hmac_algo); 930 if (digestlen == 0) 931 return (0); 932 933 /* hash the key if it is longer than the hash block size */ 934 blocklen = sctp_get_hmac_block_len(hmac_algo); 935 if (keylen > blocklen) { 936 sctp_hmac_init(hmac_algo, &ctx); 937 sctp_hmac_update(hmac_algo, &ctx, key, keylen); 938 sctp_hmac_final(hmac_algo, &ctx, temp); 939 /* set the hashed key as the key */ 940 keylen = digestlen; 941 key = temp; 942 } 943 /* initialize the inner/outer pads with the key and "append" zeroes */ 944 memset(ipad, 0, blocklen); 945 memset(opad, 0, blocklen); 946 memcpy(ipad, key, keylen); 947 memcpy(opad, key, keylen); 948 949 /* XOR the key with ipad and opad values */ 950 for (i = 0; i < blocklen; i++) { 951 ipad[i] ^= 0x36; 952 opad[i] ^= 0x5c; 953 } 954 955 /* perform inner hash */ 956 sctp_hmac_init(hmac_algo, &ctx); 957 sctp_hmac_update(hmac_algo, &ctx, ipad, blocklen); 958 sctp_hmac_update(hmac_algo, &ctx, text, textlen); 959 sctp_hmac_final(hmac_algo, &ctx, temp); 960 961 /* perform outer hash */ 962 sctp_hmac_init(hmac_algo, &ctx); 963 sctp_hmac_update(hmac_algo, &ctx, opad, blocklen); 964 sctp_hmac_update(hmac_algo, &ctx, temp, digestlen); 965 sctp_hmac_final(hmac_algo, &ctx, digest); 966 967 return (digestlen); 968} 969 970/* mbuf version */ 971uint32_t 972sctp_hmac_m(uint16_t hmac_algo, uint8_t *key, uint32_t keylen, 973 struct mbuf *m, uint32_t m_offset, uint8_t *digest, uint32_t trailer) 974{ 975 uint32_t digestlen; 976 uint32_t blocklen; 977 sctp_hash_context_t ctx; 978 uint8_t ipad[128], opad[128]; /* keyed hash inner/outer pads */ 979 uint8_t temp[SCTP_AUTH_DIGEST_LEN_MAX]; 980 uint32_t i; 981 struct mbuf *m_tmp; 982 983 /* sanity check the material and length */ 984 if ((key == NULL) || (keylen == 0) || (m == NULL) || (digest == NULL)) { 985 /* can't do HMAC with empty key or text or digest store */ 986 return (0); 987 } 988 /* validate the hmac algo and get the digest length */ 989 digestlen = sctp_get_hmac_digest_len(hmac_algo); 990 if (digestlen == 0) 991 return (0); 992 993 /* hash the key if it is longer than the hash block size */ 994 blocklen = sctp_get_hmac_block_len(hmac_algo); 995 if (keylen > blocklen) { 996 sctp_hmac_init(hmac_algo, &ctx); 997 sctp_hmac_update(hmac_algo, &ctx, key, keylen); 998 sctp_hmac_final(hmac_algo, &ctx, temp); 999 /* set the hashed key as the key */ 1000 keylen = digestlen; 1001 key = temp; 1002 } 1003 /* initialize the inner/outer pads with the key and "append" zeroes */ 1004 memset(ipad, 0, blocklen); 1005 memset(opad, 0, blocklen); 1006 memcpy(ipad, key, keylen); 1007 memcpy(opad, key, keylen); 1008 1009 /* XOR the key with ipad and opad values */ 1010 for (i = 0; i < blocklen; i++) { 1011 ipad[i] ^= 0x36; 1012 opad[i] ^= 0x5c; 1013 } 1014 1015 /* perform inner hash */ 1016 sctp_hmac_init(hmac_algo, &ctx); 1017 sctp_hmac_update(hmac_algo, &ctx, ipad, blocklen); 1018 /* find the correct starting mbuf and offset (get start of text) */ 1019 m_tmp = m; 1020 while ((m_tmp != NULL) && (m_offset >= (uint32_t)SCTP_BUF_LEN(m_tmp))) { 1021 m_offset -= SCTP_BUF_LEN(m_tmp); 1022 m_tmp = SCTP_BUF_NEXT(m_tmp); 1023 } 1024 /* now use the rest of the mbuf chain for the text */ 1025 while (m_tmp != NULL) { 1026 if ((SCTP_BUF_NEXT(m_tmp) == NULL) && trailer) { 1027 sctp_hmac_update(hmac_algo, &ctx, mtod(m_tmp, uint8_t *)+m_offset, 1028 SCTP_BUF_LEN(m_tmp) - (trailer + m_offset)); 1029 } else { 1030 sctp_hmac_update(hmac_algo, &ctx, mtod(m_tmp, uint8_t *)+m_offset, 1031 SCTP_BUF_LEN(m_tmp) - m_offset); 1032 } 1033 1034 /* clear the offset since it's only for the first mbuf */ 1035 m_offset = 0; 1036 m_tmp = SCTP_BUF_NEXT(m_tmp); 1037 } 1038 sctp_hmac_final(hmac_algo, &ctx, temp); 1039 1040 /* perform outer hash */ 1041 sctp_hmac_init(hmac_algo, &ctx); 1042 sctp_hmac_update(hmac_algo, &ctx, opad, blocklen); 1043 sctp_hmac_update(hmac_algo, &ctx, temp, digestlen); 1044 sctp_hmac_final(hmac_algo, &ctx, digest); 1045 1046 return (digestlen); 1047} 1048 1049/* 1050 * computes the requested HMAC using a key struct (which may be modified if 1051 * the keylen exceeds the HMAC block len). 1052 */ 1053uint32_t 1054sctp_compute_hmac(uint16_t hmac_algo, sctp_key_t *key, uint8_t *text, 1055 uint32_t textlen, uint8_t *digest) 1056{ 1057 uint32_t digestlen; 1058 uint32_t blocklen; 1059 sctp_hash_context_t ctx; 1060 uint8_t temp[SCTP_AUTH_DIGEST_LEN_MAX]; 1061 1062 /* sanity check */ 1063 if ((key == NULL) || (text == NULL) || (textlen == 0) || 1064 (digest == NULL)) { 1065 /* can't do HMAC with empty key or text or digest store */ 1066 return (0); 1067 } 1068 /* validate the hmac algo and get the digest length */ 1069 digestlen = sctp_get_hmac_digest_len(hmac_algo); 1070 if (digestlen == 0) 1071 return (0); 1072 1073 /* hash the key if it is longer than the hash block size */ 1074 blocklen = sctp_get_hmac_block_len(hmac_algo); 1075 if (key->keylen > blocklen) { 1076 sctp_hmac_init(hmac_algo, &ctx); 1077 sctp_hmac_update(hmac_algo, &ctx, key->key, key->keylen); 1078 sctp_hmac_final(hmac_algo, &ctx, temp); 1079 /* save the hashed key as the new key */ 1080 key->keylen = digestlen; 1081 memcpy(key->key, temp, key->keylen); 1082 } 1083 return (sctp_hmac(hmac_algo, key->key, key->keylen, text, textlen, 1084 digest)); 1085} 1086 1087/* mbuf version */ 1088uint32_t 1089sctp_compute_hmac_m(uint16_t hmac_algo, sctp_key_t *key, struct mbuf *m, 1090 uint32_t m_offset, uint8_t *digest) 1091{ 1092 uint32_t digestlen; 1093 uint32_t blocklen; 1094 sctp_hash_context_t ctx; 1095 uint8_t temp[SCTP_AUTH_DIGEST_LEN_MAX]; 1096 1097 /* sanity check */ 1098 if ((key == NULL) || (m == NULL) || (digest == NULL)) { 1099 /* can't do HMAC with empty key or text or digest store */ 1100 return (0); 1101 } 1102 /* validate the hmac algo and get the digest length */ 1103 digestlen = sctp_get_hmac_digest_len(hmac_algo); 1104 if (digestlen == 0) 1105 return (0); 1106 1107 /* hash the key if it is longer than the hash block size */ 1108 blocklen = sctp_get_hmac_block_len(hmac_algo); 1109 if (key->keylen > blocklen) { 1110 sctp_hmac_init(hmac_algo, &ctx); 1111 sctp_hmac_update(hmac_algo, &ctx, key->key, key->keylen); 1112 sctp_hmac_final(hmac_algo, &ctx, temp); 1113 /* save the hashed key as the new key */ 1114 key->keylen = digestlen; 1115 memcpy(key->key, temp, key->keylen); 1116 } 1117 return (sctp_hmac_m(hmac_algo, key->key, key->keylen, m, m_offset, digest, 0)); 1118} 1119 1120int 1121sctp_auth_is_supported_hmac(sctp_hmaclist_t *list, uint16_t id) 1122{ 1123 int i; 1124 1125 if ((list == NULL) || (id == SCTP_AUTH_HMAC_ID_RSVD)) 1126 return (0); 1127 1128 for (i = 0; i < list->num_algo; i++) 1129 if (list->hmac[i] == id) 1130 return (1); 1131 1132 /* not in the list */ 1133 return (0); 1134} 1135 1136/*- 1137 * clear any cached key(s) if they match the given key id on an association. 1138 * the cached key(s) will be recomputed and re-cached at next use. 1139 * ASSUMES TCB_LOCK is already held 1140 */ 1141void 1142sctp_clear_cachedkeys(struct sctp_tcb *stcb, uint16_t keyid) 1143{ 1144 if (stcb == NULL) 1145 return; 1146 1147 if (keyid == stcb->asoc.authinfo.assoc_keyid) { 1148 sctp_free_key(stcb->asoc.authinfo.assoc_key); 1149 stcb->asoc.authinfo.assoc_key = NULL; 1150 } 1151 if (keyid == stcb->asoc.authinfo.recv_keyid) { 1152 sctp_free_key(stcb->asoc.authinfo.recv_key); 1153 stcb->asoc.authinfo.recv_key = NULL; 1154 } 1155} 1156 1157/*- 1158 * clear any cached key(s) if they match the given key id for all assocs on 1159 * an endpoint. 1160 * ASSUMES INP_WLOCK is already held 1161 */ 1162void 1163sctp_clear_cachedkeys_ep(struct sctp_inpcb *inp, uint16_t keyid) 1164{ 1165 struct sctp_tcb *stcb; 1166 1167 if (inp == NULL) 1168 return; 1169 1170 /* clear the cached keys on all assocs on this instance */ 1171 LIST_FOREACH(stcb, &inp->sctp_asoc_list, sctp_tcblist) { 1172 SCTP_TCB_LOCK(stcb); 1173 sctp_clear_cachedkeys(stcb, keyid); 1174 SCTP_TCB_UNLOCK(stcb); 1175 } 1176} 1177 1178/*- 1179 * delete a shared key from an association 1180 * ASSUMES TCB_LOCK is already held 1181 */ 1182int 1183sctp_delete_sharedkey(struct sctp_tcb *stcb, uint16_t keyid) 1184{ 1185 sctp_sharedkey_t *skey; 1186 1187 if (stcb == NULL) 1188 return (-1); 1189 1190 /* is the keyid the assoc active sending key */ 1191 if (keyid == stcb->asoc.authinfo.active_keyid) 1192 return (-1); 1193 1194 /* does the key exist? */ 1195 skey = sctp_find_sharedkey(&stcb->asoc.shared_keys, keyid); 1196 if (skey == NULL) 1197 return (-1); 1198 1199 /* are there other refcount holders on the key? */ 1200 if (skey->refcount > 1) 1201 return (-1); 1202 1203 /* remove it */ 1204 LIST_REMOVE(skey, next); 1205 sctp_free_sharedkey(skey); /* frees skey->key as well */ 1206 1207 /* clear any cached keys */ 1208 sctp_clear_cachedkeys(stcb, keyid); 1209 return (0); 1210} 1211 1212/*- 1213 * deletes a shared key from the endpoint 1214 * ASSUMES INP_WLOCK is already held 1215 */ 1216int 1217sctp_delete_sharedkey_ep(struct sctp_inpcb *inp, uint16_t keyid) 1218{ 1219 sctp_sharedkey_t *skey; 1220 1221 if (inp == NULL) 1222 return (-1); 1223 1224 /* is the keyid the active sending key on the endpoint */ 1225 if (keyid == inp->sctp_ep.default_keyid) 1226 return (-1); 1227 1228 /* does the key exist? */ 1229 skey = sctp_find_sharedkey(&inp->sctp_ep.shared_keys, keyid); 1230 if (skey == NULL) 1231 return (-1); 1232 1233 /* endpoint keys are not refcounted */ 1234 1235 /* remove it */ 1236 LIST_REMOVE(skey, next); 1237 sctp_free_sharedkey(skey); /* frees skey->key as well */ 1238 1239 /* clear any cached keys */ 1240 sctp_clear_cachedkeys_ep(inp, keyid); 1241 return (0); 1242} 1243 1244/*- 1245 * set the active key on an association 1246 * ASSUMES TCB_LOCK is already held 1247 */ 1248int 1249sctp_auth_setactivekey(struct sctp_tcb *stcb, uint16_t keyid) 1250{ 1251 sctp_sharedkey_t *skey = NULL; 1252 1253 /* find the key on the assoc */ 1254 skey = sctp_find_sharedkey(&stcb->asoc.shared_keys, keyid); 1255 if (skey == NULL) { 1256 /* that key doesn't exist */ 1257 return (-1); 1258 } 1259 if ((skey->deactivated) && (skey->refcount > 1)) { 1260 /* can't reactivate a deactivated key with other refcounts */ 1261 return (-1); 1262 } 1263 1264 /* set the (new) active key */ 1265 stcb->asoc.authinfo.active_keyid = keyid; 1266 /* reset the deactivated flag */ 1267 skey->deactivated = 0; 1268 1269 return (0); 1270} 1271 1272/*- 1273 * set the active key on an endpoint 1274 * ASSUMES INP_WLOCK is already held 1275 */ 1276int 1277sctp_auth_setactivekey_ep(struct sctp_inpcb *inp, uint16_t keyid) 1278{ 1279 sctp_sharedkey_t *skey; 1280 1281 /* find the key */ 1282 skey = sctp_find_sharedkey(&inp->sctp_ep.shared_keys, keyid); 1283 if (skey == NULL) { 1284 /* that key doesn't exist */ 1285 return (-1); 1286 } 1287 inp->sctp_ep.default_keyid = keyid; 1288 return (0); 1289} 1290 1291/*- 1292 * deactivates a shared key from the association 1293 * ASSUMES INP_WLOCK is already held 1294 */ 1295int 1296sctp_deact_sharedkey(struct sctp_tcb *stcb, uint16_t keyid) 1297{ 1298 sctp_sharedkey_t *skey; 1299 1300 if (stcb == NULL) 1301 return (-1); 1302 1303 /* is the keyid the assoc active sending key */ 1304 if (keyid == stcb->asoc.authinfo.active_keyid) 1305 return (-1); 1306 1307 /* does the key exist? */ 1308 skey = sctp_find_sharedkey(&stcb->asoc.shared_keys, keyid); 1309 if (skey == NULL) 1310 return (-1); 1311 1312 /* are there other refcount holders on the key? */ 1313 if (skey->refcount == 1) { 1314 /* no other users, send a notification for this key */ 1315 sctp_ulp_notify(SCTP_NOTIFY_AUTH_FREE_KEY, stcb, 0, &keyid, 1316 SCTP_SO_LOCKED); 1317 } 1318 1319 /* mark the key as deactivated */ 1320 skey->deactivated = 1; 1321 1322 return (0); 1323} 1324 1325/*- 1326 * deactivates a shared key from the endpoint 1327 * ASSUMES INP_WLOCK is already held 1328 */ 1329int 1330sctp_deact_sharedkey_ep(struct sctp_inpcb *inp, uint16_t keyid) 1331{ 1332 sctp_sharedkey_t *skey; 1333 1334 if (inp == NULL) 1335 return (-1); 1336 1337 /* is the keyid the active sending key on the endpoint */ 1338 if (keyid == inp->sctp_ep.default_keyid) 1339 return (-1); 1340 1341 /* does the key exist? */ 1342 skey = sctp_find_sharedkey(&inp->sctp_ep.shared_keys, keyid); 1343 if (skey == NULL) 1344 return (-1); 1345 1346 /* endpoint keys are not refcounted */ 1347 1348 /* remove it */ 1349 LIST_REMOVE(skey, next); 1350 sctp_free_sharedkey(skey); /* frees skey->key as well */ 1351 1352 return (0); 1353} 1354 1355/* 1356 * get local authentication parameters from cookie (from INIT-ACK) 1357 */ 1358void 1359sctp_auth_get_cookie_params(struct sctp_tcb *stcb, struct mbuf *m, 1360 uint32_t offset, uint32_t length) 1361{ 1362 struct sctp_paramhdr *phdr, tmp_param; 1363 uint16_t plen, ptype; 1364 uint8_t random_store[SCTP_PARAM_BUFFER_SIZE]; 1365 struct sctp_auth_random *p_random = NULL; 1366 uint16_t random_len = 0; 1367 uint8_t hmacs_store[SCTP_PARAM_BUFFER_SIZE]; 1368 struct sctp_auth_hmac_algo *hmacs = NULL; 1369 uint16_t hmacs_len = 0; 1370 uint8_t chunks_store[SCTP_PARAM_BUFFER_SIZE]; 1371 struct sctp_auth_chunk_list *chunks = NULL; 1372 uint16_t num_chunks = 0; 1373 sctp_key_t *new_key; 1374 uint32_t keylen; 1375 1376 /* convert to upper bound */ 1377 length += offset; 1378 1379 phdr = (struct sctp_paramhdr *)sctp_m_getptr(m, offset, 1380 sizeof(struct sctp_paramhdr), (uint8_t *)&tmp_param); 1381 while (phdr != NULL) { 1382 ptype = ntohs(phdr->param_type); 1383 plen = ntohs(phdr->param_length); 1384 1385 if ((plen < sizeof(struct sctp_paramhdr)) || 1386 (offset + plen > length)) 1387 break; 1388 1389 if (ptype == SCTP_RANDOM) { 1390 if (plen > sizeof(random_store)) 1391 break; 1392 phdr = sctp_get_next_param(m, offset, 1393 (struct sctp_paramhdr *)random_store, plen); 1394 if (phdr == NULL) 1395 return; 1396 /* save the random and length for the key */ 1397 p_random = (struct sctp_auth_random *)phdr; 1398 random_len = plen - sizeof(*p_random); 1399 } else if (ptype == SCTP_HMAC_LIST) { 1400 uint16_t num_hmacs; 1401 uint16_t i; 1402 1403 if (plen > sizeof(hmacs_store)) 1404 break; 1405 phdr = sctp_get_next_param(m, offset, 1406 (struct sctp_paramhdr *)hmacs_store, plen); 1407 if (phdr == NULL) 1408 return; 1409 /* save the hmacs list and num for the key */ 1410 hmacs = (struct sctp_auth_hmac_algo *)phdr; 1411 hmacs_len = plen - sizeof(*hmacs); 1412 num_hmacs = hmacs_len / sizeof(hmacs->hmac_ids[0]); 1413 if (stcb->asoc.local_hmacs != NULL) 1414 sctp_free_hmaclist(stcb->asoc.local_hmacs); 1415 stcb->asoc.local_hmacs = sctp_alloc_hmaclist(num_hmacs); 1416 if (stcb->asoc.local_hmacs != NULL) { 1417 for (i = 0; i < num_hmacs; i++) { 1418 (void)sctp_auth_add_hmacid(stcb->asoc.local_hmacs, 1419 ntohs(hmacs->hmac_ids[i])); 1420 } 1421 } 1422 } else if (ptype == SCTP_CHUNK_LIST) { 1423 int i; 1424 1425 if (plen > sizeof(chunks_store)) 1426 break; 1427 phdr = sctp_get_next_param(m, offset, 1428 (struct sctp_paramhdr *)chunks_store, plen); 1429 if (phdr == NULL) 1430 return; 1431 chunks = (struct sctp_auth_chunk_list *)phdr; 1432 num_chunks = plen - sizeof(*chunks); 1433 /* save chunks list and num for the key */ 1434 if (stcb->asoc.local_auth_chunks != NULL) 1435 sctp_clear_chunklist(stcb->asoc.local_auth_chunks); 1436 else 1437 stcb->asoc.local_auth_chunks = sctp_alloc_chunklist(); 1438 for (i = 0; i < num_chunks; i++) { 1439 (void)sctp_auth_add_chunk(chunks->chunk_types[i], 1440 stcb->asoc.local_auth_chunks); 1441 } 1442 } 1443 /* get next parameter */ 1444 offset += SCTP_SIZE32(plen); 1445 if (offset + sizeof(struct sctp_paramhdr) > length) 1446 break; 1447 phdr = (struct sctp_paramhdr *)sctp_m_getptr(m, offset, sizeof(struct sctp_paramhdr), 1448 (uint8_t *)&tmp_param); 1449 } 1450 /* concatenate the full random key */ 1451 keylen = sizeof(*p_random) + random_len + sizeof(*hmacs) + hmacs_len; 1452 if (chunks != NULL) { 1453 keylen += sizeof(*chunks) + num_chunks; 1454 } 1455 new_key = sctp_alloc_key(keylen); 1456 if (new_key != NULL) { 1457 /* copy in the RANDOM */ 1458 if (p_random != NULL) { 1459 keylen = sizeof(*p_random) + random_len; 1460 memcpy(new_key->key, p_random, keylen); 1461 } else { 1462 keylen = 0; 1463 } 1464 /* append in the AUTH chunks */ 1465 if (chunks != NULL) { 1466 memcpy(new_key->key + keylen, chunks, 1467 sizeof(*chunks) + num_chunks); 1468 keylen += sizeof(*chunks) + num_chunks; 1469 } 1470 /* append in the HMACs */ 1471 if (hmacs != NULL) { 1472 memcpy(new_key->key + keylen, hmacs, 1473 sizeof(*hmacs) + hmacs_len); 1474 } 1475 } 1476 if (stcb->asoc.authinfo.random != NULL) 1477 sctp_free_key(stcb->asoc.authinfo.random); 1478 stcb->asoc.authinfo.random = new_key; 1479 stcb->asoc.authinfo.random_len = random_len; 1480 sctp_clear_cachedkeys(stcb, stcb->asoc.authinfo.assoc_keyid); 1481 sctp_clear_cachedkeys(stcb, stcb->asoc.authinfo.recv_keyid); 1482 1483 /* negotiate what HMAC to use for the peer */ 1484 stcb->asoc.peer_hmac_id = sctp_negotiate_hmacid(stcb->asoc.peer_hmacs, 1485 stcb->asoc.local_hmacs); 1486 1487 /* copy defaults from the endpoint */ 1488 /* FIX ME: put in cookie? */ 1489 stcb->asoc.authinfo.active_keyid = stcb->sctp_ep->sctp_ep.default_keyid; 1490 /* copy out the shared key list (by reference) from the endpoint */ 1491 (void)sctp_copy_skeylist(&stcb->sctp_ep->sctp_ep.shared_keys, 1492 &stcb->asoc.shared_keys); 1493} 1494 1495/* 1496 * compute and fill in the HMAC digest for a packet 1497 */ 1498void 1499sctp_fill_hmac_digest_m(struct mbuf *m, uint32_t auth_offset, 1500 struct sctp_auth_chunk *auth, struct sctp_tcb *stcb, uint16_t keyid) 1501{ 1502 uint32_t digestlen; 1503 sctp_sharedkey_t *skey; 1504 sctp_key_t *key; 1505 1506 if ((stcb == NULL) || (auth == NULL)) 1507 return; 1508 1509 /* zero the digest + chunk padding */ 1510 digestlen = sctp_get_hmac_digest_len(stcb->asoc.peer_hmac_id); 1511 memset(auth->hmac, 0, SCTP_SIZE32(digestlen)); 1512 1513 /* is the desired key cached? */ 1514 if ((keyid != stcb->asoc.authinfo.assoc_keyid) || 1515 (stcb->asoc.authinfo.assoc_key == NULL)) { 1516 if (stcb->asoc.authinfo.assoc_key != NULL) { 1517 /* free the old cached key */ 1518 sctp_free_key(stcb->asoc.authinfo.assoc_key); 1519 } 1520 skey = sctp_find_sharedkey(&stcb->asoc.shared_keys, keyid); 1521 /* the only way skey is NULL is if null key id 0 is used */ 1522 if (skey != NULL) 1523 key = skey->key; 1524 else 1525 key = NULL; 1526 /* compute a new assoc key and cache it */ 1527 stcb->asoc.authinfo.assoc_key = 1528 sctp_compute_hashkey(stcb->asoc.authinfo.random, 1529 stcb->asoc.authinfo.peer_random, key); 1530 stcb->asoc.authinfo.assoc_keyid = keyid; 1531 SCTPDBG(SCTP_DEBUG_AUTH1, "caching key id %u\n", 1532 stcb->asoc.authinfo.assoc_keyid); 1533#ifdef SCTP_DEBUG 1534 if (SCTP_AUTH_DEBUG) 1535 sctp_print_key(stcb->asoc.authinfo.assoc_key, 1536 "Assoc Key"); 1537#endif 1538 } 1539 1540 /* set in the active key id */ 1541 auth->shared_key_id = htons(keyid); 1542 1543 /* compute and fill in the digest */ 1544 (void)sctp_compute_hmac_m(stcb->asoc.peer_hmac_id, stcb->asoc.authinfo.assoc_key, 1545 m, auth_offset, auth->hmac); 1546} 1547 1548static void 1549sctp_zero_m(struct mbuf *m, uint32_t m_offset, uint32_t size) 1550{ 1551 struct mbuf *m_tmp; 1552 uint8_t *data; 1553 1554 /* sanity check */ 1555 if (m == NULL) 1556 return; 1557 1558 /* find the correct starting mbuf and offset (get start position) */ 1559 m_tmp = m; 1560 while ((m_tmp != NULL) && (m_offset >= (uint32_t)SCTP_BUF_LEN(m_tmp))) { 1561 m_offset -= SCTP_BUF_LEN(m_tmp); 1562 m_tmp = SCTP_BUF_NEXT(m_tmp); 1563 } 1564 /* now use the rest of the mbuf chain */ 1565 while ((m_tmp != NULL) && (size > 0)) { 1566 data = mtod(m_tmp, uint8_t *)+m_offset; 1567 if (size > (uint32_t)(SCTP_BUF_LEN(m_tmp) - m_offset)) { 1568 memset(data, 0, SCTP_BUF_LEN(m_tmp) - m_offset); 1569 size -= SCTP_BUF_LEN(m_tmp) - m_offset; 1570 } else { 1571 memset(data, 0, size); 1572 size = 0; 1573 } 1574 /* clear the offset since it's only for the first mbuf */ 1575 m_offset = 0; 1576 m_tmp = SCTP_BUF_NEXT(m_tmp); 1577 } 1578} 1579 1580/*- 1581 * process the incoming Authentication chunk 1582 * return codes: 1583 * -1 on any authentication error 1584 * 0 on authentication verification 1585 */ 1586int 1587sctp_handle_auth(struct sctp_tcb *stcb, struct sctp_auth_chunk *auth, 1588 struct mbuf *m, uint32_t offset) 1589{ 1590 uint16_t chunklen; 1591 uint16_t shared_key_id; 1592 uint16_t hmac_id; 1593 sctp_sharedkey_t *skey; 1594 uint32_t digestlen; 1595 uint8_t digest[SCTP_AUTH_DIGEST_LEN_MAX]; 1596 uint8_t computed_digest[SCTP_AUTH_DIGEST_LEN_MAX]; 1597 1598 /* auth is checked for NULL by caller */ 1599 chunklen = ntohs(auth->ch.chunk_length); 1600 if (chunklen < sizeof(*auth)) { 1601 SCTP_STAT_INCR(sctps_recvauthfailed); 1602 return (-1); 1603 } 1604 SCTP_STAT_INCR(sctps_recvauth); 1605 1606 /* get the auth params */ 1607 shared_key_id = ntohs(auth->shared_key_id); 1608 hmac_id = ntohs(auth->hmac_id); 1609 SCTPDBG(SCTP_DEBUG_AUTH1, 1610 "SCTP AUTH Chunk: shared key %u, HMAC id %u\n", 1611 shared_key_id, hmac_id); 1612 1613 /* is the indicated HMAC supported? */ 1614 if (!sctp_auth_is_supported_hmac(stcb->asoc.local_hmacs, hmac_id)) { 1615 struct mbuf *op_err; 1616 struct sctp_error_auth_invalid_hmac *cause; 1617 1618 SCTP_STAT_INCR(sctps_recvivalhmacid); 1619 SCTPDBG(SCTP_DEBUG_AUTH1, 1620 "SCTP Auth: unsupported HMAC id %u\n", 1621 hmac_id); 1622 /* 1623 * report this in an Error Chunk: Unsupported HMAC 1624 * Identifier 1625 */ 1626 op_err = sctp_get_mbuf_for_msg(sizeof(struct sctp_error_auth_invalid_hmac), 1627 0, M_NOWAIT, 1, MT_HEADER); 1628 if (op_err != NULL) { 1629 /* pre-reserve some space */ 1630 SCTP_BUF_RESV_UF(op_err, sizeof(struct sctp_chunkhdr)); 1631 /* fill in the error */ 1632 cause = mtod(op_err, struct sctp_error_auth_invalid_hmac *); 1633 cause->cause.code = htons(SCTP_CAUSE_UNSUPPORTED_HMACID); 1634 cause->cause.length = htons(sizeof(struct sctp_error_auth_invalid_hmac)); 1635 cause->hmac_id = ntohs(hmac_id); 1636 SCTP_BUF_LEN(op_err) = sizeof(struct sctp_error_auth_invalid_hmac); 1637 /* queue it */ 1638 sctp_queue_op_err(stcb, op_err); 1639 } 1640 return (-1); 1641 } 1642 /* get the indicated shared key, if available */ 1643 if ((stcb->asoc.authinfo.recv_key == NULL) || 1644 (stcb->asoc.authinfo.recv_keyid != shared_key_id)) { 1645 /* find the shared key on the assoc first */ 1646 skey = sctp_find_sharedkey(&stcb->asoc.shared_keys, 1647 shared_key_id); 1648 /* if the shared key isn't found, discard the chunk */ 1649 if (skey == NULL) { 1650 SCTP_STAT_INCR(sctps_recvivalkeyid); 1651 SCTPDBG(SCTP_DEBUG_AUTH1, 1652 "SCTP Auth: unknown key id %u\n", 1653 shared_key_id); 1654 return (-1); 1655 } 1656 /* generate a notification if this is a new key id */ 1657 if (stcb->asoc.authinfo.recv_keyid != shared_key_id) { 1658 sctp_ulp_notify(SCTP_NOTIFY_AUTH_NEW_KEY, stcb, 0, 1659 &shared_key_id, SCTP_SO_NOT_LOCKED); 1660 } 1661 /* compute a new recv assoc key and cache it */ 1662 if (stcb->asoc.authinfo.recv_key != NULL) 1663 sctp_free_key(stcb->asoc.authinfo.recv_key); 1664 stcb->asoc.authinfo.recv_key = 1665 sctp_compute_hashkey(stcb->asoc.authinfo.random, 1666 stcb->asoc.authinfo.peer_random, skey->key); 1667 stcb->asoc.authinfo.recv_keyid = shared_key_id; 1668#ifdef SCTP_DEBUG 1669 if (SCTP_AUTH_DEBUG) 1670 sctp_print_key(stcb->asoc.authinfo.recv_key, "Recv Key"); 1671#endif 1672 } 1673 /* validate the digest length */ 1674 digestlen = sctp_get_hmac_digest_len(hmac_id); 1675 if (chunklen < (sizeof(*auth) + digestlen)) { 1676 /* invalid digest length */ 1677 SCTP_STAT_INCR(sctps_recvauthfailed); 1678 SCTPDBG(SCTP_DEBUG_AUTH1, 1679 "SCTP Auth: chunk too short for HMAC\n"); 1680 return (-1); 1681 } 1682 /* save a copy of the digest, zero the pseudo header, and validate */ 1683 memcpy(digest, auth->hmac, digestlen); 1684 sctp_zero_m(m, offset + sizeof(*auth), SCTP_SIZE32(digestlen)); 1685 (void)sctp_compute_hmac_m(hmac_id, stcb->asoc.authinfo.recv_key, 1686 m, offset, computed_digest); 1687 1688 /* compare the computed digest with the one in the AUTH chunk */ 1689 if (timingsafe_bcmp(digest, computed_digest, digestlen) != 0) { 1690 SCTP_STAT_INCR(sctps_recvauthfailed); 1691 SCTPDBG(SCTP_DEBUG_AUTH1, 1692 "SCTP Auth: HMAC digest check failed\n"); 1693 return (-1); 1694 } 1695 return (0); 1696} 1697 1698/* 1699 * Generate NOTIFICATION 1700 */ 1701void 1702sctp_notify_authentication(struct sctp_tcb *stcb, uint32_t indication, 1703 uint16_t keyid, int so_locked) 1704{ 1705 struct mbuf *m_notify; 1706 struct sctp_authkey_event *auth; 1707 struct sctp_queued_to_read *control; 1708 1709 KASSERT(stcb != NULL, ("stcb == NULL")); 1710 SCTP_TCB_LOCK_ASSERT(stcb); 1711 SCTP_INP_READ_LOCK_ASSERT(stcb->sctp_ep); 1712 1713 if (sctp_stcb_is_feature_off(stcb->sctp_ep, stcb, SCTP_PCB_FLAGS_AUTHEVNT)) 1714 /* event not enabled */ 1715 return; 1716 1717 m_notify = sctp_get_mbuf_for_msg(sizeof(struct sctp_authkey_event), 1718 0, M_NOWAIT, 1, MT_HEADER); 1719 if (m_notify == NULL) 1720 /* no space left */ 1721 return; 1722 1723 SCTP_BUF_LEN(m_notify) = 0; 1724 auth = mtod(m_notify, struct sctp_authkey_event *); 1725 memset(auth, 0, sizeof(struct sctp_authkey_event)); 1726 auth->auth_type = SCTP_AUTHENTICATION_EVENT; 1727 auth->auth_flags = 0; 1728 auth->auth_length = sizeof(*auth); 1729 auth->auth_keynumber = keyid; 1730 /* XXXMT: The following is BSD specific. */ 1731 if (indication == SCTP_AUTH_NEW_KEY) { 1732 auth->auth_altkeynumber = stcb->asoc.authinfo.recv_keyid; 1733 } else { 1734 auth->auth_altkeynumber = 0; 1735 } 1736 auth->auth_indication = indication; 1737 auth->auth_assoc_id = sctp_get_associd(stcb); 1738 1739 SCTP_BUF_LEN(m_notify) = sizeof(*auth); 1740 SCTP_BUF_NEXT(m_notify) = NULL; 1741 1742 /* append to socket */ 1743 control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination, 1744 0, 0, stcb->asoc.context, 0, 0, 0, m_notify); 1745 if (control == NULL) { 1746 /* no memory */ 1747 sctp_m_freem(m_notify); 1748 return; 1749 } 1750 control->length = SCTP_BUF_LEN(m_notify); 1751 control->spec_flags = M_NOTIFICATION; 1752 /* not that we need this */ 1753 control->tail_mbuf = m_notify; 1754 sctp_add_to_readq(stcb->sctp_ep, stcb, control, 1755 &stcb->sctp_socket->so_rcv, 1, 1756 SCTP_READ_LOCK_HELD, so_locked); 1757} 1758 1759/*- 1760 * validates the AUTHentication related parameters in an INIT/INIT-ACK 1761 * Note: currently only used for INIT as INIT-ACK is handled inline 1762 * with sctp_load_addresses_from_init() 1763 */ 1764int 1765sctp_validate_init_auth_params(struct mbuf *m, int offset, int limit) 1766{ 1767 struct sctp_paramhdr *phdr, param_buf; 1768 uint16_t ptype, plen; 1769 int peer_supports_asconf = 0; 1770 int peer_supports_auth = 0; 1771 int got_random = 0, got_hmacs = 0, got_chklist = 0; 1772 uint8_t saw_asconf = 0; 1773 uint8_t saw_asconf_ack = 0; 1774 1775 /* go through each of the params. */ 1776 phdr = sctp_get_next_param(m, offset, ¶m_buf, sizeof(param_buf)); 1777 while (phdr) { 1778 ptype = ntohs(phdr->param_type); 1779 plen = ntohs(phdr->param_length); 1780 1781 if (offset + plen > limit) { 1782 break; 1783 } 1784 if (plen < sizeof(struct sctp_paramhdr)) { 1785 break; 1786 } 1787 if (ptype == SCTP_SUPPORTED_CHUNK_EXT) { 1788 /* A supported extension chunk */ 1789 struct sctp_supported_chunk_types_param *pr_supported; 1790 uint8_t local_store[SCTP_SMALL_CHUNK_STORE]; 1791 int num_ent, i; 1792 1793 if (plen > sizeof(local_store)) { 1794 break; 1795 } 1796 phdr = sctp_get_next_param(m, offset, 1797 (struct sctp_paramhdr *)&local_store, 1798 plen); 1799 if (phdr == NULL) { 1800 return (-1); 1801 } 1802 pr_supported = (struct sctp_supported_chunk_types_param *)phdr; 1803 num_ent = plen - sizeof(struct sctp_paramhdr); 1804 for (i = 0; i < num_ent; i++) { 1805 switch (pr_supported->chunk_types[i]) { 1806 case SCTP_ASCONF: 1807 case SCTP_ASCONF_ACK: 1808 peer_supports_asconf = 1; 1809 break; 1810 default: 1811 /* one we don't care about */ 1812 break; 1813 } 1814 } 1815 } else if (ptype == SCTP_RANDOM) { 1816 /* enforce the random length */ 1817 if (plen != (sizeof(struct sctp_auth_random) + 1818 SCTP_AUTH_RANDOM_SIZE_REQUIRED)) { 1819 SCTPDBG(SCTP_DEBUG_AUTH1, 1820 "SCTP: invalid RANDOM len\n"); 1821 return (-1); 1822 } 1823 got_random = 1; 1824 } else if (ptype == SCTP_HMAC_LIST) { 1825 struct sctp_auth_hmac_algo *hmacs; 1826 uint8_t store[SCTP_PARAM_BUFFER_SIZE]; 1827 int num_hmacs; 1828 1829 if (plen > sizeof(store)) { 1830 break; 1831 } 1832 phdr = sctp_get_next_param(m, offset, 1833 (struct sctp_paramhdr *)store, 1834 plen); 1835 if (phdr == NULL) { 1836 return (-1); 1837 } 1838 hmacs = (struct sctp_auth_hmac_algo *)phdr; 1839 num_hmacs = (plen - sizeof(*hmacs)) / sizeof(hmacs->hmac_ids[0]); 1840 /* validate the hmac list */ 1841 if (sctp_verify_hmac_param(hmacs, num_hmacs)) { 1842 SCTPDBG(SCTP_DEBUG_AUTH1, 1843 "SCTP: invalid HMAC param\n"); 1844 return (-1); 1845 } 1846 got_hmacs = 1; 1847 } else if (ptype == SCTP_CHUNK_LIST) { 1848 struct sctp_auth_chunk_list *chunks; 1849 uint8_t chunks_store[SCTP_SMALL_CHUNK_STORE]; 1850 int i, num_chunks; 1851 1852 if (plen > sizeof(chunks_store)) { 1853 break; 1854 } 1855 phdr = sctp_get_next_param(m, offset, 1856 (struct sctp_paramhdr *)chunks_store, 1857 plen); 1858 if (phdr == NULL) { 1859 return (-1); 1860 } 1861 /*- 1862 * Flip through the list and mark that the 1863 * peer supports asconf/asconf_ack. 1864 */ 1865 chunks = (struct sctp_auth_chunk_list *)phdr; 1866 num_chunks = plen - sizeof(*chunks); 1867 for (i = 0; i < num_chunks; i++) { 1868 /* record asconf/asconf-ack if listed */ 1869 if (chunks->chunk_types[i] == SCTP_ASCONF) 1870 saw_asconf = 1; 1871 if (chunks->chunk_types[i] == SCTP_ASCONF_ACK) 1872 saw_asconf_ack = 1; 1873 } 1874 if (num_chunks) 1875 got_chklist = 1; 1876 } 1877 1878 offset += SCTP_SIZE32(plen); 1879 if (offset >= limit) { 1880 break; 1881 } 1882 phdr = sctp_get_next_param(m, offset, ¶m_buf, 1883 sizeof(param_buf)); 1884 } 1885 /* validate authentication required parameters */ 1886 if (got_random && got_hmacs) { 1887 peer_supports_auth = 1; 1888 } else { 1889 peer_supports_auth = 0; 1890 } 1891 if (!peer_supports_auth && got_chklist) { 1892 SCTPDBG(SCTP_DEBUG_AUTH1, 1893 "SCTP: peer sent chunk list w/o AUTH\n"); 1894 return (-1); 1895 } 1896 if (peer_supports_asconf && !peer_supports_auth) { 1897 SCTPDBG(SCTP_DEBUG_AUTH1, 1898 "SCTP: peer supports ASCONF but not AUTH\n"); 1899 return (-1); 1900 } else if ((peer_supports_asconf) && (peer_supports_auth) && 1901 ((saw_asconf == 0) || (saw_asconf_ack == 0))) { 1902 return (-2); 1903 } 1904 return (0); 1905} 1906 1907void 1908sctp_initialize_auth_params(struct sctp_inpcb *inp, struct sctp_tcb *stcb) 1909{ 1910 uint16_t chunks_len = 0; 1911 uint16_t hmacs_len = 0; 1912 uint16_t random_len = SCTP_AUTH_RANDOM_SIZE_DEFAULT; 1913 sctp_key_t *new_key; 1914 uint16_t keylen; 1915 1916 /* initialize hmac list from endpoint */ 1917 stcb->asoc.local_hmacs = sctp_copy_hmaclist(inp->sctp_ep.local_hmacs); 1918 if (stcb->asoc.local_hmacs != NULL) { 1919 hmacs_len = stcb->asoc.local_hmacs->num_algo * 1920 sizeof(stcb->asoc.local_hmacs->hmac[0]); 1921 } 1922 /* initialize auth chunks list from endpoint */ 1923 stcb->asoc.local_auth_chunks = 1924 sctp_copy_chunklist(inp->sctp_ep.local_auth_chunks); 1925 if (stcb->asoc.local_auth_chunks != NULL) { 1926 int i; 1927 1928 for (i = 0; i < 256; i++) { 1929 if (stcb->asoc.local_auth_chunks->chunks[i]) 1930 chunks_len++; 1931 } 1932 } 1933 /* copy defaults from the endpoint */ 1934 stcb->asoc.authinfo.active_keyid = inp->sctp_ep.default_keyid; 1935 1936 /* copy out the shared key list (by reference) from the endpoint */ 1937 (void)sctp_copy_skeylist(&inp->sctp_ep.shared_keys, 1938 &stcb->asoc.shared_keys); 1939 1940 /* now set the concatenated key (random + chunks + hmacs) */ 1941 /* key includes parameter headers */ 1942 keylen = (3 * sizeof(struct sctp_paramhdr)) + random_len + chunks_len + 1943 hmacs_len; 1944 new_key = sctp_alloc_key(keylen); 1945 if (new_key != NULL) { 1946 struct sctp_paramhdr *ph; 1947 int plen; 1948 1949 /* generate and copy in the RANDOM */ 1950 ph = (struct sctp_paramhdr *)new_key->key; 1951 ph->param_type = htons(SCTP_RANDOM); 1952 plen = sizeof(*ph) + random_len; 1953 ph->param_length = htons(plen); 1954 SCTP_READ_RANDOM(new_key->key + sizeof(*ph), random_len); 1955 keylen = plen; 1956 1957 /* append in the AUTH chunks */ 1958 /* NOTE: currently we always have chunks to list */ 1959 ph = (struct sctp_paramhdr *)(new_key->key + keylen); 1960 ph->param_type = htons(SCTP_CHUNK_LIST); 1961 plen = sizeof(*ph) + chunks_len; 1962 ph->param_length = htons(plen); 1963 keylen += sizeof(*ph); 1964 if (stcb->asoc.local_auth_chunks) { 1965 int i; 1966 1967 for (i = 0; i < 256; i++) { 1968 if (stcb->asoc.local_auth_chunks->chunks[i]) 1969 new_key->key[keylen++] = i; 1970 } 1971 } 1972 1973 /* append in the HMACs */ 1974 ph = (struct sctp_paramhdr *)(new_key->key + keylen); 1975 ph->param_type = htons(SCTP_HMAC_LIST); 1976 plen = sizeof(*ph) + hmacs_len; 1977 ph->param_length = htons(plen); 1978 keylen += sizeof(*ph); 1979 (void)sctp_serialize_hmaclist(stcb->asoc.local_hmacs, 1980 new_key->key + keylen); 1981 } 1982 if (stcb->asoc.authinfo.random != NULL) 1983 sctp_free_key(stcb->asoc.authinfo.random); 1984 stcb->asoc.authinfo.random = new_key; 1985 stcb->asoc.authinfo.random_len = random_len; 1986} 1987