1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #pragma ident "%Z%%M% %I% %E% SMI" 27 28 /* 29 * This file is part of the core Kernel Cryptographic Framework. 30 * It implements the management of tables of Providers. Entries to 31 * added and removed when cryptographic providers register with 32 * and unregister from the framework, respectively. The KCF scheduler 33 * and ioctl pseudo driver call this function to obtain the list 34 * of available providers. 35 * 36 * The provider table is indexed by crypto_provider_id_t. Each 37 * element of the table contains a pointer to a provider descriptor, 38 * or NULL if the entry is free. 39 * 40 * This file also implements helper functions to allocate and free 41 * provider descriptors. 42 */ 43 44 #include <sys/types.h> 45 #include <sys/kmem.h> 46 #include <sys/cmn_err.h> 47 #include <sys/ddi.h> 48 #include <sys/sunddi.h> 49 #include <sys/ksynch.h> 50 #include <sys/crypto/common.h> 51 #include <sys/crypto/impl.h> 52 #include <sys/crypto/sched_impl.h> 53 #include <sys/crypto/spi.h> 54 55 #define KCF_MAX_PROVIDERS 512 /* max number of providers */ 56 57 static kmutex_t prov_tab_mutex; /* ensure exclusive access to the table */ 58 static kcf_provider_desc_t **prov_tab = NULL; 59 static uint_t prov_tab_num = 0; /* number of providers in table */ 60 static uint_t prov_tab_max = KCF_MAX_PROVIDERS; 61 62 #if DEBUG 63 extern int kcf_frmwrk_debug; 64 static void kcf_prov_tab_dump(void); 65 #endif /* DEBUG */ 66 67 /* 68 * Initialize the providers table. The providers table is dynamically 69 * allocated with prov_tab_max entries. 70 */ 71 void 72 kcf_prov_tab_init(void) 73 { 74 mutex_init(&prov_tab_mutex, NULL, MUTEX_DRIVER, NULL); 75 76 prov_tab = kmem_zalloc(prov_tab_max * sizeof (kcf_provider_desc_t *), 77 KM_SLEEP); 78 } 79 80 /* 81 * Add a provider to the provider table. If no free entry can be found 82 * for the new provider, returns CRYPTO_HOST_MEMORY. Otherwise, add 83 * the provider to the table, initialize the pd_prov_id field 84 * of the specified provider descriptor to the index in that table, 85 * and return CRYPTO_SUCCESS. Note that a REFHOLD is done on the 86 * provider when pointed to by a table entry. 87 */ 88 int 89 kcf_prov_tab_add_provider(kcf_provider_desc_t *prov_desc) 90 { 91 uint_t i; 92 93 ASSERT(prov_tab != NULL); 94 95 mutex_enter(&prov_tab_mutex); 96 97 /* find free slot in providers table */ 98 for (i = 0; i < KCF_MAX_PROVIDERS && prov_tab[i] != NULL; i++) 99 ; 100 if (i == KCF_MAX_PROVIDERS) { 101 /* ran out of providers entries */ 102 mutex_exit(&prov_tab_mutex); 103 cmn_err(CE_WARN, "out of providers entries"); 104 return (CRYPTO_HOST_MEMORY); 105 } 106 107 /* initialize entry */ 108 prov_tab[i] = prov_desc; 109 KCF_PROV_REFHOLD(prov_desc); 110 KCF_PROV_IREFHOLD(prov_desc); 111 prov_tab_num++; 112 113 mutex_exit(&prov_tab_mutex); 114 115 /* update provider descriptor */ 116 prov_desc->pd_prov_id = i; 117 118 /* 119 * The KCF-private provider handle is defined as the internal 120 * provider id. 121 */ 122 prov_desc->pd_kcf_prov_handle = 123 (crypto_kcf_provider_handle_t)prov_desc->pd_prov_id; 124 125 #if DEBUG 126 if (kcf_frmwrk_debug >= 1) 127 kcf_prov_tab_dump(); 128 #endif /* DEBUG */ 129 130 return (CRYPTO_SUCCESS); 131 } 132 133 /* 134 * Remove the provider specified by its id. A REFRELE is done on the 135 * corresponding provider descriptor before this function returns. 136 * Returns CRYPTO_UNKNOWN_PROVIDER if the provider id is not valid. 137 */ 138 int 139 kcf_prov_tab_rem_provider(crypto_provider_id_t prov_id) 140 { 141 kcf_provider_desc_t *prov_desc; 142 143 ASSERT(prov_tab != NULL); 144 ASSERT(prov_tab_num >= 0); 145 146 /* 147 * Validate provider id, since it can be specified by a 3rd-party 148 * provider. 149 */ 150 151 mutex_enter(&prov_tab_mutex); 152 if (prov_id >= KCF_MAX_PROVIDERS || 153 ((prov_desc = prov_tab[prov_id]) == NULL)) { 154 mutex_exit(&prov_tab_mutex); 155 return (CRYPTO_INVALID_PROVIDER_ID); 156 } 157 mutex_exit(&prov_tab_mutex); 158 159 /* 160 * The provider id must remain valid until the associated provider 161 * descriptor is freed. For this reason, we simply release our 162 * reference to the descriptor here. When the reference count 163 * reaches zero, kcf_free_provider_desc() will be invoked and 164 * the associated entry in the providers table will be released 165 * at that time. 166 */ 167 168 KCF_PROV_REFRELE(prov_desc); 169 KCF_PROV_IREFRELE(prov_desc); 170 171 #if DEBUG 172 if (kcf_frmwrk_debug >= 1) 173 kcf_prov_tab_dump(); 174 #endif /* DEBUG */ 175 176 return (CRYPTO_SUCCESS); 177 } 178 179 /* 180 * Returns the provider descriptor corresponding to the specified 181 * provider id. A REFHOLD is done on the descriptor before it is 182 * returned to the caller. It is the responsibility of the caller 183 * to do a REFRELE once it is done with the provider descriptor. 184 */ 185 kcf_provider_desc_t * 186 kcf_prov_tab_lookup(crypto_provider_id_t prov_id) 187 { 188 kcf_provider_desc_t *prov_desc; 189 190 mutex_enter(&prov_tab_mutex); 191 192 prov_desc = prov_tab[prov_id]; 193 194 if (prov_desc == NULL) { 195 mutex_exit(&prov_tab_mutex); 196 return (NULL); 197 } 198 199 KCF_PROV_REFHOLD(prov_desc); 200 201 mutex_exit(&prov_tab_mutex); 202 203 return (prov_desc); 204 } 205 206 static void 207 allocate_ops_v1(crypto_ops_t *src, crypto_ops_t *dst, uint_t *mech_list_count) 208 { 209 if (src->co_control_ops != NULL) 210 dst->co_control_ops = kmem_alloc(sizeof (crypto_control_ops_t), 211 KM_SLEEP); 212 213 if (src->co_digest_ops != NULL) 214 dst->co_digest_ops = kmem_alloc(sizeof (crypto_digest_ops_t), 215 KM_SLEEP); 216 217 if (src->co_cipher_ops != NULL) 218 dst->co_cipher_ops = kmem_alloc(sizeof (crypto_cipher_ops_t), 219 KM_SLEEP); 220 221 if (src->co_mac_ops != NULL) 222 dst->co_mac_ops = kmem_alloc(sizeof (crypto_mac_ops_t), 223 KM_SLEEP); 224 225 if (src->co_sign_ops != NULL) 226 dst->co_sign_ops = kmem_alloc(sizeof (crypto_sign_ops_t), 227 KM_SLEEP); 228 229 if (src->co_verify_ops != NULL) 230 dst->co_verify_ops = kmem_alloc(sizeof (crypto_verify_ops_t), 231 KM_SLEEP); 232 233 if (src->co_dual_ops != NULL) 234 dst->co_dual_ops = kmem_alloc(sizeof (crypto_dual_ops_t), 235 KM_SLEEP); 236 237 if (src->co_dual_cipher_mac_ops != NULL) 238 dst->co_dual_cipher_mac_ops = kmem_alloc( 239 sizeof (crypto_dual_cipher_mac_ops_t), KM_SLEEP); 240 241 if (src->co_random_ops != NULL) { 242 dst->co_random_ops = kmem_alloc( 243 sizeof (crypto_random_number_ops_t), KM_SLEEP); 244 245 /* 246 * Allocate storage to store the array of supported mechanisms 247 * specified by provider. We allocate extra mechanism storage 248 * if the provider has random_ops since we keep an internal 249 * mechanism, SUN_RANDOM, in this case. 250 */ 251 (*mech_list_count)++; 252 } 253 254 if (src->co_session_ops != NULL) 255 dst->co_session_ops = kmem_alloc(sizeof (crypto_session_ops_t), 256 KM_SLEEP); 257 258 if (src->co_object_ops != NULL) 259 dst->co_object_ops = kmem_alloc(sizeof (crypto_object_ops_t), 260 KM_SLEEP); 261 262 if (src->co_key_ops != NULL) 263 dst->co_key_ops = kmem_alloc(sizeof (crypto_key_ops_t), 264 KM_SLEEP); 265 266 if (src->co_provider_ops != NULL) 267 dst->co_provider_ops = kmem_alloc( 268 sizeof (crypto_provider_management_ops_t), KM_SLEEP); 269 270 if (src->co_ctx_ops != NULL) 271 dst->co_ctx_ops = kmem_alloc(sizeof (crypto_ctx_ops_t), 272 KM_SLEEP); 273 } 274 275 static void 276 allocate_ops_v2(crypto_ops_t *src, crypto_ops_t *dst) 277 { 278 if (src->co_mech_ops != NULL) 279 dst->co_mech_ops = kmem_alloc(sizeof (crypto_mech_ops_t), 280 KM_SLEEP); 281 } 282 283 static void 284 allocate_ops_v3(crypto_ops_t *src, crypto_ops_t *dst) 285 { 286 if (src->co_nostore_key_ops != NULL) 287 dst->co_nostore_key_ops = 288 kmem_alloc(sizeof (crypto_nostore_key_ops_t), KM_SLEEP); 289 } 290 291 /* 292 * Allocate a provider descriptor. mech_list_count specifies the 293 * number of mechanisms supported by the providers, and is used 294 * to allocate storage for the mechanism table. 295 * This function may sleep while allocating memory, which is OK 296 * since it is invoked from user context during provider registration. 297 */ 298 kcf_provider_desc_t * 299 kcf_alloc_provider_desc(crypto_provider_info_t *info) 300 { 301 int i, j; 302 kcf_provider_desc_t *desc; 303 uint_t mech_list_count = info->pi_mech_list_count; 304 crypto_ops_t *src_ops = info->pi_ops_vector; 305 306 desc = kmem_zalloc(sizeof (kcf_provider_desc_t), KM_SLEEP); 307 308 /* 309 * pd_description serves two purposes 310 * - Appears as a blank padded PKCS#11 style string, that will be 311 * returned to applications in CK_SLOT_INFO.slotDescription. 312 * This means that we should not have a null character in the 313 * first CRYPTO_PROVIDER_DESCR_MAX_LEN bytes. 314 * - Appears as a null-terminated string that can be used by 315 * other kcf routines. 316 * 317 * So, we allocate enough room for one extra null terminator 318 * which keeps every one happy. 319 */ 320 desc->pd_description = kmem_alloc(CRYPTO_PROVIDER_DESCR_MAX_LEN + 1, 321 KM_SLEEP); 322 (void) memset(desc->pd_description, ' ', 323 CRYPTO_PROVIDER_DESCR_MAX_LEN); 324 desc->pd_description[CRYPTO_PROVIDER_DESCR_MAX_LEN] = '\0'; 325 326 /* 327 * Since the framework does not require the ops vector specified 328 * by the providers during registration to be persistent, 329 * KCF needs to allocate storage where copies of the ops 330 * vectors are copied. 331 */ 332 desc->pd_ops_vector = kmem_zalloc(sizeof (crypto_ops_t), KM_SLEEP); 333 334 if (info->pi_provider_type != CRYPTO_LOGICAL_PROVIDER) { 335 allocate_ops_v1(src_ops, desc->pd_ops_vector, &mech_list_count); 336 if (info->pi_interface_version >= CRYPTO_SPI_VERSION_2) 337 allocate_ops_v2(src_ops, desc->pd_ops_vector); 338 if (info->pi_interface_version == CRYPTO_SPI_VERSION_3) 339 allocate_ops_v3(src_ops, desc->pd_ops_vector); 340 } 341 342 desc->pd_mech_list_count = mech_list_count; 343 desc->pd_mechanisms = kmem_zalloc(sizeof (crypto_mech_info_t) * 344 mech_list_count, KM_SLEEP); 345 for (i = 0; i < KCF_OPS_CLASSSIZE; i++) 346 for (j = 0; j < KCF_MAXMECHTAB; j++) 347 desc->pd_mech_indx[i][j] = KCF_INVALID_INDX; 348 349 desc->pd_prov_id = KCF_PROVID_INVALID; 350 desc->pd_state = KCF_PROV_ALLOCATED; 351 352 mutex_init(&desc->pd_lock, NULL, MUTEX_DEFAULT, NULL); 353 cv_init(&desc->pd_resume_cv, NULL, CV_DEFAULT, NULL); 354 cv_init(&desc->pd_remove_cv, NULL, CV_DEFAULT, NULL); 355 356 return (desc); 357 } 358 359 /* 360 * Called by KCF_PROV_REFRELE when a provider's reference count drops 361 * to zero. We free the descriptor when the last reference is released. 362 * However, for software providers, we do not free it when there is an 363 * unregister thread waiting. We signal that thread in this case and 364 * that thread is responsible for freeing the descriptor. 365 */ 366 void 367 kcf_provider_zero_refcnt(kcf_provider_desc_t *desc) 368 { 369 mutex_enter(&desc->pd_lock); 370 switch (desc->pd_prov_type) { 371 case CRYPTO_SW_PROVIDER: 372 if (desc->pd_state == KCF_PROV_REMOVED || 373 desc->pd_state == KCF_PROV_DISABLED) { 374 desc->pd_state = KCF_PROV_FREED; 375 cv_broadcast(&desc->pd_remove_cv); 376 mutex_exit(&desc->pd_lock); 377 break; 378 } 379 /* FALLTHRU */ 380 381 case CRYPTO_HW_PROVIDER: 382 case CRYPTO_LOGICAL_PROVIDER: 383 mutex_exit(&desc->pd_lock); 384 kcf_free_provider_desc(desc); 385 } 386 } 387 388 /* 389 * Free a provider descriptor. 390 */ 391 void 392 kcf_free_provider_desc(kcf_provider_desc_t *desc) 393 { 394 if (desc == NULL) 395 return; 396 397 mutex_enter(&prov_tab_mutex); 398 if (desc->pd_prov_id != KCF_PROVID_INVALID) { 399 /* release the associated providers table entry */ 400 ASSERT(prov_tab[desc->pd_prov_id] != NULL); 401 prov_tab[desc->pd_prov_id] = NULL; 402 prov_tab_num--; 403 } 404 mutex_exit(&prov_tab_mutex); 405 406 /* free the kernel memory associated with the provider descriptor */ 407 408 if (desc->pd_description != NULL) 409 kmem_free(desc->pd_description, 410 CRYPTO_PROVIDER_DESCR_MAX_LEN + 1); 411 412 if (desc->pd_ops_vector != NULL) { 413 414 if (desc->pd_ops_vector->co_control_ops != NULL) 415 kmem_free(desc->pd_ops_vector->co_control_ops, 416 sizeof (crypto_control_ops_t)); 417 418 if (desc->pd_ops_vector->co_digest_ops != NULL) 419 kmem_free(desc->pd_ops_vector->co_digest_ops, 420 sizeof (crypto_digest_ops_t)); 421 422 if (desc->pd_ops_vector->co_cipher_ops != NULL) 423 kmem_free(desc->pd_ops_vector->co_cipher_ops, 424 sizeof (crypto_cipher_ops_t)); 425 426 if (desc->pd_ops_vector->co_mac_ops != NULL) 427 kmem_free(desc->pd_ops_vector->co_mac_ops, 428 sizeof (crypto_mac_ops_t)); 429 430 if (desc->pd_ops_vector->co_sign_ops != NULL) 431 kmem_free(desc->pd_ops_vector->co_sign_ops, 432 sizeof (crypto_sign_ops_t)); 433 434 if (desc->pd_ops_vector->co_verify_ops != NULL) 435 kmem_free(desc->pd_ops_vector->co_verify_ops, 436 sizeof (crypto_verify_ops_t)); 437 438 if (desc->pd_ops_vector->co_dual_ops != NULL) 439 kmem_free(desc->pd_ops_vector->co_dual_ops, 440 sizeof (crypto_dual_ops_t)); 441 442 if (desc->pd_ops_vector->co_dual_cipher_mac_ops != NULL) 443 kmem_free(desc->pd_ops_vector->co_dual_cipher_mac_ops, 444 sizeof (crypto_dual_cipher_mac_ops_t)); 445 446 if (desc->pd_ops_vector->co_random_ops != NULL) 447 kmem_free(desc->pd_ops_vector->co_random_ops, 448 sizeof (crypto_random_number_ops_t)); 449 450 if (desc->pd_ops_vector->co_session_ops != NULL) 451 kmem_free(desc->pd_ops_vector->co_session_ops, 452 sizeof (crypto_session_ops_t)); 453 454 if (desc->pd_ops_vector->co_object_ops != NULL) 455 kmem_free(desc->pd_ops_vector->co_object_ops, 456 sizeof (crypto_object_ops_t)); 457 458 if (desc->pd_ops_vector->co_key_ops != NULL) 459 kmem_free(desc->pd_ops_vector->co_key_ops, 460 sizeof (crypto_key_ops_t)); 461 462 if (desc->pd_ops_vector->co_provider_ops != NULL) 463 kmem_free(desc->pd_ops_vector->co_provider_ops, 464 sizeof (crypto_provider_management_ops_t)); 465 466 if (desc->pd_ops_vector->co_ctx_ops != NULL) 467 kmem_free(desc->pd_ops_vector->co_ctx_ops, 468 sizeof (crypto_ctx_ops_t)); 469 470 if (desc->pd_ops_vector->co_mech_ops != NULL) 471 kmem_free(desc->pd_ops_vector->co_mech_ops, 472 sizeof (crypto_mech_ops_t)); 473 474 if (desc->pd_ops_vector->co_nostore_key_ops != NULL) 475 kmem_free(desc->pd_ops_vector->co_nostore_key_ops, 476 sizeof (crypto_nostore_key_ops_t)); 477 478 kmem_free(desc->pd_ops_vector, sizeof (crypto_ops_t)); 479 } 480 481 if (desc->pd_mechanisms != NULL) 482 /* free the memory associated with the mechanism info's */ 483 kmem_free(desc->pd_mechanisms, sizeof (crypto_mech_info_t) * 484 desc->pd_mech_list_count); 485 486 if (desc->pd_name != NULL) { 487 kmem_free(desc->pd_name, strlen(desc->pd_name) + 1); 488 } 489 490 if (desc->pd_sched_info.ks_taskq != NULL) 491 taskq_destroy(desc->pd_sched_info.ks_taskq); 492 493 kmem_free(desc, sizeof (kcf_provider_desc_t)); 494 } 495 496 /* 497 * Returns the provider descriptor corresponding to the specified 498 * module name. A REFHOLD is done on the descriptor before it is 499 * returned to the caller. It is the responsibility of the caller 500 * to do a REFRELE once it is done with the provider descriptor. 501 * Only software providers are returned by this function. 502 */ 503 kcf_provider_desc_t * 504 kcf_prov_tab_lookup_by_name(char *module_name) 505 { 506 kcf_provider_desc_t *prov_desc; 507 uint_t i; 508 509 mutex_enter(&prov_tab_mutex); 510 511 for (i = 0; i < KCF_MAX_PROVIDERS; i++) { 512 if ((prov_desc = prov_tab[i]) != NULL && 513 (!KCF_IS_PROV_REMOVED(prov_desc)) && 514 prov_desc->pd_prov_type == CRYPTO_SW_PROVIDER) { 515 ASSERT(prov_desc->pd_name != NULL); 516 if (strncmp(module_name, prov_desc->pd_name, 517 MAXNAMELEN) == 0) { 518 KCF_PROV_REFHOLD(prov_desc); 519 mutex_exit(&prov_tab_mutex); 520 return (prov_desc); 521 } 522 } 523 } 524 525 mutex_exit(&prov_tab_mutex); 526 return (NULL); 527 } 528 529 /* 530 * Returns the provider descriptor corresponding to the specified 531 * device name and instance. A REFHOLD is done on the descriptor 532 * before it is returned to the caller. It is the responsibility 533 * of the caller to do a REFRELE once it is done with the provider 534 * descriptor. Only hardware providers are returned by this function. 535 */ 536 kcf_provider_desc_t * 537 kcf_prov_tab_lookup_by_dev(char *name, uint_t instance) 538 { 539 kcf_provider_desc_t *prov_desc; 540 uint_t i; 541 542 mutex_enter(&prov_tab_mutex); 543 544 for (i = 0; i < KCF_MAX_PROVIDERS; i++) { 545 if ((prov_desc = prov_tab[i]) != NULL && 546 (!KCF_IS_PROV_REMOVED(prov_desc)) && 547 prov_desc->pd_prov_type == CRYPTO_HW_PROVIDER) { 548 ASSERT(prov_desc->pd_name != NULL); 549 if (strncmp(prov_desc->pd_name, name, 550 MAXNAMELEN) == 0 && 551 prov_desc->pd_instance == instance) { 552 KCF_PROV_REFHOLD(prov_desc); 553 mutex_exit(&prov_tab_mutex); 554 return (prov_desc); 555 } 556 } 557 } 558 559 mutex_exit(&prov_tab_mutex); 560 return (NULL); 561 } 562 563 /* 564 * Returns an array of hardware and logical provider descriptors, 565 * a.k.a the PKCS#11 slot list. A REFHOLD is done on each descriptor 566 * before the array is returned. The entire table can be freed by 567 * calling kcf_free_provider_tab(). 568 */ 569 int 570 kcf_get_slot_list(uint_t *count, kcf_provider_desc_t ***array, 571 boolean_t unverified) 572 { 573 kcf_provider_desc_t *prov_desc; 574 kcf_provider_desc_t **p = NULL; 575 char *last; 576 uint_t cnt = 0; 577 uint_t i, j; 578 int rval = CRYPTO_SUCCESS; 579 size_t n, final_size; 580 581 /* count the providers */ 582 mutex_enter(&prov_tab_mutex); 583 for (i = 0; i < KCF_MAX_PROVIDERS; i++) { 584 if ((prov_desc = prov_tab[i]) != NULL && 585 ((prov_desc->pd_prov_type == CRYPTO_HW_PROVIDER && 586 (prov_desc->pd_flags & CRYPTO_HIDE_PROVIDER) == 0) || 587 prov_desc->pd_prov_type == CRYPTO_LOGICAL_PROVIDER)) { 588 if (KCF_IS_PROV_USABLE(prov_desc) || 589 (unverified && KCF_IS_PROV_UNVERIFIED(prov_desc))) { 590 cnt++; 591 } 592 } 593 } 594 mutex_exit(&prov_tab_mutex); 595 596 if (cnt == 0) 597 goto out; 598 599 n = cnt * sizeof (kcf_provider_desc_t *); 600 again: 601 p = kmem_zalloc(n, KM_SLEEP); 602 603 /* pointer to last entry in the array */ 604 last = (char *)&p[cnt-1]; 605 606 mutex_enter(&prov_tab_mutex); 607 /* fill the slot list */ 608 for (i = 0, j = 0; i < KCF_MAX_PROVIDERS; i++) { 609 if ((prov_desc = prov_tab[i]) != NULL && 610 ((prov_desc->pd_prov_type == CRYPTO_HW_PROVIDER && 611 (prov_desc->pd_flags & CRYPTO_HIDE_PROVIDER) == 0) || 612 prov_desc->pd_prov_type == CRYPTO_LOGICAL_PROVIDER)) { 613 if (KCF_IS_PROV_USABLE(prov_desc) || 614 (unverified && KCF_IS_PROV_UNVERIFIED(prov_desc))) { 615 if ((char *)&p[j] > last) { 616 mutex_exit(&prov_tab_mutex); 617 kcf_free_provider_tab(cnt, p); 618 n = n << 1; 619 cnt = cnt << 1; 620 goto again; 621 } 622 p[j++] = prov_desc; 623 KCF_PROV_REFHOLD(prov_desc); 624 } 625 } 626 } 627 mutex_exit(&prov_tab_mutex); 628 629 final_size = j * sizeof (kcf_provider_desc_t *); 630 cnt = j; 631 ASSERT(final_size <= n); 632 633 /* check if buffer we allocated is too large */ 634 if (final_size < n) { 635 char *final_buffer = NULL; 636 637 if (final_size > 0) { 638 final_buffer = kmem_alloc(final_size, KM_SLEEP); 639 bcopy(p, final_buffer, final_size); 640 } 641 kmem_free(p, n); 642 p = (kcf_provider_desc_t **)final_buffer; 643 } 644 out: 645 *count = cnt; 646 *array = p; 647 return (rval); 648 } 649 650 /* 651 * Returns an array of hardware provider descriptors. This routine 652 * used by cryptoadm(1M). A REFHOLD is done on each descriptor before 653 * the array is returned. The entire table can be freed by calling 654 * kcf_free_provider_tab(). 655 * 656 * A NULL name argument puts all hardware providers in the array. 657 * A non-NULL name argument puts only those providers in the array 658 * which match the name and instance arguments. 659 */ 660 int 661 kcf_get_hw_prov_tab(uint_t *count, kcf_provider_desc_t ***array, int kmflag, 662 char *name, uint_t instance, boolean_t unverified) 663 { 664 kcf_provider_desc_t *prov_desc; 665 kcf_provider_desc_t **p = NULL; 666 char *last; 667 uint_t cnt = 0; 668 uint_t i, j; 669 int rval = CRYPTO_SUCCESS; 670 size_t n, final_size; 671 672 /* count the providers */ 673 mutex_enter(&prov_tab_mutex); 674 for (i = 0; i < KCF_MAX_PROVIDERS; i++) { 675 if ((prov_desc = prov_tab[i]) != NULL && 676 prov_desc->pd_prov_type == CRYPTO_HW_PROVIDER) { 677 if (KCF_IS_PROV_USABLE(prov_desc) || 678 (unverified && KCF_IS_PROV_UNVERIFIED(prov_desc))) { 679 if (name == NULL || 680 (strncmp(prov_desc->pd_name, name, 681 MAXNAMELEN) == 0 && 682 prov_desc->pd_instance == instance)) { 683 cnt++; 684 } 685 } 686 } 687 } 688 mutex_exit(&prov_tab_mutex); 689 690 if (cnt == 0) 691 goto out; 692 693 n = cnt * sizeof (kcf_provider_desc_t *); 694 again: 695 p = kmem_zalloc(n, kmflag); 696 if (p == NULL) { 697 rval = CRYPTO_HOST_MEMORY; 698 goto out; 699 } 700 /* pointer to last entry in the array */ 701 last = (char *)&p[cnt-1]; 702 703 mutex_enter(&prov_tab_mutex); 704 for (i = 0, j = 0; i < KCF_MAX_PROVIDERS; i++) { 705 if ((prov_desc = prov_tab[i]) != NULL && 706 prov_desc->pd_prov_type == CRYPTO_HW_PROVIDER) { 707 if (KCF_IS_PROV_USABLE(prov_desc) || 708 (unverified && KCF_IS_PROV_UNVERIFIED(prov_desc))) { 709 if (name == NULL || 710 (strncmp(prov_desc->pd_name, name, 711 MAXNAMELEN) == 0 && 712 prov_desc->pd_instance == instance)) { 713 if ((char *)&p[j] > last) { 714 mutex_exit(&prov_tab_mutex); 715 kcf_free_provider_tab(cnt, p); 716 n = n << 1; 717 cnt = cnt << 1; 718 goto again; 719 } 720 p[j++] = prov_desc; 721 KCF_PROV_REFHOLD(prov_desc); 722 } 723 } 724 } 725 } 726 mutex_exit(&prov_tab_mutex); 727 728 final_size = j * sizeof (kcf_provider_desc_t *); 729 ASSERT(final_size <= n); 730 731 /* check if buffer we allocated is too large */ 732 if (final_size < n) { 733 char *final_buffer = NULL; 734 735 if (final_size > 0) { 736 final_buffer = kmem_alloc(final_size, kmflag); 737 if (final_buffer == NULL) { 738 kcf_free_provider_tab(cnt, p); 739 cnt = 0; 740 p = NULL; 741 rval = CRYPTO_HOST_MEMORY; 742 goto out; 743 } 744 bcopy(p, final_buffer, final_size); 745 } 746 kmem_free(p, n); 747 p = (kcf_provider_desc_t **)final_buffer; 748 } 749 cnt = j; 750 out: 751 *count = cnt; 752 *array = p; 753 return (rval); 754 } 755 756 /* 757 * Free an array of hardware provider descriptors. A REFRELE 758 * is done on each descriptor before the table is freed. 759 */ 760 void 761 kcf_free_provider_tab(uint_t count, kcf_provider_desc_t **array) 762 { 763 kcf_provider_desc_t *prov_desc; 764 int i; 765 766 for (i = 0; i < count; i++) { 767 if ((prov_desc = array[i]) != NULL) { 768 KCF_PROV_REFRELE(prov_desc); 769 } 770 } 771 kmem_free(array, count * sizeof (kcf_provider_desc_t *)); 772 } 773 774 /* 775 * Returns in the location pointed to by pd a pointer to the descriptor 776 * for the software provider for the specified mechanism. 777 * The provider descriptor is returned held and it is the caller's 778 * responsibility to release it when done. The mechanism entry 779 * is returned if the optional argument mep is non NULL. 780 * 781 * Returns one of the CRYPTO_ * error codes on failure, and 782 * CRYPTO_SUCCESS on success. 783 */ 784 int 785 kcf_get_sw_prov(crypto_mech_type_t mech_type, kcf_provider_desc_t **pd, 786 kcf_mech_entry_t **mep, boolean_t log_warn) 787 { 788 kcf_mech_entry_t *me; 789 790 /* get the mechanism entry for this mechanism */ 791 if (kcf_get_mech_entry(mech_type, &me) != KCF_SUCCESS) 792 return (CRYPTO_MECHANISM_INVALID); 793 794 /* 795 * Get the software provider for this mechanism. 796 * Lock the mech_entry until we grab the 'pd'. 797 */ 798 mutex_enter(&me->me_mutex); 799 800 if (me->me_sw_prov == NULL || 801 (*pd = me->me_sw_prov->pm_prov_desc) == NULL) { 802 /* no SW provider for this mechanism */ 803 if (log_warn) 804 cmn_err(CE_WARN, "no SW provider for \"%s\"\n", 805 me->me_name); 806 mutex_exit(&me->me_mutex); 807 return (CRYPTO_MECH_NOT_SUPPORTED); 808 } 809 810 KCF_PROV_REFHOLD(*pd); 811 mutex_exit(&me->me_mutex); 812 813 if (mep != NULL) 814 *mep = me; 815 816 return (CRYPTO_SUCCESS); 817 } 818 819 #if DEBUG 820 821 static void 822 kcf_prov_tab_dump(void) 823 { 824 uint_t i; 825 826 mutex_enter(&prov_tab_mutex); 827 828 printf("Providers table:\n"); 829 for (i = 0; i < KCF_MAX_PROVIDERS; i++) { 830 if (prov_tab[i] != NULL) { 831 printf("[%d]: (%s) %s\n", 832 i, (prov_tab[i]->pd_prov_type == 833 CRYPTO_HW_PROVIDER) ? "HW" : "SW", 834 prov_tab[i]->pd_description); 835 } 836 } 837 printf("(end of providers table)\n"); 838 839 mutex_exit(&prov_tab_mutex); 840 } 841 842 #endif /* DEBUG */ 843 844 /* 845 * This function goes through the provider table and verifies 846 * any unverified providers. 847 * 848 * This is called when kcfd is up and the door handle is ready. 849 */ 850 void 851 verify_unverified_providers() 852 { 853 int i; 854 kcf_provider_desc_t *pd; 855 boolean_t need_verify; 856 857 ASSERT(kcf_dh != NULL); 858 mutex_enter(&prov_tab_mutex); 859 860 for (i = 0; i < KCF_MAX_PROVIDERS; i++) { 861 if ((pd = prov_tab[i]) == NULL) 862 continue; 863 864 if (pd->pd_prov_type == CRYPTO_LOGICAL_PROVIDER) 865 continue; 866 867 mutex_enter(&pd->pd_lock); 868 need_verify = pd->pd_state == KCF_PROV_UNVERIFIED; 869 mutex_exit(&pd->pd_lock); 870 871 if (!need_verify) 872 continue; 873 874 KCF_PROV_REFHOLD(pd); 875 KCF_PROV_IREFHOLD(pd); 876 877 /* 878 * We need to drop this lock, since it could be 879 * acquired by kcf_verify_signature(). 880 * This is safe, as any providers that are 881 * added to the table after we dropped the 882 * lock *will see* a non NULL kcf_dh and hence 883 * would have been verified by other means. 884 */ 885 mutex_exit(&prov_tab_mutex); 886 /* This routine will release the above holds */ 887 kcf_verify_signature(pd); 888 mutex_enter(&prov_tab_mutex); 889 } 890 891 mutex_exit(&prov_tab_mutex); 892 } 893