src/third_party/usrsctp/usrsctplib/netinet/sctp_auth.c

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