1 /* ssl/ssl_stat.c */ 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 #include "ssl_locl.h" 87 88 const char *SSL_state_string_long(const SSL *s) 89 { 90 const char *str; 91 92 switch (s->state) { 93 case SSL_ST_BEFORE: 94 str = "before SSL initialization"; 95 break; 96 case SSL_ST_ACCEPT: 97 str = "before accept initialization"; 98 break; 99 case SSL_ST_CONNECT: 100 str = "before connect initialization"; 101 break; 102 case SSL_ST_OK: 103 str = "SSL negotiation finished successfully"; 104 break; 105 case SSL_ST_RENEGOTIATE: 106 str = "SSL renegotiate ciphers"; 107 break; 108 case SSL_ST_BEFORE | SSL_ST_CONNECT: 109 str = "before/connect initialization"; 110 break; 111 case SSL_ST_OK | SSL_ST_CONNECT: 112 str = "ok/connect SSL initialization"; 113 break; 114 case SSL_ST_BEFORE | SSL_ST_ACCEPT: 115 str = "before/accept initialization"; 116 break; 117 case SSL_ST_OK | SSL_ST_ACCEPT: 118 str = "ok/accept SSL initialization"; 119 break; 120 case SSL_ST_ERR: 121 str = "error"; 122 break; 123 #ifndef OPENSSL_NO_SSL2 124 case SSL2_ST_CLIENT_START_ENCRYPTION: 125 str = "SSLv2 client start encryption"; 126 break; 127 case SSL2_ST_SERVER_START_ENCRYPTION: 128 str = "SSLv2 server start encryption"; 129 break; 130 case SSL2_ST_SEND_CLIENT_HELLO_A: 131 str = "SSLv2 write client hello A"; 132 break; 133 case SSL2_ST_SEND_CLIENT_HELLO_B: 134 str = "SSLv2 write client hello B"; 135 break; 136 case SSL2_ST_GET_SERVER_HELLO_A: 137 str = "SSLv2 read server hello A"; 138 break; 139 case SSL2_ST_GET_SERVER_HELLO_B: 140 str = "SSLv2 read server hello B"; 141 break; 142 case SSL2_ST_SEND_CLIENT_MASTER_KEY_A: 143 str = "SSLv2 write client master key A"; 144 break; 145 case SSL2_ST_SEND_CLIENT_MASTER_KEY_B: 146 str = "SSLv2 write client master key B"; 147 break; 148 case SSL2_ST_SEND_CLIENT_FINISHED_A: 149 str = "SSLv2 write client finished A"; 150 break; 151 case SSL2_ST_SEND_CLIENT_FINISHED_B: 152 str = "SSLv2 write client finished B"; 153 break; 154 case SSL2_ST_SEND_CLIENT_CERTIFICATE_A: 155 str = "SSLv2 write client certificate A"; 156 break; 157 case SSL2_ST_SEND_CLIENT_CERTIFICATE_B: 158 str = "SSLv2 write client certificate B"; 159 break; 160 case SSL2_ST_SEND_CLIENT_CERTIFICATE_C: 161 str = "SSLv2 write client certificate C"; 162 break; 163 case SSL2_ST_SEND_CLIENT_CERTIFICATE_D: 164 str = "SSLv2 write client certificate D"; 165 break; 166 case SSL2_ST_GET_SERVER_VERIFY_A: 167 str = "SSLv2 read server verify A"; 168 break; 169 case SSL2_ST_GET_SERVER_VERIFY_B: 170 str = "SSLv2 read server verify B"; 171 break; 172 case SSL2_ST_GET_SERVER_FINISHED_A: 173 str = "SSLv2 read server finished A"; 174 break; 175 case SSL2_ST_GET_SERVER_FINISHED_B: 176 str = "SSLv2 read server finished B"; 177 break; 178 case SSL2_ST_GET_CLIENT_HELLO_A: 179 str = "SSLv2 read client hello A"; 180 break; 181 case SSL2_ST_GET_CLIENT_HELLO_B: 182 str = "SSLv2 read client hello B"; 183 break; 184 case SSL2_ST_GET_CLIENT_HELLO_C: 185 str = "SSLv2 read client hello C"; 186 break; 187 case SSL2_ST_SEND_SERVER_HELLO_A: 188 str = "SSLv2 write server hello A"; 189 break; 190 case SSL2_ST_SEND_SERVER_HELLO_B: 191 str = "SSLv2 write server hello B"; 192 break; 193 case SSL2_ST_GET_CLIENT_MASTER_KEY_A: 194 str = "SSLv2 read client master key A"; 195 break; 196 case SSL2_ST_GET_CLIENT_MASTER_KEY_B: 197 str = "SSLv2 read client master key B"; 198 break; 199 case SSL2_ST_SEND_SERVER_VERIFY_A: 200 str = "SSLv2 write server verify A"; 201 break; 202 case SSL2_ST_SEND_SERVER_VERIFY_B: 203 str = "SSLv2 write server verify B"; 204 break; 205 case SSL2_ST_SEND_SERVER_VERIFY_C: 206 str = "SSLv2 write server verify C"; 207 break; 208 case SSL2_ST_GET_CLIENT_FINISHED_A: 209 str = "SSLv2 read client finished A"; 210 break; 211 case SSL2_ST_GET_CLIENT_FINISHED_B: 212 str = "SSLv2 read client finished B"; 213 break; 214 case SSL2_ST_SEND_SERVER_FINISHED_A: 215 str = "SSLv2 write server finished A"; 216 break; 217 case SSL2_ST_SEND_SERVER_FINISHED_B: 218 str = "SSLv2 write server finished B"; 219 break; 220 case SSL2_ST_SEND_REQUEST_CERTIFICATE_A: 221 str = "SSLv2 write request certificate A"; 222 break; 223 case SSL2_ST_SEND_REQUEST_CERTIFICATE_B: 224 str = "SSLv2 write request certificate B"; 225 break; 226 case SSL2_ST_SEND_REQUEST_CERTIFICATE_C: 227 str = "SSLv2 write request certificate C"; 228 break; 229 case SSL2_ST_SEND_REQUEST_CERTIFICATE_D: 230 str = "SSLv2 write request certificate D"; 231 break; 232 case SSL2_ST_X509_GET_SERVER_CERTIFICATE: 233 str = "SSLv2 X509 read server certificate"; 234 break; 235 case SSL2_ST_X509_GET_CLIENT_CERTIFICATE: 236 str = "SSLv2 X509 read client certificate"; 237 break; 238 #endif 239 240 #ifndef OPENSSL_NO_SSL3 241 /* SSLv3 additions */ 242 case SSL3_ST_CW_CLNT_HELLO_A: 243 str = "SSLv3 write client hello A"; 244 break; 245 case SSL3_ST_CW_CLNT_HELLO_B: 246 str = "SSLv3 write client hello B"; 247 break; 248 case SSL3_ST_CR_SRVR_HELLO_A: 249 str = "SSLv3 read server hello A"; 250 break; 251 case SSL3_ST_CR_SRVR_HELLO_B: 252 str = "SSLv3 read server hello B"; 253 break; 254 case SSL3_ST_CR_CERT_A: 255 str = "SSLv3 read server certificate A"; 256 break; 257 case SSL3_ST_CR_CERT_B: 258 str = "SSLv3 read server certificate B"; 259 break; 260 case SSL3_ST_CR_KEY_EXCH_A: 261 str = "SSLv3 read server key exchange A"; 262 break; 263 case SSL3_ST_CR_KEY_EXCH_B: 264 str = "SSLv3 read server key exchange B"; 265 break; 266 case SSL3_ST_CR_CERT_REQ_A: 267 str = "SSLv3 read server certificate request A"; 268 break; 269 case SSL3_ST_CR_CERT_REQ_B: 270 str = "SSLv3 read server certificate request B"; 271 break; 272 case SSL3_ST_CR_SESSION_TICKET_A: 273 str = "SSLv3 read server session ticket A"; 274 break; 275 case SSL3_ST_CR_SESSION_TICKET_B: 276 str = "SSLv3 read server session ticket B"; 277 break; 278 case SSL3_ST_CR_SRVR_DONE_A: 279 str = "SSLv3 read server done A"; 280 break; 281 case SSL3_ST_CR_SRVR_DONE_B: 282 str = "SSLv3 read server done B"; 283 break; 284 case SSL3_ST_CW_CERT_A: 285 str = "SSLv3 write client certificate A"; 286 break; 287 case SSL3_ST_CW_CERT_B: 288 str = "SSLv3 write client certificate B"; 289 break; 290 case SSL3_ST_CW_CERT_C: 291 str = "SSLv3 write client certificate C"; 292 break; 293 case SSL3_ST_CW_CERT_D: 294 str = "SSLv3 write client certificate D"; 295 break; 296 case SSL3_ST_CW_KEY_EXCH_A: 297 str = "SSLv3 write client key exchange A"; 298 break; 299 case SSL3_ST_CW_KEY_EXCH_B: 300 str = "SSLv3 write client key exchange B"; 301 break; 302 case SSL3_ST_CW_CERT_VRFY_A: 303 str = "SSLv3 write certificate verify A"; 304 break; 305 case SSL3_ST_CW_CERT_VRFY_B: 306 str = "SSLv3 write certificate verify B"; 307 break; 308 309 case SSL3_ST_CW_CHANGE_A: 310 case SSL3_ST_SW_CHANGE_A: 311 str = "SSLv3 write change cipher spec A"; 312 break; 313 case SSL3_ST_CW_CHANGE_B: 314 case SSL3_ST_SW_CHANGE_B: 315 str = "SSLv3 write change cipher spec B"; 316 break; 317 case SSL3_ST_CW_FINISHED_A: 318 case SSL3_ST_SW_FINISHED_A: 319 str = "SSLv3 write finished A"; 320 break; 321 case SSL3_ST_CW_FINISHED_B: 322 case SSL3_ST_SW_FINISHED_B: 323 str = "SSLv3 write finished B"; 324 break; 325 case SSL3_ST_CR_CHANGE_A: 326 case SSL3_ST_SR_CHANGE_A: 327 str = "SSLv3 read change cipher spec A"; 328 break; 329 case SSL3_ST_CR_CHANGE_B: 330 case SSL3_ST_SR_CHANGE_B: 331 str = "SSLv3 read change cipher spec B"; 332 break; 333 case SSL3_ST_CR_FINISHED_A: 334 case SSL3_ST_SR_FINISHED_A: 335 str = "SSLv3 read finished A"; 336 break; 337 case SSL3_ST_CR_FINISHED_B: 338 case SSL3_ST_SR_FINISHED_B: 339 str = "SSLv3 read finished B"; 340 break; 341 342 case SSL3_ST_CW_FLUSH: 343 case SSL3_ST_SW_FLUSH: 344 str = "SSLv3 flush data"; 345 break; 346 347 case SSL3_ST_SR_CLNT_HELLO_A: 348 str = "SSLv3 read client hello A"; 349 break; 350 case SSL3_ST_SR_CLNT_HELLO_B: 351 str = "SSLv3 read client hello B"; 352 break; 353 case SSL3_ST_SR_CLNT_HELLO_C: 354 str = "SSLv3 read client hello C"; 355 break; 356 case SSL3_ST_SW_HELLO_REQ_A: 357 str = "SSLv3 write hello request A"; 358 break; 359 case SSL3_ST_SW_HELLO_REQ_B: 360 str = "SSLv3 write hello request B"; 361 break; 362 case SSL3_ST_SW_HELLO_REQ_C: 363 str = "SSLv3 write hello request C"; 364 break; 365 case SSL3_ST_SW_SRVR_HELLO_A: 366 str = "SSLv3 write server hello A"; 367 break; 368 case SSL3_ST_SW_SRVR_HELLO_B: 369 str = "SSLv3 write server hello B"; 370 break; 371 case SSL3_ST_SW_CERT_A: 372 str = "SSLv3 write certificate A"; 373 break; 374 case SSL3_ST_SW_CERT_B: 375 str = "SSLv3 write certificate B"; 376 break; 377 case SSL3_ST_SW_KEY_EXCH_A: 378 str = "SSLv3 write key exchange A"; 379 break; 380 case SSL3_ST_SW_KEY_EXCH_B: 381 str = "SSLv3 write key exchange B"; 382 break; 383 case SSL3_ST_SW_CERT_REQ_A: 384 str = "SSLv3 write certificate request A"; 385 break; 386 case SSL3_ST_SW_CERT_REQ_B: 387 str = "SSLv3 write certificate request B"; 388 break; 389 case SSL3_ST_SW_SESSION_TICKET_A: 390 str = "SSLv3 write session ticket A"; 391 break; 392 case SSL3_ST_SW_SESSION_TICKET_B: 393 str = "SSLv3 write session ticket B"; 394 break; 395 case SSL3_ST_SW_SRVR_DONE_A: 396 str = "SSLv3 write server done A"; 397 break; 398 case SSL3_ST_SW_SRVR_DONE_B: 399 str = "SSLv3 write server done B"; 400 break; 401 case SSL3_ST_SR_CERT_A: 402 str = "SSLv3 read client certificate A"; 403 break; 404 case SSL3_ST_SR_CERT_B: 405 str = "SSLv3 read client certificate B"; 406 break; 407 case SSL3_ST_SR_KEY_EXCH_A: 408 str = "SSLv3 read client key exchange A"; 409 break; 410 case SSL3_ST_SR_KEY_EXCH_B: 411 str = "SSLv3 read client key exchange B"; 412 break; 413 case SSL3_ST_SR_CERT_VRFY_A: 414 str = "SSLv3 read certificate verify A"; 415 break; 416 case SSL3_ST_SR_CERT_VRFY_B: 417 str = "SSLv3 read certificate verify B"; 418 break; 419 #endif 420 421 /* SSLv2/v3 compatibility states */ 422 /* client */ 423 case SSL23_ST_CW_CLNT_HELLO_A: 424 str = "SSLv2/v3 write client hello A"; 425 break; 426 case SSL23_ST_CW_CLNT_HELLO_B: 427 str = "SSLv2/v3 write client hello B"; 428 break; 429 case SSL23_ST_CR_SRVR_HELLO_A: 430 str = "SSLv2/v3 read server hello A"; 431 break; 432 case SSL23_ST_CR_SRVR_HELLO_B: 433 str = "SSLv2/v3 read server hello B"; 434 break; 435 /* server */ 436 case SSL23_ST_SR_CLNT_HELLO_A: 437 str = "SSLv2/v3 read client hello A"; 438 break; 439 case SSL23_ST_SR_CLNT_HELLO_B: 440 str = "SSLv2/v3 read client hello B"; 441 break; 442 443 /* DTLS */ 444 case DTLS1_ST_CR_HELLO_VERIFY_REQUEST_A: 445 str = "DTLS1 read hello verify request A"; 446 break; 447 case DTLS1_ST_CR_HELLO_VERIFY_REQUEST_B: 448 str = "DTLS1 read hello verify request B"; 449 break; 450 case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_A: 451 str = "DTLS1 write hello verify request A"; 452 break; 453 case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_B: 454 str = "DTLS1 write hello verify request B"; 455 break; 456 457 default: 458 str = "unknown state"; 459 break; 460 } 461 return (str); 462 } 463 464 const char *SSL_rstate_string_long(const SSL *s) 465 { 466 const char *str; 467 468 switch (s->rstate) { 469 case SSL_ST_READ_HEADER: 470 str = "read header"; 471 break; 472 case SSL_ST_READ_BODY: 473 str = "read body"; 474 break; 475 case SSL_ST_READ_DONE: 476 str = "read done"; 477 break; 478 default: 479 str = "unknown"; 480 break; 481 } 482 return (str); 483 } 484 485 const char *SSL_state_string(const SSL *s) 486 { 487 const char *str; 488 489 switch (s->state) { 490 case SSL_ST_BEFORE: 491 str = "PINIT "; 492 break; 493 case SSL_ST_ACCEPT: 494 str = "AINIT "; 495 break; 496 case SSL_ST_CONNECT: 497 str = "CINIT "; 498 break; 499 case SSL_ST_OK: 500 str = "SSLOK "; 501 break; 502 case SSL_ST_ERR: 503 str = "SSLERR"; 504 break; 505 #ifndef OPENSSL_NO_SSL2 506 case SSL2_ST_CLIENT_START_ENCRYPTION: 507 str = "2CSENC"; 508 break; 509 case SSL2_ST_SERVER_START_ENCRYPTION: 510 str = "2SSENC"; 511 break; 512 case SSL2_ST_SEND_CLIENT_HELLO_A: 513 str = "2SCH_A"; 514 break; 515 case SSL2_ST_SEND_CLIENT_HELLO_B: 516 str = "2SCH_B"; 517 break; 518 case SSL2_ST_GET_SERVER_HELLO_A: 519 str = "2GSH_A"; 520 break; 521 case SSL2_ST_GET_SERVER_HELLO_B: 522 str = "2GSH_B"; 523 break; 524 case SSL2_ST_SEND_CLIENT_MASTER_KEY_A: 525 str = "2SCMKA"; 526 break; 527 case SSL2_ST_SEND_CLIENT_MASTER_KEY_B: 528 str = "2SCMKB"; 529 break; 530 case SSL2_ST_SEND_CLIENT_FINISHED_A: 531 str = "2SCF_A"; 532 break; 533 case SSL2_ST_SEND_CLIENT_FINISHED_B: 534 str = "2SCF_B"; 535 break; 536 case SSL2_ST_SEND_CLIENT_CERTIFICATE_A: 537 str = "2SCC_A"; 538 break; 539 case SSL2_ST_SEND_CLIENT_CERTIFICATE_B: 540 str = "2SCC_B"; 541 break; 542 case SSL2_ST_SEND_CLIENT_CERTIFICATE_C: 543 str = "2SCC_C"; 544 break; 545 case SSL2_ST_SEND_CLIENT_CERTIFICATE_D: 546 str = "2SCC_D"; 547 break; 548 case SSL2_ST_GET_SERVER_VERIFY_A: 549 str = "2GSV_A"; 550 break; 551 case SSL2_ST_GET_SERVER_VERIFY_B: 552 str = "2GSV_B"; 553 break; 554 case SSL2_ST_GET_SERVER_FINISHED_A: 555 str = "2GSF_A"; 556 break; 557 case SSL2_ST_GET_SERVER_FINISHED_B: 558 str = "2GSF_B"; 559 break; 560 case SSL2_ST_GET_CLIENT_HELLO_A: 561 str = "2GCH_A"; 562 break; 563 case SSL2_ST_GET_CLIENT_HELLO_B: 564 str = "2GCH_B"; 565 break; 566 case SSL2_ST_GET_CLIENT_HELLO_C: 567 str = "2GCH_C"; 568 break; 569 case SSL2_ST_SEND_SERVER_HELLO_A: 570 str = "2SSH_A"; 571 break; 572 case SSL2_ST_SEND_SERVER_HELLO_B: 573 str = "2SSH_B"; 574 break; 575 case SSL2_ST_GET_CLIENT_MASTER_KEY_A: 576 str = "2GCMKA"; 577 break; 578 case SSL2_ST_GET_CLIENT_MASTER_KEY_B: 579 str = "2GCMKA"; 580 break; 581 case SSL2_ST_SEND_SERVER_VERIFY_A: 582 str = "2SSV_A"; 583 break; 584 case SSL2_ST_SEND_SERVER_VERIFY_B: 585 str = "2SSV_B"; 586 break; 587 case SSL2_ST_SEND_SERVER_VERIFY_C: 588 str = "2SSV_C"; 589 break; 590 case SSL2_ST_GET_CLIENT_FINISHED_A: 591 str = "2GCF_A"; 592 break; 593 case SSL2_ST_GET_CLIENT_FINISHED_B: 594 str = "2GCF_B"; 595 break; 596 case SSL2_ST_SEND_SERVER_FINISHED_A: 597 str = "2SSF_A"; 598 break; 599 case SSL2_ST_SEND_SERVER_FINISHED_B: 600 str = "2SSF_B"; 601 break; 602 case SSL2_ST_SEND_REQUEST_CERTIFICATE_A: 603 str = "2SRC_A"; 604 break; 605 case SSL2_ST_SEND_REQUEST_CERTIFICATE_B: 606 str = "2SRC_B"; 607 break; 608 case SSL2_ST_SEND_REQUEST_CERTIFICATE_C: 609 str = "2SRC_C"; 610 break; 611 case SSL2_ST_SEND_REQUEST_CERTIFICATE_D: 612 str = "2SRC_D"; 613 break; 614 case SSL2_ST_X509_GET_SERVER_CERTIFICATE: 615 str = "2X9GSC"; 616 break; 617 case SSL2_ST_X509_GET_CLIENT_CERTIFICATE: 618 str = "2X9GCC"; 619 break; 620 #endif 621 622 #ifndef OPENSSL_NO_SSL3 623 /* SSLv3 additions */ 624 case SSL3_ST_SW_FLUSH: 625 case SSL3_ST_CW_FLUSH: 626 str = "3FLUSH"; 627 break; 628 case SSL3_ST_CW_CLNT_HELLO_A: 629 str = "3WCH_A"; 630 break; 631 case SSL3_ST_CW_CLNT_HELLO_B: 632 str = "3WCH_B"; 633 break; 634 case SSL3_ST_CR_SRVR_HELLO_A: 635 str = "3RSH_A"; 636 break; 637 case SSL3_ST_CR_SRVR_HELLO_B: 638 str = "3RSH_B"; 639 break; 640 case SSL3_ST_CR_CERT_A: 641 str = "3RSC_A"; 642 break; 643 case SSL3_ST_CR_CERT_B: 644 str = "3RSC_B"; 645 break; 646 case SSL3_ST_CR_KEY_EXCH_A: 647 str = "3RSKEA"; 648 break; 649 case SSL3_ST_CR_KEY_EXCH_B: 650 str = "3RSKEB"; 651 break; 652 case SSL3_ST_CR_CERT_REQ_A: 653 str = "3RCR_A"; 654 break; 655 case SSL3_ST_CR_CERT_REQ_B: 656 str = "3RCR_B"; 657 break; 658 case SSL3_ST_CR_SRVR_DONE_A: 659 str = "3RSD_A"; 660 break; 661 case SSL3_ST_CR_SRVR_DONE_B: 662 str = "3RSD_B"; 663 break; 664 case SSL3_ST_CW_CERT_A: 665 str = "3WCC_A"; 666 break; 667 case SSL3_ST_CW_CERT_B: 668 str = "3WCC_B"; 669 break; 670 case SSL3_ST_CW_CERT_C: 671 str = "3WCC_C"; 672 break; 673 case SSL3_ST_CW_CERT_D: 674 str = "3WCC_D"; 675 break; 676 case SSL3_ST_CW_KEY_EXCH_A: 677 str = "3WCKEA"; 678 break; 679 case SSL3_ST_CW_KEY_EXCH_B: 680 str = "3WCKEB"; 681 break; 682 case SSL3_ST_CW_CERT_VRFY_A: 683 str = "3WCV_A"; 684 break; 685 case SSL3_ST_CW_CERT_VRFY_B: 686 str = "3WCV_B"; 687 break; 688 689 case SSL3_ST_SW_CHANGE_A: 690 case SSL3_ST_CW_CHANGE_A: 691 str = "3WCCSA"; 692 break; 693 case SSL3_ST_SW_CHANGE_B: 694 case SSL3_ST_CW_CHANGE_B: 695 str = "3WCCSB"; 696 break; 697 case SSL3_ST_SW_FINISHED_A: 698 case SSL3_ST_CW_FINISHED_A: 699 str = "3WFINA"; 700 break; 701 case SSL3_ST_SW_FINISHED_B: 702 case SSL3_ST_CW_FINISHED_B: 703 str = "3WFINB"; 704 break; 705 case SSL3_ST_SR_CHANGE_A: 706 case SSL3_ST_CR_CHANGE_A: 707 str = "3RCCSA"; 708 break; 709 case SSL3_ST_SR_CHANGE_B: 710 case SSL3_ST_CR_CHANGE_B: 711 str = "3RCCSB"; 712 break; 713 case SSL3_ST_SR_FINISHED_A: 714 case SSL3_ST_CR_FINISHED_A: 715 str = "3RFINA"; 716 break; 717 case SSL3_ST_SR_FINISHED_B: 718 case SSL3_ST_CR_FINISHED_B: 719 str = "3RFINB"; 720 break; 721 722 case SSL3_ST_SW_HELLO_REQ_A: 723 str = "3WHR_A"; 724 break; 725 case SSL3_ST_SW_HELLO_REQ_B: 726 str = "3WHR_B"; 727 break; 728 case SSL3_ST_SW_HELLO_REQ_C: 729 str = "3WHR_C"; 730 break; 731 case SSL3_ST_SR_CLNT_HELLO_A: 732 str = "3RCH_A"; 733 break; 734 case SSL3_ST_SR_CLNT_HELLO_B: 735 str = "3RCH_B"; 736 break; 737 case SSL3_ST_SR_CLNT_HELLO_C: 738 str = "3RCH_C"; 739 break; 740 case SSL3_ST_SW_SRVR_HELLO_A: 741 str = "3WSH_A"; 742 break; 743 case SSL3_ST_SW_SRVR_HELLO_B: 744 str = "3WSH_B"; 745 break; 746 case SSL3_ST_SW_CERT_A: 747 str = "3WSC_A"; 748 break; 749 case SSL3_ST_SW_CERT_B: 750 str = "3WSC_B"; 751 break; 752 case SSL3_ST_SW_KEY_EXCH_A: 753 str = "3WSKEA"; 754 break; 755 case SSL3_ST_SW_KEY_EXCH_B: 756 str = "3WSKEB"; 757 break; 758 case SSL3_ST_SW_CERT_REQ_A: 759 str = "3WCR_A"; 760 break; 761 case SSL3_ST_SW_CERT_REQ_B: 762 str = "3WCR_B"; 763 break; 764 case SSL3_ST_SW_SRVR_DONE_A: 765 str = "3WSD_A"; 766 break; 767 case SSL3_ST_SW_SRVR_DONE_B: 768 str = "3WSD_B"; 769 break; 770 case SSL3_ST_SR_CERT_A: 771 str = "3RCC_A"; 772 break; 773 case SSL3_ST_SR_CERT_B: 774 str = "3RCC_B"; 775 break; 776 case SSL3_ST_SR_KEY_EXCH_A: 777 str = "3RCKEA"; 778 break; 779 case SSL3_ST_SR_KEY_EXCH_B: 780 str = "3RCKEB"; 781 break; 782 case SSL3_ST_SR_CERT_VRFY_A: 783 str = "3RCV_A"; 784 break; 785 case SSL3_ST_SR_CERT_VRFY_B: 786 str = "3RCV_B"; 787 break; 788 #endif 789 790 /* SSLv2/v3 compatibility states */ 791 /* client */ 792 case SSL23_ST_CW_CLNT_HELLO_A: 793 str = "23WCHA"; 794 break; 795 case SSL23_ST_CW_CLNT_HELLO_B: 796 str = "23WCHB"; 797 break; 798 case SSL23_ST_CR_SRVR_HELLO_A: 799 str = "23RSHA"; 800 break; 801 case SSL23_ST_CR_SRVR_HELLO_B: 802 str = "23RSHA"; 803 break; 804 /* server */ 805 case SSL23_ST_SR_CLNT_HELLO_A: 806 str = "23RCHA"; 807 break; 808 case SSL23_ST_SR_CLNT_HELLO_B: 809 str = "23RCHB"; 810 break; 811 812 /* DTLS */ 813 case DTLS1_ST_CR_HELLO_VERIFY_REQUEST_A: 814 str = "DRCHVA"; 815 break; 816 case DTLS1_ST_CR_HELLO_VERIFY_REQUEST_B: 817 str = "DRCHVB"; 818 break; 819 case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_A: 820 str = "DWCHVA"; 821 break; 822 case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_B: 823 str = "DWCHVB"; 824 break; 825 826 default: 827 str = "UNKWN "; 828 break; 829 } 830 return (str); 831 } 832 833 const char *SSL_alert_type_string_long(int value) 834 { 835 value >>= 8; 836 if (value == SSL3_AL_WARNING) 837 return ("warning"); 838 else if (value == SSL3_AL_FATAL) 839 return ("fatal"); 840 else 841 return ("unknown"); 842 } 843 844 const char *SSL_alert_type_string(int value) 845 { 846 value >>= 8; 847 if (value == SSL3_AL_WARNING) 848 return ("W"); 849 else if (value == SSL3_AL_FATAL) 850 return ("F"); 851 else 852 return ("U"); 853 } 854 855 const char *SSL_alert_desc_string(int value) 856 { 857 const char *str; 858 859 switch (value & 0xff) { 860 case SSL3_AD_CLOSE_NOTIFY: 861 str = "CN"; 862 break; 863 case SSL3_AD_UNEXPECTED_MESSAGE: 864 str = "UM"; 865 break; 866 case SSL3_AD_BAD_RECORD_MAC: 867 str = "BM"; 868 break; 869 case SSL3_AD_DECOMPRESSION_FAILURE: 870 str = "DF"; 871 break; 872 case SSL3_AD_HANDSHAKE_FAILURE: 873 str = "HF"; 874 break; 875 case SSL3_AD_NO_CERTIFICATE: 876 str = "NC"; 877 break; 878 case SSL3_AD_BAD_CERTIFICATE: 879 str = "BC"; 880 break; 881 case SSL3_AD_UNSUPPORTED_CERTIFICATE: 882 str = "UC"; 883 break; 884 case SSL3_AD_CERTIFICATE_REVOKED: 885 str = "CR"; 886 break; 887 case SSL3_AD_CERTIFICATE_EXPIRED: 888 str = "CE"; 889 break; 890 case SSL3_AD_CERTIFICATE_UNKNOWN: 891 str = "CU"; 892 break; 893 case SSL3_AD_ILLEGAL_PARAMETER: 894 str = "IP"; 895 break; 896 case TLS1_AD_DECRYPTION_FAILED: 897 str = "DC"; 898 break; 899 case TLS1_AD_RECORD_OVERFLOW: 900 str = "RO"; 901 break; 902 case TLS1_AD_UNKNOWN_CA: 903 str = "CA"; 904 break; 905 case TLS1_AD_ACCESS_DENIED: 906 str = "AD"; 907 break; 908 case TLS1_AD_DECODE_ERROR: 909 str = "DE"; 910 break; 911 case TLS1_AD_DECRYPT_ERROR: 912 str = "CY"; 913 break; 914 case TLS1_AD_EXPORT_RESTRICTION: 915 str = "ER"; 916 break; 917 case TLS1_AD_PROTOCOL_VERSION: 918 str = "PV"; 919 break; 920 case TLS1_AD_INSUFFICIENT_SECURITY: 921 str = "IS"; 922 break; 923 case TLS1_AD_INTERNAL_ERROR: 924 str = "IE"; 925 break; 926 case TLS1_AD_USER_CANCELLED: 927 str = "US"; 928 break; 929 case TLS1_AD_NO_RENEGOTIATION: 930 str = "NR"; 931 break; 932 case TLS1_AD_UNSUPPORTED_EXTENSION: 933 str = "UE"; 934 break; 935 case TLS1_AD_CERTIFICATE_UNOBTAINABLE: 936 str = "CO"; 937 break; 938 case TLS1_AD_UNRECOGNIZED_NAME: 939 str = "UN"; 940 break; 941 case TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE: 942 str = "BR"; 943 break; 944 case TLS1_AD_BAD_CERTIFICATE_HASH_VALUE: 945 str = "BH"; 946 break; 947 case TLS1_AD_UNKNOWN_PSK_IDENTITY: 948 str = "UP"; 949 break; 950 default: 951 str = "UK"; 952 break; 953 } 954 return (str); 955 } 956 957 const char *SSL_alert_desc_string_long(int value) 958 { 959 const char *str; 960 961 switch (value & 0xff) { 962 case SSL3_AD_CLOSE_NOTIFY: 963 str = "close notify"; 964 break; 965 case SSL3_AD_UNEXPECTED_MESSAGE: 966 str = "unexpected_message"; 967 break; 968 case SSL3_AD_BAD_RECORD_MAC: 969 str = "bad record mac"; 970 break; 971 case SSL3_AD_DECOMPRESSION_FAILURE: 972 str = "decompression failure"; 973 break; 974 case SSL3_AD_HANDSHAKE_FAILURE: 975 str = "handshake failure"; 976 break; 977 case SSL3_AD_NO_CERTIFICATE: 978 str = "no certificate"; 979 break; 980 case SSL3_AD_BAD_CERTIFICATE: 981 str = "bad certificate"; 982 break; 983 case SSL3_AD_UNSUPPORTED_CERTIFICATE: 984 str = "unsupported certificate"; 985 break; 986 case SSL3_AD_CERTIFICATE_REVOKED: 987 str = "certificate revoked"; 988 break; 989 case SSL3_AD_CERTIFICATE_EXPIRED: 990 str = "certificate expired"; 991 break; 992 case SSL3_AD_CERTIFICATE_UNKNOWN: 993 str = "certificate unknown"; 994 break; 995 case SSL3_AD_ILLEGAL_PARAMETER: 996 str = "illegal parameter"; 997 break; 998 case TLS1_AD_DECRYPTION_FAILED: 999 str = "decryption failed"; 1000 break; 1001 case TLS1_AD_RECORD_OVERFLOW: 1002 str = "record overflow"; 1003 break; 1004 case TLS1_AD_UNKNOWN_CA: 1005 str = "unknown CA"; 1006 break; 1007 case TLS1_AD_ACCESS_DENIED: 1008 str = "access denied"; 1009 break; 1010 case TLS1_AD_DECODE_ERROR: 1011 str = "decode error"; 1012 break; 1013 case TLS1_AD_DECRYPT_ERROR: 1014 str = "decrypt error"; 1015 break; 1016 case TLS1_AD_EXPORT_RESTRICTION: 1017 str = "export restriction"; 1018 break; 1019 case TLS1_AD_PROTOCOL_VERSION: 1020 str = "protocol version"; 1021 break; 1022 case TLS1_AD_INSUFFICIENT_SECURITY: 1023 str = "insufficient security"; 1024 break; 1025 case TLS1_AD_INTERNAL_ERROR: 1026 str = "internal error"; 1027 break; 1028 case TLS1_AD_USER_CANCELLED: 1029 str = "user canceled"; 1030 break; 1031 case TLS1_AD_NO_RENEGOTIATION: 1032 str = "no renegotiation"; 1033 break; 1034 case TLS1_AD_UNSUPPORTED_EXTENSION: 1035 str = "unsupported extension"; 1036 break; 1037 case TLS1_AD_CERTIFICATE_UNOBTAINABLE: 1038 str = "certificate unobtainable"; 1039 break; 1040 case TLS1_AD_UNRECOGNIZED_NAME: 1041 str = "unrecognized name"; 1042 break; 1043 case TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE: 1044 str = "bad certificate status response"; 1045 break; 1046 case TLS1_AD_BAD_CERTIFICATE_HASH_VALUE: 1047 str = "bad certificate hash value"; 1048 break; 1049 case TLS1_AD_UNKNOWN_PSK_IDENTITY: 1050 str = "unknown PSK identity"; 1051 break; 1052 default: 1053 str = "unknown"; 1054 break; 1055 } 1056 return (str); 1057 } 1058 1059 const char *SSL_rstate_string(const SSL *s) 1060 { 1061 const char *str; 1062 1063 switch (s->rstate) { 1064 case SSL_ST_READ_HEADER: 1065 str = "RH"; 1066 break; 1067 case SSL_ST_READ_BODY: 1068 str = "RB"; 1069 break; 1070 case SSL_ST_READ_DONE: 1071 str = "RD"; 1072 break; 1073 default: 1074 str = "unknown"; 1075 break; 1076 } 1077 return (str); 1078 } 1079