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