1 /* 2 * This file and its contents are supplied under the terms of the 3 * Common Development and Distribution License ("CDDL"), version 1.0. 4 * You may only use this file in accordance with the terms of version 5 * 1.0 of the CDDL. 6 * 7 * A full copy of the text of the CDDL should have accompanied this 8 * source. A copy of the CDDL is also available via the Internet at 9 * http://www.illumos.org/license/CDDL. 10 */ 11 12 /* 13 * Copyright 2015 Nexenta Systems, Inc. All rights reserved. 14 * Copyright 2019 Joyent, Inc. 15 * Copyright 2023 RackTop Systems, Inc. 16 */ 17 18 #include <fcntl.h> 19 #include <strings.h> 20 #include <unistd.h> 21 #include <errno.h> 22 #include <stdio.h> 23 #include <stdlib.h> 24 #include <sys/debug.h> 25 26 #include "cryptotest.h" 27 28 boolean_t cryptotest_pkcs = B_FALSE; /* true if PKCS */ 29 30 struct crypto_op { 31 char *in; 32 char *out; 33 char *key; 34 char *param; 35 36 size_t inlen; 37 size_t outlen; 38 size_t keylen; 39 size_t paramlen; 40 const size_t *updatelens; 41 42 char *mechname; 43 44 /* internal */ 45 crypto_mech_type_t mech; 46 crypto_session_id_t hsession; 47 crypto_func_group_t fg; 48 }; 49 50 static int fd = -1; 51 static const char CRYPTO_DEVICE[] = "/dev/crypto"; 52 53 int 54 kcf_do_ioctl(int opcode, uint_t *arg, char *opstr) 55 { 56 int ret; 57 58 while ((ret = ioctl(fd, opcode, arg)) < 0) { 59 if (errno != EINTR) 60 break; 61 } 62 63 if (ret < 0 || *arg != CRYPTO_SUCCESS) { 64 char errbuf[BUFSZ] = {0}; 65 (void) fprintf(stderr, 66 "%s: Error: %s errno: %s (%d) rc: %d\n", 67 (opstr == NULL) ? "ioctl" : opstr, 68 cryptotest_errstr(*arg, errbuf, sizeof (errbuf)), 69 strerror(errno), errno, ret); 70 } 71 72 /* 73 * The callers all expect CRYPTO_xx errors. We've displayed the 74 * errno value (see above), so just return a generic CRYPTO_xxx 75 * error to signal failure. 76 */ 77 if (ret < 0) 78 return (CRYPTO_GENERAL_ERROR); 79 80 return (*arg); 81 } 82 83 crypto_op_t * 84 cryptotest_init(cryptotest_t *arg, crypto_func_group_t fg) 85 { 86 crypto_op_t *op = malloc(sizeof (*op)); 87 88 if (op == NULL) { 89 (void) fprintf(stderr, "malloc failed: %s\n", strerror(errno)); 90 return (NULL); 91 } 92 93 while ((fd = open(CRYPTO_DEVICE, O_RDWR)) < 0) { 94 if (errno != EINTR) { 95 (void) fprintf(stderr, "open of %s failed: %s", 96 CRYPTO_DEVICE, strerror(errno)); 97 free(op); 98 return (NULL); 99 } 100 } 101 102 op->in = (char *)arg->in; 103 op->out = (char *)arg->out; 104 op->key = (char *)arg->key; 105 op->param = (char *)arg->param; 106 107 op->inlen = arg->inlen; 108 op->outlen = arg->outlen; 109 op->keylen = arg->keylen * 8; /* kcf uses keylen in bits */ 110 op->paramlen = arg->plen; 111 op->updatelens = arg->updatelens; 112 113 op->mechname = arg->mechname; 114 115 op->hsession = CRYPTO_INVALID_SESSION; 116 op->fg = fg; 117 118 if (op->out == NULL) 119 op->outlen = op->inlen; 120 return (op); 121 } 122 123 int 124 cryptotest_close_session(crypto_session_id_t session) 125 { 126 crypto_close_session_t cs; 127 128 cs.cs_session = session; 129 return (kcf_do_ioctl(CRYPTO_CLOSE_SESSION, (uint_t *)&cs, "session")); 130 } 131 132 void 133 cryptotest_close(crypto_op_t *op) 134 { 135 if (op->hsession != CRYPTO_INVALID_SESSION) 136 (void) cryptotest_close_session(op->hsession); 137 free(op); 138 if (fd >= 0) 139 VERIFY0(close(fd)); 140 fd = -1; 141 } 142 143 int 144 get_mech_info(crypto_op_t *op) 145 { 146 crypto_get_mechanism_number_t get_number; 147 148 bzero(&get_number, sizeof (get_number)); 149 150 get_number.pn_mechanism_string = op->mechname; 151 get_number.pn_mechanism_len = strlen(op->mechname) + 1; 152 153 if (kcf_do_ioctl(CRYPTO_GET_MECHANISM_NUMBER, 154 (uint_t *)&get_number, "get_mech_info") != CRYPTO_SUCCESS) { 155 (void) fprintf(stderr, "failed to resolve mechanism name %s\n", 156 op->mechname); 157 return (CTEST_NAME_RESOLVE_FAILED); 158 } 159 op->mech = get_number.pn_internal_number; 160 return (CRYPTO_SUCCESS); 161 } 162 163 int 164 get_hsession_by_mech(crypto_op_t *op) 165 { 166 crypto_by_mech_t mech; 167 int rv; 168 169 mech.mech_keylen = op->keylen; 170 mech.mech_type = op->mech; 171 mech.mech_fg = op->fg; 172 173 rv = kcf_do_ioctl(CRYPTO_GET_PROVIDER_BY_MECH, (uint_t *)&mech, 174 "get_hsession_by_mech"); 175 176 if (rv != 0 || mech.rv != CRYPTO_SUCCESS) { 177 (void) fprintf(stderr, 178 "could not find provider for mechanism %llu\n", 179 mech.mech_type); 180 return (CTEST_MECH_NO_PROVIDER); 181 } 182 183 op->hsession = mech.session_id; 184 185 return (CRYPTO_SUCCESS); 186 } 187 188 /* 189 * CRYPTO_MAC_* functions 190 */ 191 int 192 mac_init(crypto_op_t *op) 193 { 194 crypto_mac_init_t init; 195 196 bzero((void *)&init, sizeof (init)); 197 198 init.mi_session = op->hsession; 199 200 init.mi_key.ck_data = op->key; 201 init.mi_key.ck_format = CRYPTO_KEY_RAW; /* must be this */ 202 init.mi_key.ck_length = op->keylen; 203 204 init.mi_mech.cm_type = op->mech; 205 init.mi_mech.cm_param = op->param; 206 init.mi_mech.cm_param_len = op->paramlen; 207 208 return (kcf_do_ioctl(CRYPTO_MAC_INIT, (uint_t *)&init, "init")); 209 } 210 211 int 212 mac_single(crypto_op_t *op) 213 { 214 crypto_mac_t mac; 215 216 bzero(&mac, sizeof (mac)); 217 mac.cm_session = op->hsession; 218 mac.cm_datalen = op->inlen; 219 mac.cm_databuf = op->in; 220 mac.cm_maclen = op->outlen; 221 mac.cm_macbuf = op->out; 222 223 return (kcf_do_ioctl(CRYPTO_MAC, (uint_t *)&mac, "single")); 224 } 225 226 int 227 mac_update(crypto_op_t *op, size_t offset, size_t len, size_t *dummy __unused) 228 { 229 crypto_mac_update_t update; 230 231 bzero((void *)&update, sizeof (update)); 232 233 update.mu_session = op->hsession; 234 update.mu_databuf = op->in + offset; 235 update.mu_datalen = len; 236 237 return (kcf_do_ioctl(CRYPTO_MAC_UPDATE, (uint_t *)&update, "update")); 238 } 239 240 int 241 mac_final(crypto_op_t *op, size_t dummy __unused) 242 { 243 crypto_mac_final_t final; 244 245 bzero((void *)&final, sizeof (final)); 246 247 final.mf_session = op->hsession; 248 final.mf_maclen = op->outlen; 249 final.mf_macbuf = op->out; 250 251 return (kcf_do_ioctl(CRYPTO_MAC_FINAL, (uint_t *)&final, "final")); 252 } 253 254 255 /* 256 * CRYPTO_ENCRYPT_* functions 257 */ 258 259 int 260 encrypt_init(crypto_op_t *op) 261 { 262 crypto_encrypt_init_t init; 263 264 bzero((void *)&init, sizeof (init)); 265 266 init.ei_session = op->hsession; 267 268 init.ei_key.ck_data = op->key; 269 init.ei_key.ck_format = CRYPTO_KEY_RAW; /* must be this */ 270 init.ei_key.ck_length = op->keylen; 271 272 init.ei_mech.cm_type = op->mech; 273 init.ei_mech.cm_param = op->param; 274 init.ei_mech.cm_param_len = op->paramlen; 275 276 return (kcf_do_ioctl(CRYPTO_ENCRYPT_INIT, (uint_t *)&init, "init")); 277 } 278 279 int 280 encrypt_single(crypto_op_t *op) 281 { 282 crypto_encrypt_t encrypt; 283 284 bzero(&encrypt, sizeof (encrypt)); 285 encrypt.ce_session = op->hsession; 286 encrypt.ce_datalen = op->inlen; 287 encrypt.ce_databuf = op->in; 288 encrypt.ce_encrlen = op->outlen; 289 encrypt.ce_encrbuf = op->out; 290 291 return (kcf_do_ioctl(CRYPTO_ENCRYPT, (uint_t *)&encrypt, "single")); 292 } 293 294 int 295 encrypt_update(crypto_op_t *op, size_t offset, size_t plainlen, size_t *encrlen) 296 { 297 crypto_encrypt_update_t update; 298 int ret; 299 bzero((void *)&update, sizeof (update)); 300 301 update.eu_session = op->hsession; 302 update.eu_databuf = op->in + offset; 303 update.eu_datalen = plainlen; 304 update.eu_encrlen = op->outlen - *encrlen; 305 update.eu_encrbuf = op->out + *encrlen; 306 307 ret = kcf_do_ioctl(CRYPTO_ENCRYPT_UPDATE, (uint_t *)&update, "update"); 308 *encrlen += update.eu_encrlen; 309 return (ret); 310 } 311 312 int 313 encrypt_final(crypto_op_t *op, size_t encrlen) 314 { 315 crypto_encrypt_final_t final; 316 317 bzero((void *)&final, sizeof (final)); 318 319 final.ef_session = op->hsession; 320 final.ef_encrlen = op->outlen - encrlen; 321 final.ef_encrbuf = op->out + encrlen; 322 323 return (kcf_do_ioctl(CRYPTO_ENCRYPT_FINAL, (uint_t *)&final, "final")); 324 } 325 326 /* 327 * CRYPTO_DECRYPT_* functions 328 */ 329 330 int 331 decrypt_init(crypto_op_t *op) 332 { 333 crypto_decrypt_init_t init; 334 335 bzero((void *)&init, sizeof (init)); 336 337 init.di_session = op->hsession; 338 339 init.di_key.ck_data = op->key; 340 init.di_key.ck_format = CRYPTO_KEY_RAW; /* must be this */ 341 init.di_key.ck_length = op->keylen; 342 343 init.di_mech.cm_type = op->mech; 344 init.di_mech.cm_param = op->param; 345 init.di_mech.cm_param_len = op->paramlen; 346 347 return (kcf_do_ioctl(CRYPTO_DECRYPT_INIT, (uint_t *)&init, "init")); 348 } 349 350 int 351 decrypt_single(crypto_op_t *op) 352 { 353 crypto_decrypt_t decrypt; 354 355 bzero(&decrypt, sizeof (decrypt)); 356 decrypt.cd_session = op->hsession; 357 decrypt.cd_datalen = op->outlen; 358 decrypt.cd_databuf = op->out; 359 decrypt.cd_encrlen = op->inlen; 360 decrypt.cd_encrbuf = op->in; 361 362 return (kcf_do_ioctl(CRYPTO_DECRYPT, (uint_t *)&decrypt, "single")); 363 } 364 365 int 366 decrypt_update(crypto_op_t *op, size_t offset, size_t len, size_t *encrlen) 367 { 368 crypto_decrypt_update_t update; 369 int ret; 370 371 bzero((void *)&update, sizeof (update)); 372 373 update.du_session = op->hsession; 374 update.du_databuf = op->out + *encrlen; 375 update.du_datalen = op->outlen - *encrlen; 376 update.du_encrlen = len; 377 update.du_encrbuf = op->in + offset; 378 379 ret = kcf_do_ioctl(CRYPTO_DECRYPT_UPDATE, (uint_t *)&update, "update"); 380 *encrlen += update.du_datalen; 381 return (ret); 382 } 383 384 int 385 decrypt_final(crypto_op_t *op, size_t encrlen) 386 { 387 crypto_decrypt_final_t final; 388 389 bzero((void *)&final, sizeof (final)); 390 391 final.df_session = op->hsession; 392 final.df_datalen = op->outlen - encrlen; 393 final.df_databuf = op->out + encrlen; 394 395 return (kcf_do_ioctl(CRYPTO_DECRYPT_FINAL, (uint_t *)&final, "final")); 396 } 397 398 int 399 digest_init(crypto_op_t *op) 400 { 401 crypto_digest_init_t init; 402 403 bzero(&init, sizeof (init)); 404 405 init.di_session = op->hsession; 406 407 init.di_mech.cm_type = op->mech; 408 init.di_mech.cm_param = op->param; 409 init.di_mech.cm_param_len = op->paramlen; 410 411 return (kcf_do_ioctl(CRYPTO_DIGEST_INIT, (uint_t *)&init, "init")); 412 } 413 414 int 415 digest_single(crypto_op_t *op) 416 { 417 crypto_digest_t digest; 418 419 bzero(&digest, sizeof (digest)); 420 421 digest.cd_session = op->hsession; 422 423 digest.cd_datalen = op->inlen; 424 digest.cd_databuf = op->in; 425 digest.cd_digestlen = op->outlen; 426 digest.cd_digestbuf = op->out; 427 428 return (kcf_do_ioctl(CRYPTO_DIGEST, (uint_t *)&digest, "digest")); 429 } 430 431 int 432 digest_update(crypto_op_t *op, size_t offset, size_t len, 433 size_t *dummy __unused) 434 { 435 crypto_digest_update_t update; 436 437 bzero(&update, sizeof (update)); 438 439 update.du_session = op->hsession; 440 441 update.du_datalen = len; 442 update.du_databuf = op->in + offset; 443 444 return (kcf_do_ioctl(CRYPTO_DIGEST_UPDATE, (uint_t *)&update, 445 "update")); 446 } 447 448 int 449 digest_final(crypto_op_t *op, size_t dummy __unused) 450 { 451 crypto_digest_final_t final; 452 453 bzero(&final, sizeof (final)); 454 455 final.df_session = op->hsession; 456 457 final.df_digestlen = op->outlen; 458 final.df_digestbuf = op->out; 459 460 return (kcf_do_ioctl(CRYPTO_DIGEST_FINAL, (uint_t *)&final, "final")); 461 } 462 463 void 464 ccm_init_params(void *buf, ulong_t ulDataLen, uchar_t *pNonce, 465 ulong_t ulNonceLen, uchar_t *pAAD, ulong_t ulAADLen, ulong_t ulMACLen) 466 { 467 CK_AES_CCM_PARAMS *pp = buf; 468 469 pp->ulDataSize = ulDataLen; 470 pp->nonce = pNonce; 471 pp->ulNonceSize = ulNonceLen; 472 pp->authData = pAAD; 473 pp->ulAuthDataSize = ulAADLen; 474 pp->ulMACSize = ulMACLen; 475 } 476 477 size_t 478 ccm_param_len(void) 479 { 480 return (sizeof (CK_AES_CCM_PARAMS)); 481 } 482 483 /* 484 * KCF always takes CK_AES_GMAC_PARAMS, but the caller may pass 485 * either just the IV or IV plus AAD. 486 * 487 * Some tests pass ulAADLen = 0 and non-NULL pAAD, so allow that, 488 * but require ulAADLen=0 if pAAD=NULL. 489 */ 490 void 491 gmac_init_params(void *buf, uchar_t *pIv, uchar_t *pAAD, ulong_t ulAADLen) 492 { 493 CK_AES_GMAC_PARAMS *pp = buf; 494 495 if (pAAD == NULL) { 496 VERIFY0(ulAADLen); 497 } 498 499 pp->pIv = pIv; 500 pp->pAAD = pAAD; /* may be NULL */ 501 pp->ulAADLen = ulAADLen; 502 } 503 504 size_t 505 gmac_param_len(void) 506 { 507 return (sizeof (CK_AES_GMAC_PARAMS)); 508 } 509 510 const char * 511 cryptotest_errstr(int e, char *buf, size_t buflen) 512 { 513 const char *valstr = NULL; 514 515 switch (e) { 516 case CRYPTO_SUCCESS: 517 valstr = "CRYPTO_SUCCESS"; 518 break; 519 case CRYPTO_CANCEL: 520 valstr = "CRYPTO_CANCEL"; 521 break; 522 case CRYPTO_HOST_MEMORY: 523 valstr = "CRYPTO_HOST_MEMORY"; 524 break; 525 case CRYPTO_GENERAL_ERROR: 526 valstr = "CRYPTO_GENERAL_ERROR"; 527 break; 528 case CRYPTO_FAILED: 529 valstr = "CRYPTO_FAILED"; 530 break; 531 case CRYPTO_ARGUMENTS_BAD: 532 valstr = "CRYPTO_ARGUMENTS_BAD"; 533 break; 534 case CRYPTO_ATTRIBUTE_READ_ONLY: 535 valstr = "CRYPTO_ATTRIBUTE_READ_ONLY"; 536 break; 537 case CRYPTO_ATTRIBUTE_SENSITIVE: 538 valstr = "CRYPTO_ATTRIBUTE_SENSITIVE"; 539 break; 540 case CRYPTO_ATTRIBUTE_TYPE_INVALID: 541 valstr = "CRYPTO_ATTRIBUTE_TYPE_INVALID"; 542 break; 543 case CRYPTO_ATTRIBUTE_VALUE_INVALID: 544 valstr = "CRYPTO_ATTRIBUTE_VALUE_INVALID"; 545 break; 546 case CRYPTO_CANCELED: 547 valstr = "CRYPTO_CANCELED"; 548 break; 549 case CRYPTO_DATA_INVALID: 550 valstr = "CRYPTO_DATA_INVALID"; 551 break; 552 case CRYPTO_DATA_LEN_RANGE: 553 valstr = "CRYPTO_DATA_LEN_RANGE"; 554 break; 555 case CRYPTO_DEVICE_ERROR: 556 valstr = "CRYPTO_DEVICE_ERROR"; 557 break; 558 case CRYPTO_DEVICE_MEMORY: 559 valstr = "CRYPTO_DEVICE_MEMORY"; 560 break; 561 case CRYPTO_DEVICE_REMOVED: 562 valstr = "CRYPTO_DEVICE_REMOVED"; 563 break; 564 case CRYPTO_ENCRYPTED_DATA_INVALID: 565 valstr = "CRYPTO_ENCRYPTED_DATA_INVALID"; 566 break; 567 case CRYPTO_ENCRYPTED_DATA_LEN_RANGE: 568 valstr = "CRYPTO_ENCRYPTED_DATA_LEN_RANGE"; 569 break; 570 case CRYPTO_KEY_HANDLE_INVALID: 571 valstr = "CRYPTO_KEY_HANDLE_INVALID"; 572 break; 573 case CRYPTO_KEY_SIZE_RANGE: 574 valstr = "CRYPTO_KEY_SIZE_RANGE"; 575 break; 576 case CRYPTO_KEY_TYPE_INCONSISTENT: 577 valstr = "CRYPTO_KEY_TYPE_INCONSISTENT"; 578 break; 579 case CRYPTO_KEY_NOT_NEEDED: 580 valstr = "CRYPTO_KEY_NOT_NEEDED"; 581 break; 582 case CRYPTO_KEY_CHANGED: 583 valstr = "CRYPTO_KEY_CHANGED"; 584 break; 585 case CRYPTO_KEY_NEEDED: 586 valstr = "CRYPTO_KEY_NEEDED"; 587 break; 588 case CRYPTO_KEY_INDIGESTIBLE: 589 valstr = "CRYPTO_KEY_INDIGESTIBLE"; 590 break; 591 case CRYPTO_KEY_FUNCTION_NOT_PERMITTED: 592 valstr = "CRYPTO_KEY_FUNCTION_NOT_PERMITTED"; 593 break; 594 case CRYPTO_KEY_NOT_WRAPPABLE: 595 valstr = "CRYPTO_KEY_NOT_WRAPPABLE"; 596 break; 597 case CRYPTO_KEY_UNEXTRACTABLE: 598 valstr = "CRYPTO_KEY_UNEXTRACTABLE"; 599 break; 600 case CRYPTO_MECHANISM_INVALID: 601 valstr = "CRYPTO_MECHANISM_INVALID"; 602 break; 603 case CRYPTO_MECHANISM_PARAM_INVALID: 604 valstr = "CRYPTO_MECHANISM_PARAM_INVALID"; 605 break; 606 case CRYPTO_OBJECT_HANDLE_INVALID: 607 valstr = "CRYPTO_OBJECT_HANDLE_INVALID"; 608 break; 609 case CRYPTO_OPERATION_IS_ACTIVE: 610 valstr = "CRYPTO_OPERATION_IS_ACTIVE"; 611 break; 612 case CRYPTO_OPERATION_NOT_INITIALIZED: 613 valstr = "CRYPTO_OPERATION_NOT_INITIALIZED"; 614 break; 615 case CRYPTO_PIN_INCORRECT: 616 valstr = "CRYPTO_PIN_INCORRECT"; 617 break; 618 case CRYPTO_PIN_INVALID: 619 valstr = "CRYPTO_PIN_INVALID"; 620 break; 621 case CRYPTO_PIN_LEN_RANGE: 622 valstr = "CRYPTO_PIN_LEN_RANGE"; 623 break; 624 case CRYPTO_PIN_EXPIRED: 625 valstr = "CRYPTO_PIN_EXPIRED"; 626 break; 627 case CRYPTO_PIN_LOCKED: 628 valstr = "CRYPTO_PIN_LOCKED"; 629 break; 630 case CRYPTO_SESSION_CLOSED: 631 valstr = "CRYPTO_SESSION_CLOSED"; 632 break; 633 case CRYPTO_SESSION_COUNT: 634 valstr = "CRYPTO_SESSION_COUNT"; 635 break; 636 case CRYPTO_SESSION_HANDLE_INVALID: 637 valstr = "CRYPTO_SESSION_HANDLE_INVALID"; 638 break; 639 case CRYPTO_SESSION_READ_ONLY: 640 valstr = "CRYPTO_SESSION_READ_ONLY"; 641 break; 642 case CRYPTO_SESSION_EXISTS: 643 valstr = "CRYPTO_SESSION_EXISTS"; 644 break; 645 case CRYPTO_SESSION_READ_ONLY_EXISTS: 646 valstr = "CRYPTO_SESSION_READ_ONLY_EXISTS"; 647 break; 648 case CRYPTO_SESSION_READ_WRITE_SO_EXISTS: 649 valstr = "CRYPTO_SESSION_READ_WRITE_SO_EXISTS"; 650 break; 651 case CRYPTO_SIGNATURE_INVALID: 652 valstr = "CRYPTO_SIGNATURE_INVALID"; 653 break; 654 case CRYPTO_SIGNATURE_LEN_RANGE: 655 valstr = "CRYPTO_SIGNATURE_LEN_RANGE"; 656 break; 657 case CRYPTO_TEMPLATE_INCOMPLETE: 658 valstr = "CRYPTO_TEMPLATE_INCOMPLETE"; 659 break; 660 case CRYPTO_TEMPLATE_INCONSISTENT: 661 valstr = "CRYPTO_TEMPLATE_INCONSISTENT"; 662 break; 663 case CRYPTO_UNWRAPPING_KEY_HANDLE_INVALID: 664 valstr = "CRYPTO_UNWRAPPING_KEY_HANDLE_INVALID"; 665 break; 666 case CRYPTO_UNWRAPPING_KEY_SIZE_RANGE: 667 valstr = "CRYPTO_UNWRAPPING_KEY_SIZE_RANGE"; 668 break; 669 case CRYPTO_UNWRAPPING_KEY_TYPE_INCONSISTENT: 670 valstr = "CRYPTO_UNWRAPPING_KEY_TYPE_INCONSISTENT"; 671 break; 672 case CRYPTO_USER_ALREADY_LOGGED_IN: 673 valstr = "CRYPTO_USER_ALREADY_LOGGED_IN"; 674 break; 675 case CRYPTO_USER_NOT_LOGGED_IN: 676 valstr = "CRYPTO_USER_NOT_LOGGED_IN"; 677 break; 678 case CRYPTO_USER_PIN_NOT_INITIALIZED: 679 valstr = "CRYPTO_USER_PIN_NOT_INITIALIZED"; 680 break; 681 case CRYPTO_USER_TYPE_INVALID: 682 valstr = "CRYPTO_USER_TYPE_INVALID"; 683 break; 684 case CRYPTO_USER_ANOTHER_ALREADY_LOGGED_IN: 685 valstr = "CRYPTO_USER_ANOTHER_ALREADY_LOGGED_IN"; 686 break; 687 case CRYPTO_USER_TOO_MANY_TYPES: 688 valstr = "CRYPTO_USER_TOO_MANY_TYPES"; 689 break; 690 case CRYPTO_WRAPPED_KEY_INVALID: 691 valstr = "CRYPTO_WRAPPED_KEY_INVALID"; 692 break; 693 case CRYPTO_WRAPPED_KEY_LEN_RANGE: 694 valstr = "CRYPTO_WRAPPED_KEY_LEN_RANGE"; 695 break; 696 case CRYPTO_WRAPPING_KEY_HANDLE_INVALID: 697 valstr = "CRYPTO_WRAPPING_KEY_HANDLE_INVALID"; 698 break; 699 case CRYPTO_WRAPPING_KEY_SIZE_RANGE: 700 valstr = "CRYPTO_WRAPPING_KEY_SIZE_RANGE"; 701 break; 702 case CRYPTO_WRAPPING_KEY_TYPE_INCONSISTENT: 703 valstr = "CRYPTO_WRAPPING_KEY_TYPE_INCONSISTENT"; 704 break; 705 case CRYPTO_RANDOM_SEED_NOT_SUPPORTED: 706 valstr = "CRYPTO_RANDOM_SEED_NOT_SUPPORTED"; 707 break; 708 case CRYPTO_RANDOM_NO_RNG: 709 valstr = "CRYPTO_RANDOM_NO_RNG"; 710 break; 711 case CRYPTO_DOMAIN_PARAMS_INVALID: 712 valstr = "CRYPTO_DOMAIN_PARAMS_INVALID"; 713 break; 714 case CRYPTO_BUFFER_TOO_SMALL: 715 valstr = "CRYPTO_BUFFER_TOO_SMALL"; 716 break; 717 case CRYPTO_INFORMATION_SENSITIVE: 718 valstr = "CRYPTO_INFORMATION_SENSITIVE"; 719 break; 720 case CRYPTO_NOT_SUPPORTED: 721 valstr = "CRYPTO_NOT_SUPPORTED"; 722 break; 723 case CRYPTO_QUEUED: 724 valstr = "CRYPTO_QUEUED"; 725 break; 726 case CRYPTO_BUFFER_TOO_BIG: 727 valstr = "CRYPTO_BUFFER_TOO_BIG"; 728 break; 729 case CRYPTO_INVALID_CONTEXT: 730 valstr = "CRYPTO_INVALID_CONTEXT"; 731 break; 732 case CRYPTO_INVALID_MAC: 733 valstr = "CRYPTO_INVALID_MAC"; 734 break; 735 case CRYPTO_MECH_NOT_SUPPORTED: 736 valstr = "CRYPTO_MECH_NOT_SUPPORTED"; 737 break; 738 case CRYPTO_INCONSISTENT_ATTRIBUTE: 739 valstr = "CRYPTO_INCONSISTENT_ATTRIBUTE"; 740 break; 741 case CRYPTO_NO_PERMISSION: 742 valstr = "CRYPTO_NO_PERMISSION"; 743 break; 744 case CRYPTO_INVALID_PROVIDER_ID: 745 valstr = "CRYPTO_INVALID_PROVIDER_ID"; 746 break; 747 case CRYPTO_VERSION_MISMATCH: 748 valstr = "CRYPTO_VERSION_MISMATCH"; 749 break; 750 case CRYPTO_BUSY: 751 valstr = "CRYPTO_BUSY"; 752 break; 753 case CRYPTO_UNKNOWN_PROVIDER: 754 valstr = "CRYPTO_UNKNOWN_PROVIDER"; 755 break; 756 case CRYPTO_MODVERIFICATION_FAILED: 757 valstr = "CRYPTO_MODVERIFICATION_FAILED"; 758 break; 759 case CRYPTO_OLD_CTX_TEMPLATE: 760 valstr = "CRYPTO_OLD_CTX_TEMPLATE"; 761 break; 762 case CRYPTO_WEAK_KEY: 763 valstr = "CRYPTO_WEAK_KEY"; 764 break; 765 case CRYPTO_FIPS140_ERROR: 766 valstr = "CRYPTO_FIPS140_ERROR"; 767 break; 768 default: 769 valstr = "Unknown KCF error"; 770 break; 771 } 772 773 (void) snprintf(buf, buflen, "%s (0x%08x)", valstr, e); 774 return (buf); 775 } 776