1 /* $OpenBSD: ssl_stat.c,v 1.18 2022/02/05 14:54:10 jsing Exp $ */ 2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) 3 * All rights reserved. 4 * 5 * This package is an SSL implementation written 6 * by Eric Young (eay@cryptsoft.com). 7 * The implementation was written so as to conform with Netscapes SSL. 8 * 9 * This library is free for commercial and non-commercial use as long as 10 * the following conditions are aheared to. The following conditions 11 * apply to all code found in this distribution, be it the RC4, RSA, 12 * lhash, DES, etc., code; not just the SSL code. The SSL documentation 13 * included with this distribution is covered by the same copyright terms 14 * except that the holder is Tim Hudson (tjh@cryptsoft.com). 15 * 16 * Copyright remains Eric Young's, and as such any Copyright notices in 17 * the code are not to be removed. 18 * If this package is used in a product, Eric Young should be given attribution 19 * as the author of the parts of the library used. 20 * This can be in the form of a textual message at program startup or 21 * in documentation (online or textual) provided with the package. 22 * 23 * Redistribution and use in source and binary forms, with or without 24 * modification, are permitted provided that the following conditions 25 * are met: 26 * 1. Redistributions of source code must retain the copyright 27 * notice, this list of conditions and the following disclaimer. 28 * 2. Redistributions in binary form must reproduce the above copyright 29 * notice, this list of conditions and the following disclaimer in the 30 * documentation and/or other materials provided with the distribution. 31 * 3. All advertising materials mentioning features or use of this software 32 * must display the following acknowledgement: 33 * "This product includes cryptographic software written by 34 * Eric Young (eay@cryptsoft.com)" 35 * The word 'cryptographic' can be left out if the rouines from the library 36 * being used are not cryptographic related :-). 37 * 4. If you include any Windows specific code (or a derivative thereof) from 38 * the apps directory (application code) you must include an acknowledgement: 39 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" 40 * 41 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND 42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 44 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 51 * SUCH DAMAGE. 52 * 53 * The licence and distribution terms for any publically available version or 54 * derivative of this code cannot be changed. i.e. this code cannot simply be 55 * copied and put under another distribution licence 56 * [including the GNU Public Licence.] 57 */ 58 /* ==================================================================== 59 * Copyright 2005 Nokia. All rights reserved. 60 * 61 * The portions of the attached software ("Contribution") is developed by 62 * Nokia Corporation and is licensed pursuant to the OpenSSL open source 63 * license. 64 * 65 * The Contribution, originally written by Mika Kousa and Pasi Eronen of 66 * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites 67 * support (see RFC 4279) to OpenSSL. 68 * 69 * No patent licenses or other rights except those expressly stated in 70 * the OpenSSL open source license shall be deemed granted or received 71 * expressly, by implication, estoppel, or otherwise. 72 * 73 * No assurances are provided by Nokia that the Contribution does not 74 * infringe the patent or other intellectual property rights of any third 75 * party or that the license provides you with all the necessary rights 76 * to make use of the Contribution. 77 * 78 * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN 79 * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA 80 * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY 81 * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR 82 * OTHERWISE. 83 */ 84 85 #include <stdio.h> 86 87 #include "ssl_locl.h" 88 89 const char * 90 SSL_state_string_long(const SSL *s) 91 { 92 const char *str; 93 94 switch (s->s3->hs.state) { 95 case SSL_ST_BEFORE: 96 str = "before SSL initialization"; 97 break; 98 case SSL_ST_ACCEPT: 99 str = "before accept initialization"; 100 break; 101 case SSL_ST_CONNECT: 102 str = "before connect initialization"; 103 break; 104 case SSL_ST_OK: 105 str = "SSL negotiation finished successfully"; 106 break; 107 case SSL_ST_RENEGOTIATE: 108 str = "SSL renegotiate ciphers"; 109 break; 110 case SSL_ST_BEFORE|SSL_ST_CONNECT: 111 str = "before/connect initialization"; 112 break; 113 case SSL_ST_OK|SSL_ST_CONNECT: 114 str = "ok/connect SSL initialization"; 115 break; 116 case SSL_ST_BEFORE|SSL_ST_ACCEPT: 117 str = "before/accept initialization"; 118 break; 119 case SSL_ST_OK|SSL_ST_ACCEPT: 120 str = "ok/accept SSL initialization"; 121 break; 122 123 /* SSLv3 additions */ 124 case SSL3_ST_CW_CLNT_HELLO_A: 125 str = "SSLv3 write client hello A"; 126 break; 127 case SSL3_ST_CW_CLNT_HELLO_B: 128 str = "SSLv3 write client hello B"; 129 break; 130 case SSL3_ST_CR_SRVR_HELLO_A: 131 str = "SSLv3 read server hello A"; 132 break; 133 case SSL3_ST_CR_SRVR_HELLO_B: 134 str = "SSLv3 read server hello B"; 135 break; 136 case SSL3_ST_CR_CERT_A: 137 str = "SSLv3 read server certificate A"; 138 break; 139 case SSL3_ST_CR_CERT_B: 140 str = "SSLv3 read server certificate B"; 141 break; 142 case SSL3_ST_CR_KEY_EXCH_A: 143 str = "SSLv3 read server key exchange A"; 144 break; 145 case SSL3_ST_CR_KEY_EXCH_B: 146 str = "SSLv3 read server key exchange B"; 147 break; 148 case SSL3_ST_CR_CERT_REQ_A: 149 str = "SSLv3 read server certificate request A"; 150 break; 151 case SSL3_ST_CR_CERT_REQ_B: 152 str = "SSLv3 read server certificate request B"; 153 break; 154 case SSL3_ST_CR_SESSION_TICKET_A: 155 str = "SSLv3 read server session ticket A"; 156 break; 157 case SSL3_ST_CR_SESSION_TICKET_B: 158 str = "SSLv3 read server session ticket B"; 159 break; 160 case SSL3_ST_CR_SRVR_DONE_A: 161 str = "SSLv3 read server done A"; 162 break; 163 case SSL3_ST_CR_SRVR_DONE_B: 164 str = "SSLv3 read server done B"; 165 break; 166 case SSL3_ST_CW_CERT_A: 167 str = "SSLv3 write client certificate A"; 168 break; 169 case SSL3_ST_CW_CERT_B: 170 str = "SSLv3 write client certificate B"; 171 break; 172 case SSL3_ST_CW_CERT_C: 173 str = "SSLv3 write client certificate C"; 174 break; 175 case SSL3_ST_CW_CERT_D: 176 str = "SSLv3 write client certificate D"; 177 break; 178 case SSL3_ST_CW_KEY_EXCH_A: 179 str = "SSLv3 write client key exchange A"; 180 break; 181 case SSL3_ST_CW_KEY_EXCH_B: 182 str = "SSLv3 write client key exchange B"; 183 break; 184 case SSL3_ST_CW_CERT_VRFY_A: 185 str = "SSLv3 write certificate verify A"; 186 break; 187 case SSL3_ST_CW_CERT_VRFY_B: 188 str = "SSLv3 write certificate verify B"; 189 break; 190 191 case SSL3_ST_CW_CHANGE_A: 192 case SSL3_ST_SW_CHANGE_A: 193 str = "SSLv3 write change cipher spec A"; 194 break; 195 case SSL3_ST_CW_CHANGE_B: 196 case SSL3_ST_SW_CHANGE_B: 197 str = "SSLv3 write change cipher spec B"; 198 break; 199 case SSL3_ST_CW_FINISHED_A: 200 case SSL3_ST_SW_FINISHED_A: 201 str = "SSLv3 write finished A"; 202 break; 203 case SSL3_ST_CW_FINISHED_B: 204 case SSL3_ST_SW_FINISHED_B: 205 str = "SSLv3 write finished B"; 206 break; 207 case SSL3_ST_CR_CHANGE_A: 208 case SSL3_ST_SR_CHANGE_A: 209 str = "SSLv3 read change cipher spec A"; 210 break; 211 case SSL3_ST_CR_CHANGE_B: 212 case SSL3_ST_SR_CHANGE_B: 213 str = "SSLv3 read change cipher spec B"; 214 break; 215 case SSL3_ST_CR_FINISHED_A: 216 case SSL3_ST_SR_FINISHED_A: 217 str = "SSLv3 read finished A"; 218 break; 219 case SSL3_ST_CR_FINISHED_B: 220 case SSL3_ST_SR_FINISHED_B: 221 str = "SSLv3 read finished B"; 222 break; 223 224 case SSL3_ST_CW_FLUSH: 225 case SSL3_ST_SW_FLUSH: 226 str = "SSLv3 flush data"; 227 break; 228 229 case SSL3_ST_SR_CLNT_HELLO_A: 230 str = "SSLv3 read client hello A"; 231 break; 232 case SSL3_ST_SR_CLNT_HELLO_B: 233 str = "SSLv3 read client hello B"; 234 break; 235 case SSL3_ST_SR_CLNT_HELLO_C: 236 str = "SSLv3 read client hello C"; 237 break; 238 case SSL3_ST_SW_HELLO_REQ_A: 239 str = "SSLv3 write hello request A"; 240 break; 241 case SSL3_ST_SW_HELLO_REQ_B: 242 str = "SSLv3 write hello request B"; 243 break; 244 case SSL3_ST_SW_HELLO_REQ_C: 245 str = "SSLv3 write hello request C"; 246 break; 247 case SSL3_ST_SW_SRVR_HELLO_A: 248 str = "SSLv3 write server hello A"; 249 break; 250 case SSL3_ST_SW_SRVR_HELLO_B: 251 str = "SSLv3 write server hello B"; 252 break; 253 case SSL3_ST_SW_CERT_A: 254 str = "SSLv3 write certificate A"; 255 break; 256 case SSL3_ST_SW_CERT_B: 257 str = "SSLv3 write certificate B"; 258 break; 259 case SSL3_ST_SW_KEY_EXCH_A: 260 str = "SSLv3 write key exchange A"; 261 break; 262 case SSL3_ST_SW_KEY_EXCH_B: 263 str = "SSLv3 write key exchange B"; 264 break; 265 case SSL3_ST_SW_CERT_REQ_A: 266 str = "SSLv3 write certificate request A"; 267 break; 268 case SSL3_ST_SW_CERT_REQ_B: 269 str = "SSLv3 write certificate request B"; 270 break; 271 case SSL3_ST_SW_SESSION_TICKET_A: 272 str = "SSLv3 write session ticket A"; 273 break; 274 case SSL3_ST_SW_SESSION_TICKET_B: 275 str = "SSLv3 write session ticket B"; 276 break; 277 case SSL3_ST_SW_SRVR_DONE_A: 278 str = "SSLv3 write server done A"; 279 break; 280 case SSL3_ST_SW_SRVR_DONE_B: 281 str = "SSLv3 write server done B"; 282 break; 283 case SSL3_ST_SR_CERT_A: 284 str = "SSLv3 read client certificate A"; 285 break; 286 case SSL3_ST_SR_CERT_B: 287 str = "SSLv3 read client certificate B"; 288 break; 289 case SSL3_ST_SR_KEY_EXCH_A: 290 str = "SSLv3 read client key exchange A"; 291 break; 292 case SSL3_ST_SR_KEY_EXCH_B: 293 str = "SSLv3 read client key exchange B"; 294 break; 295 case SSL3_ST_SR_CERT_VRFY_A: 296 str = "SSLv3 read certificate verify A"; 297 break; 298 case SSL3_ST_SR_CERT_VRFY_B: 299 str = "SSLv3 read certificate verify B"; 300 break; 301 302 /* DTLS */ 303 case DTLS1_ST_CR_HELLO_VERIFY_REQUEST_A: 304 str = "DTLS1 read hello verify request A"; 305 break; 306 case DTLS1_ST_CR_HELLO_VERIFY_REQUEST_B: 307 str = "DTLS1 read hello verify request B"; 308 break; 309 case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_A: 310 str = "DTLS1 write hello verify request A"; 311 break; 312 case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_B: 313 str = "DTLS1 write hello verify request B"; 314 break; 315 316 default: 317 str = "unknown state"; 318 break; 319 } 320 return (str); 321 } 322 323 const char * 324 SSL_rstate_string_long(const SSL *s) 325 { 326 const char *str; 327 328 switch (s->internal->rstate) { 329 case SSL_ST_READ_HEADER: 330 str = "read header"; 331 break; 332 case SSL_ST_READ_BODY: 333 str = "read body"; 334 break; 335 case SSL_ST_READ_DONE: 336 str = "read done"; 337 break; 338 default: 339 str = "unknown"; 340 break; 341 } 342 return (str); 343 } 344 345 const char * 346 SSL_state_string(const SSL *s) 347 { 348 const char *str; 349 350 switch (s->s3->hs.state) { 351 case SSL_ST_BEFORE: 352 str = "PINIT "; 353 break; 354 case SSL_ST_ACCEPT: 355 str = "AINIT "; 356 break; 357 case SSL_ST_CONNECT: 358 str = "CINIT "; 359 break; 360 case SSL_ST_OK: 361 str = "SSLOK "; 362 break; 363 364 /* SSLv3 additions */ 365 case SSL3_ST_SW_FLUSH: 366 case SSL3_ST_CW_FLUSH: 367 str = "3FLUSH"; 368 break; 369 case SSL3_ST_CW_CLNT_HELLO_A: 370 str = "3WCH_A"; 371 break; 372 case SSL3_ST_CW_CLNT_HELLO_B: 373 str = "3WCH_B"; 374 break; 375 case SSL3_ST_CR_SRVR_HELLO_A: 376 str = "3RSH_A"; 377 break; 378 case SSL3_ST_CR_SRVR_HELLO_B: 379 str = "3RSH_B"; 380 break; 381 case SSL3_ST_CR_CERT_A: 382 str = "3RSC_A"; 383 break; 384 case SSL3_ST_CR_CERT_B: 385 str = "3RSC_B"; 386 break; 387 case SSL3_ST_CR_KEY_EXCH_A: 388 str = "3RSKEA"; 389 break; 390 case SSL3_ST_CR_KEY_EXCH_B: 391 str = "3RSKEB"; 392 break; 393 case SSL3_ST_CR_CERT_REQ_A: 394 str = "3RCR_A"; 395 break; 396 case SSL3_ST_CR_CERT_REQ_B: 397 str = "3RCR_B"; 398 break; 399 case SSL3_ST_CR_SRVR_DONE_A: 400 str = "3RSD_A"; 401 break; 402 case SSL3_ST_CR_SRVR_DONE_B: 403 str = "3RSD_B"; 404 break; 405 case SSL3_ST_CW_CERT_A: 406 str = "3WCC_A"; 407 break; 408 case SSL3_ST_CW_CERT_B: 409 str = "3WCC_B"; 410 break; 411 case SSL3_ST_CW_CERT_C: 412 str = "3WCC_C"; 413 break; 414 case SSL3_ST_CW_CERT_D: 415 str = "3WCC_D"; 416 break; 417 case SSL3_ST_CW_KEY_EXCH_A: 418 str = "3WCKEA"; 419 break; 420 case SSL3_ST_CW_KEY_EXCH_B: 421 str = "3WCKEB"; 422 break; 423 case SSL3_ST_CW_CERT_VRFY_A: 424 str = "3WCV_A"; 425 break; 426 case SSL3_ST_CW_CERT_VRFY_B: 427 str = "3WCV_B"; 428 break; 429 430 case SSL3_ST_SW_CHANGE_A: 431 case SSL3_ST_CW_CHANGE_A: 432 str = "3WCCSA"; 433 break; 434 case SSL3_ST_SW_CHANGE_B: 435 case SSL3_ST_CW_CHANGE_B: 436 str = "3WCCSB"; 437 break; 438 case SSL3_ST_SW_FINISHED_A: 439 case SSL3_ST_CW_FINISHED_A: 440 str = "3WFINA"; 441 break; 442 case SSL3_ST_SW_FINISHED_B: 443 case SSL3_ST_CW_FINISHED_B: 444 str = "3WFINB"; 445 break; 446 case SSL3_ST_SR_CHANGE_A: 447 case SSL3_ST_CR_CHANGE_A: 448 str = "3RCCSA"; 449 break; 450 case SSL3_ST_SR_CHANGE_B: 451 case SSL3_ST_CR_CHANGE_B: 452 str = "3RCCSB"; 453 break; 454 case SSL3_ST_SR_FINISHED_A: 455 case SSL3_ST_CR_FINISHED_A: 456 str = "3RFINA"; 457 break; 458 case SSL3_ST_SR_FINISHED_B: 459 case SSL3_ST_CR_FINISHED_B: 460 str = "3RFINB"; 461 break; 462 463 case SSL3_ST_SW_HELLO_REQ_A: 464 str = "3WHR_A"; 465 break; 466 case SSL3_ST_SW_HELLO_REQ_B: 467 str = "3WHR_B"; 468 break; 469 case SSL3_ST_SW_HELLO_REQ_C: 470 str = "3WHR_C"; 471 break; 472 case SSL3_ST_SR_CLNT_HELLO_A: 473 str = "3RCH_A"; 474 break; 475 case SSL3_ST_SR_CLNT_HELLO_B: 476 str = "3RCH_B"; 477 break; 478 case SSL3_ST_SR_CLNT_HELLO_C: 479 str = "3RCH_C"; 480 break; 481 case SSL3_ST_SW_SRVR_HELLO_A: 482 str = "3WSH_A"; 483 break; 484 case SSL3_ST_SW_SRVR_HELLO_B: 485 str = "3WSH_B"; 486 break; 487 case SSL3_ST_SW_CERT_A: 488 str = "3WSC_A"; 489 break; 490 case SSL3_ST_SW_CERT_B: 491 str = "3WSC_B"; 492 break; 493 case SSL3_ST_SW_KEY_EXCH_A: 494 str = "3WSKEA"; 495 break; 496 case SSL3_ST_SW_KEY_EXCH_B: 497 str = "3WSKEB"; 498 break; 499 case SSL3_ST_SW_CERT_REQ_A: 500 str = "3WCR_A"; 501 break; 502 case SSL3_ST_SW_CERT_REQ_B: 503 str = "3WCR_B"; 504 break; 505 case SSL3_ST_SW_SRVR_DONE_A: 506 str = "3WSD_A"; 507 break; 508 case SSL3_ST_SW_SRVR_DONE_B: 509 str = "3WSD_B"; 510 break; 511 case SSL3_ST_SR_CERT_A: 512 str = "3RCC_A"; 513 break; 514 case SSL3_ST_SR_CERT_B: 515 str = "3RCC_B"; 516 break; 517 case SSL3_ST_SR_KEY_EXCH_A: 518 str = "3RCKEA"; 519 break; 520 case SSL3_ST_SR_KEY_EXCH_B: 521 str = "3RCKEB"; 522 break; 523 case SSL3_ST_SR_CERT_VRFY_A: 524 str = "3RCV_A"; 525 break; 526 case SSL3_ST_SR_CERT_VRFY_B: 527 str = "3RCV_B"; 528 break; 529 530 /* DTLS */ 531 case DTLS1_ST_CR_HELLO_VERIFY_REQUEST_A: 532 str = "DRCHVA"; 533 break; 534 case DTLS1_ST_CR_HELLO_VERIFY_REQUEST_B: 535 str = "DRCHVB"; 536 break; 537 case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_A: 538 str = "DWCHVA"; 539 break; 540 case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_B: 541 str = "DWCHVB"; 542 break; 543 544 default: 545 str = "UNKWN "; 546 break; 547 } 548 return (str); 549 } 550 551 const char * 552 SSL_alert_type_string_long(int value) 553 { 554 value >>= 8; 555 if (value == SSL3_AL_WARNING) 556 return ("warning"); 557 else if (value == SSL3_AL_FATAL) 558 return ("fatal"); 559 else 560 return ("unknown"); 561 } 562 563 const char * 564 SSL_alert_type_string(int value) 565 { 566 value >>= 8; 567 if (value == SSL3_AL_WARNING) 568 return ("W"); 569 else if (value == SSL3_AL_FATAL) 570 return ("F"); 571 else 572 return ("U"); 573 } 574 575 const char * 576 SSL_alert_desc_string(int value) 577 { 578 const char *str; 579 580 switch (value & 0xff) { 581 case SSL_AD_CLOSE_NOTIFY: 582 str = "CN"; 583 break; 584 case SSL_AD_UNEXPECTED_MESSAGE: 585 str = "UM"; 586 break; 587 case SSL_AD_BAD_RECORD_MAC: 588 str = "BM"; 589 break; 590 case SSL_AD_DECOMPRESSION_FAILURE: 591 str = "DF"; 592 break; 593 case SSL_AD_HANDSHAKE_FAILURE: 594 str = "HF"; 595 break; 596 case SSL_AD_BAD_CERTIFICATE: 597 str = "BC"; 598 break; 599 case SSL_AD_UNSUPPORTED_CERTIFICATE: 600 str = "UC"; 601 break; 602 case SSL_AD_CERTIFICATE_REVOKED: 603 str = "CR"; 604 break; 605 case SSL_AD_CERTIFICATE_EXPIRED: 606 str = "CE"; 607 break; 608 case SSL_AD_CERTIFICATE_UNKNOWN: 609 str = "CU"; 610 break; 611 case SSL_AD_ILLEGAL_PARAMETER: 612 str = "IP"; 613 break; 614 case SSL_AD_RECORD_OVERFLOW: 615 str = "RO"; 616 break; 617 case SSL_AD_UNKNOWN_CA: 618 str = "CA"; 619 break; 620 case SSL_AD_ACCESS_DENIED: 621 str = "AD"; 622 break; 623 case SSL_AD_DECODE_ERROR: 624 str = "DE"; 625 break; 626 case SSL_AD_DECRYPT_ERROR: 627 str = "CY"; 628 break; 629 case SSL_AD_PROTOCOL_VERSION: 630 str = "PV"; 631 break; 632 case SSL_AD_INSUFFICIENT_SECURITY: 633 str = "IS"; 634 break; 635 case SSL_AD_INTERNAL_ERROR: 636 str = "IE"; 637 break; 638 case SSL_AD_USER_CANCELLED: 639 str = "US"; 640 break; 641 case SSL_AD_NO_RENEGOTIATION: 642 str = "NR"; 643 break; 644 case SSL_AD_MISSING_EXTENSION: 645 str = "ME"; 646 break; 647 case SSL_AD_UNSUPPORTED_EXTENSION: 648 str = "UE"; 649 break; 650 case SSL_AD_CERTIFICATE_UNOBTAINABLE: 651 str = "CO"; 652 break; 653 case SSL_AD_UNRECOGNIZED_NAME: 654 str = "UN"; 655 break; 656 case SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE: 657 str = "BR"; 658 break; 659 case SSL_AD_BAD_CERTIFICATE_HASH_VALUE: 660 str = "BH"; 661 break; 662 case SSL_AD_UNKNOWN_PSK_IDENTITY: 663 str = "UP"; 664 break; 665 default: 666 str = "UK"; 667 break; 668 } 669 return (str); 670 } 671 672 const char * 673 SSL_alert_desc_string_long(int value) 674 { 675 const char *str; 676 677 switch (value & 0xff) { 678 case SSL_AD_CLOSE_NOTIFY: 679 str = "close notify"; 680 break; 681 case SSL_AD_UNEXPECTED_MESSAGE: 682 str = "unexpected_message"; 683 break; 684 case SSL_AD_BAD_RECORD_MAC: 685 str = "bad record mac"; 686 break; 687 case SSL_AD_DECOMPRESSION_FAILURE: 688 str = "decompression failure"; 689 break; 690 case SSL_AD_HANDSHAKE_FAILURE: 691 str = "handshake failure"; 692 break; 693 case SSL_AD_BAD_CERTIFICATE: 694 str = "bad certificate"; 695 break; 696 case SSL_AD_UNSUPPORTED_CERTIFICATE: 697 str = "unsupported certificate"; 698 break; 699 case SSL_AD_CERTIFICATE_REVOKED: 700 str = "certificate revoked"; 701 break; 702 case SSL_AD_CERTIFICATE_EXPIRED: 703 str = "certificate expired"; 704 break; 705 case SSL_AD_CERTIFICATE_UNKNOWN: 706 str = "certificate unknown"; 707 break; 708 case SSL_AD_ILLEGAL_PARAMETER: 709 str = "illegal parameter"; 710 break; 711 case SSL_AD_RECORD_OVERFLOW: 712 str = "record overflow"; 713 break; 714 case SSL_AD_UNKNOWN_CA: 715 str = "unknown CA"; 716 break; 717 case SSL_AD_ACCESS_DENIED: 718 str = "access denied"; 719 break; 720 case SSL_AD_DECODE_ERROR: 721 str = "decode error"; 722 break; 723 case SSL_AD_DECRYPT_ERROR: 724 str = "decrypt error"; 725 break; 726 case SSL_AD_PROTOCOL_VERSION: 727 str = "protocol version"; 728 break; 729 case SSL_AD_INSUFFICIENT_SECURITY: 730 str = "insufficient security"; 731 break; 732 case SSL_AD_INTERNAL_ERROR: 733 str = "internal error"; 734 break; 735 case SSL_AD_USER_CANCELLED: 736 str = "user canceled"; 737 break; 738 case SSL_AD_NO_RENEGOTIATION: 739 str = "no renegotiation"; 740 break; 741 case SSL_AD_MISSING_EXTENSION: 742 str = "missing extension"; 743 break; 744 case SSL_AD_UNSUPPORTED_EXTENSION: 745 str = "unsupported extension"; 746 break; 747 case SSL_AD_CERTIFICATE_UNOBTAINABLE: 748 str = "certificate unobtainable"; 749 break; 750 case SSL_AD_UNRECOGNIZED_NAME: 751 str = "unrecognized name"; 752 break; 753 case SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE: 754 str = "bad certificate status response"; 755 break; 756 case SSL_AD_BAD_CERTIFICATE_HASH_VALUE: 757 str = "bad certificate hash value"; 758 break; 759 case SSL_AD_UNKNOWN_PSK_IDENTITY: 760 str = "unknown PSK identity"; 761 break; 762 default: 763 str = "unknown"; 764 break; 765 } 766 return (str); 767 } 768 769 const char * 770 SSL_rstate_string(const SSL *s) 771 { 772 const char *str; 773 774 switch (s->internal->rstate) { 775 case SSL_ST_READ_HEADER: 776 str = "RH"; 777 break; 778 case SSL_ST_READ_BODY: 779 str = "RB"; 780 break; 781 case SSL_ST_READ_DONE: 782 str = "RD"; 783 break; 784 default: 785 str = "unknown"; 786 break; 787 } 788 return (str); 789 } 790