ck_ssl.c

   1 char *cksslv = "SSL/TLS support, 8.0.221, 26 Feb 2004";
   2 /*
   3   C K _ S S L . C --  OpenSSL Interface for C-Kermit
   4
   5   Copyright (C) 1985, 2004,
   6     Trustees of Columbia University in the City of New York.
   7     All rights reserved.  See the C-Kermit COPYING.TXT file or the
   8     copyright text in the ckcmai.c module for disclaimer and permissions.
   9
  10     Author:  Jeffrey E Altman (jaltman@secure-endpoints.com)
  11                Secure Endpoints Inc., New York City
  12
  13   Provides:
  14
  15   . Telnet Auth SSL option compatible with Tim Hudson's hack.
  16   . Telnet START_TLS option
  17   . Configuration of certificate and key files
  18   . Certificate verification and revocation list checks
  19   . Client certificate to user id routine
  20
  21   Note: This code is written to be compatible with OpenSSL 0.9.6[abcdefgh]
  22   and 0.9.7 beta 5.
  23   It will also compile with version 0.9.5 although that is discouraged
  24   due to security weaknesses in that release.
  25 */
  26
  27 #include "ckcsym.h"
  28 #include "ckcdeb.h"
  29
  30 #ifdef CK_SSL
  31 #include "ckcnet.h"
  32 #include "ckuath.h"
  33
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #ifdef UNIX
  37 #include <netinet/in.h>
  38 #ifndef FREEBSD4
  39 #include <arpa/inet.h>
  40 #endif /* FREEBSD4 */
  41 #endif /* UNIX */
  42
  43 #ifdef DEC_TCPIP
  44 #include <time.h>
  45 #include <inet.h>
  46 #endif /* DEC_TCPIP */
  47
  48 #ifdef OS2
  49 extern char exedir[];
  50 #ifdef NT
  51 char * GetAppData(int);
  52 #endif
  53 #endif /* OS2 */
  54
  55 static int ssl_installed = 1;
  56 #endif /* CK_SSL */
  57 int
  58 ck_ssh_is_installed()
  59 {
  60 #ifdef SSHBUILTIN
  61 #ifdef SSLDLL
  62 #ifdef NT
  63     extern HINSTANCE hCRYPTO;
  64 #else /* NT */
  65     extern HMODULE hCRYPTO;
  66 #endif /* NT */
  67     debug(F111,"ck_ssh_is_installed","hCRYPTO",hCRYPTO);
  68     return(ssl_installed && (hCRYPTO != NULL));
  69 #else /* SSLDLL */
  70     return(ssl_installed);
  71 #endif /* SSLDLL */
  72 #else
  73     return 0;
  74 #endif
  75 }
  76
  77 int
  78 #ifdef CK_ANSIC
  79 ck_ssleay_is_installed(void)
  80 #else
  81 ck_ssleay_is_installed()
  82 #endif
  83 {
  84 #ifdef CK_SSL
  85 #ifdef SSLDLL
  86 #ifdef NT
  87     extern HINSTANCE hSSL, hCRYPTO;
  88 #else /* NT */
  89     extern HMODULE hSSL, hCRYPTO;
  90 #endif /* NT */
  91     debug(F111,"ck_ssleay_is_installed","hSSL",hSSL);
  92     debug(F111,"ck_ssleay_is_installed","hCRYPTO",hCRYPTO);
  93     return(ssl_installed && (hSSL != NULL) && (hCRYPTO != NULL));
  94 #else /* SSLDLL */
  95     return(ssl_installed);
  96 #endif /* SSLDLL */
  97 #else /* CK_SSL */
  98     return(0);
  99 #endif /* CK_SSL */
 100 }
 101
 102 #ifdef CK_SSL
 103 #include "ckcker.h"
 104 #include "ckucmd.h"                             /* For struct keytab */
 105 #include "ckctel.h"
 106 #include "ck_ssl.h"
 107 #ifdef UNIX
 108 #include <pwd.h>                    /* Password file for home directory */
 109 #endif /* UNIX */
 110 #ifdef OS2
 111 #include <process.h>
 112 #endif /* OS2 */
 113 #ifdef OS2ONLY
 114 #include "ckotcp.h"
 115 #endif /* OS2ONLY */
 116
 117 #ifdef SSLDLL
 118 int ssl_finished_messages = 0;
 119 #else /* SSLDLL */
 120 #ifdef OPENSSL_VERSION_NUMBER
 121 int ssl_finished_messages = (OPENSSL_VERSION_NUMBER >= 0x0090581fL);
 122 #else
 123 !ERROR This module requires OpenSSL 0.9.5a or higher
 124 #endif /* OPENSSL_VERSION_NUMBER */
 125 #endif /* SSLDLL */
 126
 127 static int auth_ssl_valid = 0;
 128 static char *auth_ssl_name = 0;    /* this holds the oneline name */
 129 char ssl_err[SSL_ERR_BFSZ]="";
 130
 131 BIO *bio_err=NULL;
 132 X509_STORE *crl_store = NULL;
 133
 134 #ifndef NOFTP
 135 #ifndef SYSFTP
 136 SSL *ssl_ftp_con             = NULL;
 137 SSL_CTX *ssl_ftp_ctx         = NULL;
 138 SSL *ssl_ftp_data_con        = NULL;
 139 int ssl_ftp_active_flag      = 0;
 140 int ssl_ftp_data_active_flag = 0;
 141 #endif /* SYSFTP */
 142 #endif /* NOFTP */
 143
 144 #ifndef NOHTTP
 145 SSL *tls_http_con            = NULL;
 146 SSL_CTX *tls_http_ctx        = NULL;
 147 int tls_http_active_flag     = 0;
 148 int ssl_http_initialized = 0;
 149 #endif /* NOHTTP */
 150
 151 SSL_CTX *ssl_ctx = NULL;
 152 SSL *ssl_con = NULL;
 153 int ssl_debug_flag = 0;
 154 int ssl_verbose_flag = 0;
 155 int ssl_only_flag = 0;
 156 int ssl_active_flag = 0;
 157 int ssl_verify_flag = SSL_VERIFY_PEER;
 158 int ssl_certsok_flag = 0;
 159 char *ssl_rsa_cert_file = NULL;
 160 char *ssl_rsa_cert_chain_file = NULL;
 161 char *ssl_rsa_key_file = NULL;
 162 char *ssl_dsa_cert_file = NULL;
 163 char *ssl_dsa_cert_chain_file = NULL;
 164 char *ssl_dh_key_file = NULL;
 165 char *ssl_crl_file = NULL;
 166 char *ssl_crl_dir = NULL;
 167 char *ssl_verify_file = NULL;
 168 char *ssl_verify_dir = NULL;
 169 char *ssl_dh_param_file = NULL;
 170 char *ssl_cipher_list = NULL;
 171 char *ssl_rnd_file = NULL;
 172
 173 SSL_CTX *tls_ctx = NULL;
 174 SSL *tls_con = NULL;
 175 int tls_only_flag = 0;
 176 int tls_active_flag = 0;
 177
 178 int ssl_initialized = 0;
 179 int ssl_verify_depth = -1; /* used to track depth in verify routines */
 180
 181 /* compile this set to 1 to negotiate SSL/TLS but not actually start it */
 182 int ssl_dummy_flag=0;
 183
 184 extern int inserver;
 185 extern int debses;
 186 extern int accept_complete;
 187 extern char szHostName[], szUserNameRequested[], szUserNameAuthenticated[];
 188
 189 _PROTOTYP(int X509_to_user,(X509 *, char *, int));
 190
 191 int
 192 #ifdef CK_ANSIC
 193 ssl_server_verify_callback(int ok, X509_STORE_CTX * ctx)
 194 #else /* CK_ANSIC */
 195 ssl_server_verify_callback(ok, ctx)
 196 int ok;
 197 X509_STORE_CTX *ctx;
 198 #endif /* CK_ANSIC */
 199 {
 200     static char *saved_subject=NULL;
 201     char *subject=NULL, *issuer=NULL;
 202     int depth,error;
 203     X509 *xs = NULL;
 204
 205     if ( ssl_certsok_flag )
 206         return(1);
 207
 208     error=X509_STORE_CTX_get_error(ctx);
 209     depth=X509_STORE_CTX_get_error_depth(ctx);
 210     xs=X509_STORE_CTX_get_current_cert(ctx);
 211
 212     if (depth==0) {
 213         /* clear things */
 214         if (saved_subject!=NULL) {
 215             free(saved_subject);
 216             saved_subject=NULL;
 217         }
 218         if (auth_ssl_name!=NULL) {
 219             free(auth_ssl_name);
 220             auth_ssl_name=NULL;
 221         }
 222     }
 223
 224
 225     if (ssl_debug_flag && !inserver) {
 226         printf("ssl:server_verify_callback:depth=%d ok=%d err=%d-%s\r\n",
 227             depth,ok,error,X509_verify_cert_error_string(error));
 228     }
 229
 230     /* first thing is to have a meaningful name for the current
 231      * certificate that is being verified ... and if we cannot
 232      * determine that then something is seriously wrong!
 233      */
 234     makestr(&subject,
 235             (char *)X509_NAME_oneline(X509_get_subject_name(xs),NULL,0));
 236     makestr(&issuer,
 237             (char *)X509_NAME_oneline(X509_get_issuer_name(xs),NULL,0));
 238     if (!subject || !subject[0] || !issuer || !issuer[0]) {
 239         ok = 0;
 240         goto return_time;
 241     }
 242
 243     if (ssl_verbose_flag && !inserver && depth != ssl_verify_depth) {
 244         printf("[%d] Certificate Subject:\r\n%s\r\n",depth,subject);
 245         printf("[%d] Certificate Issuer:\r\n%s\r\n",depth,issuer);
 246         ssl_verify_depth = depth;
 247     }
 248
 249     /* make sure that the certificate that has been presented */
 250     /* has not been revoked (if we have been given a CRL.     */
 251     ok =  ssl_verify_crl(ok, ctx);
 252
 253     /* if we have any form of error in secure mode we reject the connection */
 254     if (error!=X509_V_OK) {
 255         if (inserver) {
 256 #ifdef CKSYSLOG
 257             if (ckxsyslog >= SYSLG_LI && ckxlogging) {
 258                 cksyslog(SYSLG_LI, 0,
 259                           "X.509 Certificate verify failure",
 260                           (char *) subject,
 261                           (char *)X509_verify_cert_error_string(error)
 262                           );
 263             }
 264 #endif /* CKSYSLOG */
 265
 266         } else {
 267             if ( ssl_verify_flag &
 268                  (SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT))
 269                 printf("Error: ");
 270             else
 271                 printf("Warning: ");
 272             switch (error) {
 273             case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
 274                 printf("Certificate is self signed.\r\n");
 275                 break;
 276             case X509_V_ERR_CERT_HAS_EXPIRED:
 277                 printf("Certificate has expired.\r\n");
 278                 break;
 279             case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
 280                 printf(
 281   "Certificate issuer's certificate isn't available locally.\r\n");
 282                 break;
 283             case X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE:
 284                 printf("Unable to verify leaf signature.\r\n");
 285                 break;
 286             case X509_V_ERR_CERT_REVOKED:
 287                 printf("Certificate revoked.\r\n");
 288                 break;
 289             default:
 290                 printf("Error %d while verifying certificate.\r\n",
 291                        ctx->error);
 292                 break;
 293             }
 294         }
 295         ok = !(ssl_verify_flag & SSL_VERIFY_FAIL_IF_NO_PEER_CERT);
 296     } else {
 297         /* if we got all the way to the top of the tree then
 298          * we *can* use this certificate for a username to
 299          * match ... in all other cases we must not!
 300          */
 301         auth_ssl_name = saved_subject;
 302         saved_subject = NULL;
 303     }
 304
 305   return_time:
 306
 307     /* save the name if at least the first level is okay */
 308     if (depth == 0 && ok)
 309         makestr(&saved_subject,subject);
 310
 311     /* clean up things */
 312     if (subject!=NULL)
 313         free(subject);
 314     if (issuer!=NULL)
 315         free(issuer);
 316
 317     return ok;
 318 }
 319
 320 int
 321 #ifdef CK_ANSIC
 322 ssl_client_verify_callback(int ok, X509_STORE_CTX * ctx)
 323 #else
 324 ssl_client_verify_callback(ok, ctx)
 325 int ok;
 326 X509_STORE_CTX *ctx;
 327 #endif
 328 {
 329     char subject[256]="", issuer[256]="";
 330     int depth, error, len;
 331     X509 *xs;
 332
 333     xs=X509_STORE_CTX_get_current_cert(ctx);
 334     error=X509_STORE_CTX_get_error(ctx);
 335     depth=X509_STORE_CTX_get_error_depth(ctx);
 336
 337     if ( ssl_debug_flag )
 338         printf("ssl:client_verify_callback:depth=%d ok=%d err=%d-%s\r\n",
 339                 depth,ok,error,X509_verify_cert_error_string(error));
 340
 341     if ( ssl_certsok_flag ) {
 342         ok = 1;
 343     }
 344
 345     /* first thing is to have a meaningful name for the current
 346      * certificate that is being verified ... and if we cannot
 347      * determine that then something is seriously wrong!
 348      */
 349 #ifdef XN_FLAG_SEP_MULTILINE
 350     X509_NAME_print_ex(bio_err,X509_get_subject_name(xs),4,
 351                         XN_FLAG_SEP_MULTILINE);
 352     len = BIO_read(bio_err,subject,256);
 353     subject[len < 256 ? len : 255] = '\0';
 354     if (!subject[0]) {
 355         ERR_print_errors(bio_err);
 356         len = BIO_read(bio_err,ssl_err,SSL_ERR_BFSZ);
 357         ssl_err[len < SSL_ERR_BFSZ ? len : SSL_ERR_BFSZ] = '\0';
 358         uq_ok("X.509 Subject Name unavailable", ssl_err, 1, NULL, 0);
 359         ok=0;
 360         goto return_time;
 361     }
 362
 363     X509_NAME_print_ex(bio_err,X509_get_issuer_name(xs),4,
 364                         XN_FLAG_SEP_MULTILINE);
 365     len = BIO_read(bio_err,issuer,256);
 366     issuer[len < 256 ? len : 255] = '\0';
 367     if (!issuer[0]) {
 368         ERR_print_errors(bio_err);
 369         len = BIO_read(bio_err,ssl_err,SSL_ERR_BFSZ);
 370         ssl_err[len < SSL_ERR_BFSZ ? len : SSL_ERR_BFSZ] = '\0';
 371         uq_ok("X.509 Issuer Name unavailable", ssl_err, 1, NULL, 0);
 372         ok=0;
 373         goto return_time;
 374     }
 375 #else /* XN_FLAG_SEP_MULTILINE */
 376     X509_NAME_oneline(X509_get_subject_name(xs),subject,256);
 377     if (!subject[0]) {
 378         int len;
 379         ERR_print_errors(bio_err);
 380         len = BIO_read(bio_err,ssl_err,SSL_ERR_BFSZ);
 381         ssl_err[len < SSL_ERR_BFSZ ? len : SSL_ERR_BFSZ] = '\0';
 382         uq_ok("X.509 Subject Name unavailable", ssl_err, 1, NULL, 0);
 383         ok=0;
 384         goto return_time;
 385     }
 386
 387     X509_NAME_oneline(X509_get_issuer_name(xs),issuer,256);
 388     if (!issuer[0]) {
 389         int len;
 390         ERR_print_errors(bio_err);
 391         len = BIO_read(bio_err,ssl_err,SSL_ERR_BFSZ);
 392         ssl_err[len < SSL_ERR_BFSZ ? len : SSL_ERR_BFSZ] = '\0';
 393         uq_ok("X.509 Issuer Name unavailable", ssl_err, 1, NULL, 0);
 394         ok=0;
 395         goto return_time;
 396     }
 397 #endif /* XN_FLAG_SEP_MULTILINE */
 398
 399     if (ssl_verbose_flag && depth != ssl_verify_depth) {
 400         printf("[%d] Certificate Subject:\r\n%s\r\n",depth,subject);
 401         printf("[%d] Certificate Issuer:\r\n%s\r\n",depth,issuer);
 402         ssl_verify_depth = depth;
 403     }
 404
 405     ok = ssl_verify_crl(ok, ctx);
 406
 407     if ( !ok ) {
 408         char prefix[1024];
 409         /* if the server is using a self signed certificate then
 410          * we need to decide if that is good enough for us to
 411          * accept ...
 412          */
 413
 414         switch ( error ) {
 415         case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT: {
 416             if (ssl_verify_flag & SSL_VERIFY_FAIL_IF_NO_PEER_CERT) {
 417                 /* make 100% sure that in secure more we drop the
 418                  * connection if the server does not have a
 419                  * real certificate!
 420                  */
 421                 ckmakxmsg(prefix,1024,
 422                            "Error: Server has a self-signed certificate\n",
 423                            "[",ckitoa(depth),"] Certificate Subject=\n",subject,
 424                            "\n[",ckitoa(depth),"] Certificate Issuer=\n",issuer,
 425                            NULL,NULL,NULL);
 426
 427                 uq_ok(prefix, "Rejecting Connection", 1, NULL, 0);
 428
 429                 /* sometimes it is really handy to be able to debug things
 430                 * and still get a connection!
 431                 */
 432                 if (ssl_debug_flag) {
 433                     printf("SSL: debug -> ignoring cert required!\r\n");
 434                     ok=1;
 435                 } else {
 436                     ok=0;
 437                 }
 438                 goto return_time;
 439             } else if (ssl_verify_flag != SSL_VERIFY_NONE) {
 440                 ckmakxmsg(prefix,1024,
 441                            "Warning: Server has a self-signed certificate\n",
 442                            "[",ckitoa(depth),"] Certificate Subject=\n",subject,
 443                            "\n[",ckitoa(depth),"] Certificate Issuer=\n",issuer,
 444                            NULL,NULL,NULL);
 445
 446                 ok = uq_ok(prefix,
 447                            "Continue? (Y/N) ",
 448                            3, NULL, 0);
 449                 if ( ok < 0 )
 450                     ok = 0;
 451                 goto return_time;
 452             }
 453         }
 454         case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT:
 455             if (ssl_verify_flag & SSL_VERIFY_FAIL_IF_NO_PEER_CERT) {
 456                 /* make 100% sure that in secure more we drop the
 457                  * connection if the server does not have a
 458                  * real certificate!
 459                  */
 460                 ckmakxmsg(prefix,1024,
 461                            "Error: ",
 462                            (char *)X509_verify_cert_error_string(error),
 463                            "\nCertificate Issuer=\n",issuer,
 464                            NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
 465                 uq_ok(prefix, "Rejecting Connection", 1, NULL, 0);
 466
 467                 /* sometimes it is really handy to be able to debug things
 468                 * and still get a connection!
 469                 */
 470                 if (ssl_debug_flag) {
 471                     printf("SSL: debug -> ignoring cert required!\r\n");
 472                     ok=1;
 473                 } else {
 474                     ok=0;
 475                 }
 476                 goto return_time;
 477             } else if (ssl_verify_flag != SSL_VERIFY_NONE) {
 478                 ckmakxmsg(prefix,1024,
 479                            "Warning: ",
 480                            (char *)X509_verify_cert_error_string(error),
 481                            "\nCertificate Issuer=\n",issuer,
 482                            NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
 483                 ok = uq_ok(prefix, "Continue (Y/N)", 3, NULL, 0);
 484                 goto return_time;
 485             }
 486             break;
 487         case X509_V_ERR_CERT_NOT_YET_VALID:
 488         case X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD:
 489             if (ssl_verify_flag & SSL_VERIFY_FAIL_IF_NO_PEER_CERT) {
 490                 int len;
 491                 /* make 100% sure that in secure more we drop the
 492                  * connection if the server does not have a
 493                  * real certificate!
 494                  */
 495                 ASN1_TIME_print(bio_err,X509_get_notBefore(xs));
 496                 len = BIO_read(bio_err,ssl_err,SSL_ERR_BFSZ);
 497                 ssl_err[len < SSL_ERR_BFSZ ? len : SSL_ERR_BFSZ] = '\0';
 498                 ckmakxmsg(prefix,1024,
 499                            "Error: ",
 500                            (char *)X509_verify_cert_error_string(error),
 501                            "\nCertificate Subject=\n",subject,
 502                            "\nnotBefore=",ssl_err,
 503                            NULL,NULL,NULL,NULL,NULL,NULL);
 504                 uq_ok(prefix, "Rejecting Connection", 1, NULL, 0);
 505                 /* sometimes it is really handy to be able to debug things
 506                 * and still get a connection!
 507                 */
 508                 if (ssl_debug_flag) {
 509                     printf("SSL: debug -> ignoring cert required!\r\n");
 510                     ok=1;
 511                 } else {
 512                     ok=0;
 513                 }
 514                 goto return_time;
 515             } else if (ssl_verify_flag != SSL_VERIFY_NONE) {
 516                 int len;
 517                 ASN1_TIME_print(bio_err,X509_get_notBefore(xs));
 518                 len = BIO_read(bio_err,ssl_err,SSL_ERR_BFSZ);
 519                 ssl_err[len < SSL_ERR_BFSZ ? len : SSL_ERR_BFSZ] = '\0';
 520                 ckmakxmsg(prefix,1024,
 521                            "Warning: ",
 522                            (char *)X509_verify_cert_error_string(error),
 523                            "\nCertificate Subject=\n",subject,
 524                            "\n    notBefore=",ssl_err,
 525                            NULL,NULL,NULL,NULL,NULL,NULL);
 526                 ok = uq_ok(prefix, "Continue (Y/N)", 3, NULL, 0);
 527             }
 528             break;
 529         case X509_V_ERR_CERT_HAS_EXPIRED:
 530         case X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD:
 531             if (ssl_verify_flag & SSL_VERIFY_FAIL_IF_NO_PEER_CERT) {
 532                 int len;
 533                 /* make 100% sure that in secure more we drop the
 534                  * connection if the server does not have a
 535                  * real certificate!
 536                  */
 537                 ASN1_TIME_print(bio_err,X509_get_notAfter(xs));
 538                 len = BIO_read(bio_err,ssl_err,SSL_ERR_BFSZ);
 539                 ssl_err[len < SSL_ERR_BFSZ ? len : SSL_ERR_BFSZ] = '\0';
 540
 541                 ckmakxmsg(prefix,1024,
 542                            "Error: ",
 543                            (char *)X509_verify_cert_error_string(error),
 544                            "\nCertificate Subject=\n",subject,
 545                            "\n    notAfter=",ssl_err,
 546                            NULL,NULL,NULL,NULL,NULL,NULL);
 547                 uq_ok(prefix, "Rejecting Connection", 1, NULL, 0);
 548
 549                 /* sometimes it is really handy to be able to debug things
 550                 * and still get a connection!
 551                 */
 552                 if (ssl_debug_flag) {
 553                     printf("SSL: debug -> ignoring cert required!\r\n");
 554                     ok=1;
 555                 } else {
 556                     ok=0;
 557                 }
 558                 goto return_time;
 559             } else if (ssl_verify_flag != SSL_VERIFY_NONE) {
 560                 int len;
 561                 ASN1_TIME_print(bio_err,X509_get_notAfter(xs));
 562                 len = BIO_read(bio_err,ssl_err,SSL_ERR_BFSZ);
 563                 ssl_err[len < SSL_ERR_BFSZ ? len : SSL_ERR_BFSZ] = '\0';
 564                 ckmakxmsg(prefix,1024,
 565                            "Warning: ",
 566                            (char *)X509_verify_cert_error_string(error),
 567                            "\nCertificate Subject=\n",subject,
 568                            "\n    notAfter=",ssl_err,
 569                            NULL,NULL,NULL,NULL,NULL,NULL);
 570                 ok = uq_ok(prefix, "Continue (Y/N)", 3, NULL, 0);
 571             }
 572             break;
 573         case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
 574         case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
 575             /*
 576              * When an SSL server sends its certificates to the client there
 577              * are two" conventions": one is to send the complete certificate
 578              * chain and the other is to send the whole chain apart from the
 579              * root.
 580              *
 581              * You don't usually need the root because the root is normally
 582              * stored and trusted locally.
 583              *
 584              * So if you get the whole chain it will complain about the self
 585              * signed certificate whereas if the root is missing it says it
 586              * can't find the issuer certificate.
 587              */
 588             if (ssl_verify_flag & SSL_VERIFY_FAIL_IF_NO_PEER_CERT) {
 589                 /* make 100% sure that in secure more we drop the
 590                  * connection if the server does not have a
 591                  * real certificate!
 592                  */
 593                 ckmakxmsg(prefix,1024,
 594                            "Error: ",
 595                            (char *)X509_verify_cert_error_string(error),
 596                            "\nCertificate Issuer=\n",issuer,
 597                            NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
 598                 uq_ok(prefix, "Rejecting Connection", 1, NULL, 0);
 599                 /* sometimes it is really handy to be able to debug things
 600                 * and still get a connection!
 601                 */
 602                 if (ssl_debug_flag) {
 603                     printf("SSL: debug -> ignoring cert required!\r\n");
 604                     ok=1;
 605                 } else {
 606                     ok=0;
 607                 }
 608                 goto return_time;
 609             } else if (ssl_verify_flag != SSL_VERIFY_NONE) {
 610                 ckmakxmsg(prefix,1024,
 611                            "Warning: ",
 612                            (char *)X509_verify_cert_error_string(error),
 613                            "\nCertificate Issuer=\n",issuer,
 614                            NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
 615                 ok = uq_ok(prefix, "Continue (Y/N)", 3, NULL, 0);
 616 #ifdef NT
 617                 if (ok) {
 618                     /* if the user decides to accept the certificate
 619                      * offer to store it for future connections in
 620                      * the user's private store
 621                      */
 622                     ok = uq_ok(
 623   "Do you wish to store the certificate to verify future connections?",
 624                                "Continue (Y/N)", 3, NULL, 0);
 625                     if (ok)
 626                         ck_X509_save_cert_to_user_store(xs);
 627                 }
 628 #endif /* NT */
 629             }
 630             break;
 631         case X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE:
 632         case X509_V_ERR_UNABLE_TO_GET_CRL:
 633         case X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE:
 634         case X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE:
 635         case X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY:
 636         case X509_V_ERR_CERT_SIGNATURE_FAILURE:
 637         case X509_V_ERR_CRL_SIGNATURE_FAILURE:
 638         case X509_V_ERR_CRL_NOT_YET_VALID:
 639         case X509_V_ERR_CRL_HAS_EXPIRED:
 640         case X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD:
 641         case X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD:
 642         case X509_V_ERR_OUT_OF_MEM:
 643         case X509_V_ERR_CERT_CHAIN_TOO_LONG:
 644         case X509_V_ERR_CERT_REVOKED:
 645         case X509_V_ERR_APPLICATION_VERIFICATION:
 646         default:
 647             if (ssl_verify_flag & SSL_VERIFY_FAIL_IF_NO_PEER_CERT) {
 648                 /* make 100% sure that in secure mode we drop the
 649                  * connection if the server does not have a
 650                  * real certificate!
 651                  */
 652                 ckmakxmsg(prefix,1024,
 653                            "Error: ",
 654                            (char *)X509_verify_cert_error_string(error),
 655                            "\nCertificate Subject=\n",subject,
 656                            NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
 657                 uq_ok(prefix, "Rejecting Connection", 1, NULL, 0);
 658
 659                 /* sometimes it is really handy to be able to debug things
 660                 * and still get a connection!
 661                 */
 662                 if (ssl_debug_flag) {
 663                     printf("SSL: debug -> ignoring cert required!\r\n");
 664                     ok=1;
 665                 } else {
 666                     ok=0;
 667                 }
 668                 goto return_time;
 669             } else if (ssl_verify_flag != SSL_VERIFY_NONE) {
 670                 ckmakxmsg(prefix,1024,
 671                            "Warning: ",
 672                            (char *)X509_verify_cert_error_string(error),
 673                            "\nCertificate Subject=\n",subject,
 674                            NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
 675                 ok = uq_ok(prefix, "Continue (Y/N)", 3, NULL, 0);
 676             }
 677             break;
 678         }
 679     }
 680
 681   return_time:
 682     if ( ssl_debug_flag )
 683         printf("ssl:client_verify_callback => ok: %d\r\n",ok);
 684     return ok;
 685 }
 686
 687 VOID
 688 #ifdef CK_ANSIC
 689 ssl_client_info_callback(const SSL *s, int where, int ret)
 690 #else
 691 ssl_client_info_callback(s,where,ret)
 692 const SSL *s;
 693 int where;
 694 int ret;
 695 #endif /* CK_ANSIC */
 696 {
 697     if (inserver || !ssl_debug_flag)
 698         return;
 699
 700     switch ( where ) {
 701     case SSL_CB_CONNECT_LOOP:
 702         printf("SSL_connect:%s %s\r\n",
 703                 SSL_state_string((SSL *)s),SSL_state_string_long((SSL *)s));
 704         break;
 705     case SSL_CB_CONNECT_EXIT:
 706         if (ret == 0) {
 707             printf("SSL_connect:failed in %s %s\r\n",
 708                     SSL_state_string((SSL *)s),SSL_state_string_long((SSL *)s));
 709         } else if (ret < 0) {
 710             printf("SSL_connect:error in %s %s\r\n",
 711                     SSL_state_string((SSL *)s),SSL_state_string_long((SSL *)s));
 712         }
 713         break;
 714     case SSL_CB_ACCEPT_LOOP:
 715         printf("SSL_accept:%s %s\r\n",
 716                 SSL_state_string((SSL *)s),SSL_state_string_long((SSL *)s));
 717         break;
 718     case SSL_CB_ACCEPT_EXIT:
 719         if (ret == 0) {
 720             printf("SSL_accept:failed in %s %s\r\n",
 721                     SSL_state_string((SSL *)s),SSL_state_string_long((SSL *)s));
 722         } else if (ret < 0) {
 723             printf("SSL_accept:error in %s %s\r\n",
 724                     SSL_state_string((SSL *)s),SSL_state_string_long((SSL *)s));
 725         }
 726         break;
 727     case SSL_CB_READ_ALERT:
 728         printf("SSL_read_alert\r\n");
 729         break;
 730     case SSL_CB_WRITE_ALERT:
 731         printf("SSL_write_alert\r\n");
 732         break;
 733     case SSL_CB_HANDSHAKE_START:
 734         printf("SSL_handshake:%s %s\r\n",
 735                 SSL_state_string((SSL *)s),SSL_state_string_long((SSL *)s));
 736         break;
 737     case SSL_CB_HANDSHAKE_DONE:
 738         printf("SSL_handshake:%s %s\r\n",
 739                 SSL_state_string((SSL *)s),SSL_state_string_long((SSL *)s));
 740         break;
 741     }
 742 }
 743
 744 #ifdef USE_CERT_CB
 745 /* Return 1, client cert is available */
 746 /* Return 0, no client cert is available */
 747 /* Return -1, callback must be called again. SSL_want_x509_lookup() == 1 */
 748 int
 749 #ifdef CK_ANSIC
 750 ssl_client_cert_callback(SSL * s, X509 ** x509, EVP_PKEY ** pkey)
 751 #else /* CK_ANSIC */
 752 ssl_client_cert_callback(s, x509, pkey)
 753     SSL * s;
 754     X509 ** x509;
 755     EVP_PKEY ** pkey;
 756 #endif /* CK_ANSIC */
 757 {
 758     if ( ssl_debug_flag ) {
 759         const char * cipher_list=SSL_get_cipher(s);
 760         printf("ssl_client_cert_callback called (%s)\r\n",
 761                 cipher_list?cipher_list:"UNKNOWN");
 762     }
 763 #ifdef COMMENT
 764     if ( s == tls_con ) {
 765         if (tls_load_certs(tls_cts,tls_con,0)) {
 766             *x509 = SSL_get_certificate(s);
 767             *pkey = SSL_get_privatekey(s);
 768             return(1);
 769         }
 770     } else if ( s == ssl_con ) {
 771         if (tls_load_certs(ssl_ctx,ssl_con,0)) {
 772             *x509 = SSL_get_certificate(s);
 773             *pkey = SSL_get_privatekey(s);
 774             return(1);
 775         }
 776     }
 777     return(0);
 778 #else /* COMMENT */
 779     return(0);
 780 #endif /* COMMENT */
 781 }
 782 #endif /* USE_CERT_CB */
 783
 784 #ifndef MS_CALLBACK
 785 #define MS_CALLBACK
 786 #endif /* MS_CALLBACK */
 787
 788 static RSA MS_CALLBACK *
 789 #ifdef CK_ANSIC
 790 tmp_rsa_cb(SSL * s, int export, int keylength)
 791 #else /* CK_ANSIC */
 792 tmp_rsa_cb(s,export,keylength)
 793 SSL *s;
 794 int export;
 795 int keylength;
 796 #endif /* CK_ANSIC */
 797 {
 798     static RSA *rsa_tmp=NULL;
 799     extern int quiet;
 800
 801 #ifndef NO_RSA
 802     if (rsa_tmp == NULL)
 803     {
 804         if (ssl_debug_flag)
 805             printf("Generating temporary (%d bit) RSA key...\r\n",keylength);
 806
 807         rsa_tmp=RSA_generate_key(keylength,RSA_F4,NULL,NULL);
 808
 809         if (ssl_debug_flag)
 810             printf("\r\n");
 811     }
 812 #else /* NO_RSA */
 813     if (ssl_debug_flag)
 814         printf("Unable to generate temporary RSA key...\r\n");
 815 #endif
 816     return(rsa_tmp);
 817 }
 818
 819
 820 #ifndef NO_DH
 821 static unsigned char dh512_p[]={
 822     0xE9,0x4E,0x3A,0x64,0xFA,0x65,0x5F,0xA6,0x44,0xC7,0xFC,0xF1,
 823     0x16,0x8B,0x11,0x11,0x7A,0xF0,0xB2,0x49,0x80,0x56,0xA3,0xF8,
 824     0x0F,0x7D,0x01,0x68,0x5D,0xF6,0x8A,0xEA,0x8C,0xDD,0x01,0xDC,
 825     0x43,0x18,0xE0,0xC4,0x89,0x80,0xE6,0x2D,0x44,0x77,0x45,0xFD,
 826     0xBA,0xFC,0x43,0x35,0x12,0xC0,0xED,0x32,0xD3,0x16,0xEF,0x51,
 827     0x09,0x44,0xA2,0xDB,
 828 };
 829 static unsigned char dh512_g[]={
 830     0x05,
 831 };
 832
 833 static unsigned char dh768_p[]={
 834     0x8B,0x2A,0x8C,0x6C,0x0F,0x87,0xC7,0x34,0xEE,0x2E,0xFB,0x60,
 835     0x94,0xB3,0xBF,0x95,0xBA,0x84,0x74,0x86,0xEA,0xE0,0xA4,0x33,
 836     0xE0,0x8F,0x7C,0x79,0x5C,0x62,0xE2,0x91,0xC5,0x6D,0x68,0xB9,
 837     0x6C,0x5E,0x4E,0x94,0x0C,0x8E,0x56,0x8E,0xEB,0x98,0x7C,0x6E,
 838     0x0E,0xF2,0xD5,0xAA,0x22,0x27,0x3F,0x0F,0xAF,0x10,0xB5,0x0B,
 839     0x16,0xCC,0x05,0x27,0xBB,0x58,0x6D,0x61,0x4B,0x2B,0xAB,0xDC,
 840     0x6A,0x15,0xBC,0x36,0x75,0x4D,0xEC,0xAB,0xFA,0xB6,0xE1,0xB1,
 841     0x13,0x70,0xD8,0x77,0xCD,0x5E,0x51,0x77,0x81,0x0D,0x77,0x43,
 842 };
 843 static unsigned char dh768_g[]={
 844     0x05,
 845 };
 846
 847 static unsigned char dh1024_p[]={
 848     0xA4,0x75,0xCF,0x35,0x00,0xAF,0x3C,0x17,0xCE,0xB0,0xD0,0x52,
 849     0x43,0xA0,0x0E,0xFA,0xA2,0xC9,0xBE,0x0B,0x76,0x7A,0xD9,0x2E,
 850     0xF4,0x97,0xAC,0x02,0x24,0x69,0xF6,0x36,0x4F,0xAB,0xCC,0x43,
 851     0xC1,0x74,0xFF,0xA3,0xD4,0x04,0x0F,0x11,0x2B,0x6D,0x8C,0x47,
 852     0xC9,0xCF,0x40,0x93,0x9B,0x7D,0x1E,0x52,0x85,0xB2,0x17,0x55,
 853     0x9C,0xF2,0x41,0x02,0x2A,0x9D,0x5F,0x24,0x22,0xC6,0x04,0xC4,
 854     0xAB,0x92,0x6D,0xC7,0xC8,0xF3,0x41,0x58,0x6C,0x86,0xFD,0xB8,
 855     0x0F,0x2D,0xDD,0xBF,0xA8,0x40,0x0C,0x58,0xC8,0xF2,0x3F,0x18,
 856     0xEF,0xF1,0x93,0x3E,0xBA,0x16,0x41,0xBE,0x32,0x6C,0xC5,0x63,
 857     0xFF,0x8A,0x02,0x3D,0xAC,0xD5,0x5A,0x49,0x64,0x34,0x14,0x2E,
 858     0xFB,0x2E,0xE7,0x39,0x1A,0x0F,0x3C,0x33,
 859 };
 860 static unsigned char dh1024_g[]={
 861     0x05,
 862 };
 863
 864 static unsigned char dh1536_p[]={
 865     0xA3,0x2B,0x75,0x0E,0x7B,0x31,0x82,0xCA,0xF2,0xFC,0xF3,0x3D,
 866     0xCE,0x5F,0xCD,0x5B,0x95,0xF6,0x2F,0xA4,0x5D,0x08,0x26,0xD2,
 867     0x5F,0xC0,0x3F,0xC5,0xD8,0xA2,0xFE,0x83,0x26,0xBC,0xEB,0x7D,
 868     0xF0,0x4E,0xD2,0xA6,0xBB,0x3C,0x88,0x63,0xCE,0x98,0xDE,0x08,
 869     0xE2,0xE1,0xAF,0xE2,0x38,0xA8,0xFA,0x68,0x76,0x8D,0xBF,0xDF,
 870     0xBB,0x30,0x15,0xFE,0xBD,0x22,0xCC,0x03,0x4E,0x5E,0x33,0xA3,
 871     0x6D,0xD6,0x68,0x12,0x97,0x17,0x4B,0xB5,0x84,0x5F,0x5F,0xA3,
 872     0x5C,0x2F,0xA4,0x10,0xC1,0xAD,0xBF,0xAC,0x30,0xCA,0x47,0x64,
 873     0x63,0xFE,0xEE,0xEE,0xA1,0x64,0x73,0x70,0xAA,0xF9,0xFE,0xC6,
 874     0xAD,0x5E,0xF6,0xF3,0x9C,0xDF,0x34,0x53,0x34,0x72,0xA6,0xA4,
 875     0xBB,0x81,0x5A,0x43,0x41,0xFD,0x41,0x05,0x5B,0x77,0x7B,0x84,
 876     0x03,0xFA,0x8A,0xFA,0xF7,0x8E,0x0F,0xCB,0x51,0xA2,0xB8,0x45,
 877     0xFF,0x59,0x42,0xEF,0xCF,0xF6,0x25,0x37,0xE2,0x6D,0xFF,0x69,
 878     0x11,0xF5,0x77,0x59,0x79,0x1C,0x5F,0x05,0xFC,0x7A,0x65,0x81,
 879     0x03,0x4A,0x78,0xC6,0xE9,0x48,0x73,0xF6,0x10,0xBC,0x99,0x1C,
 880     0xEE,0x44,0x2F,0x8B,0x70,0xCA,0xA8,0xB6,0x02,0x83,0x3E,0x0B,
 881 };
 882 static unsigned char dh1536_g[]={
 883     0x05,
 884 };
 885
 886 static unsigned char dh2048_p[]={
 887     0xFA,0x4E,0xE4,0x3B,0xFA,0xC1,0x87,0xDD,0xE7,0xC6,0x8B,0xE6,
 888     0x13,0x85,0xBC,0x9B,0x2B,0x8B,0x5B,0x46,0xBB,0x8B,0x86,0x6D,
 889     0xD7,0xB6,0xD5,0x49,0xC5,0x54,0xF2,0x3E,0xD2,0x39,0x64,0x9B,
 890     0x0E,0x33,0x39,0x8F,0xFA,0xFA,0xD9,0x78,0xED,0x34,0x82,0x29,
 891     0x37,0x58,0x4D,0x5D,0x40,0xCB,0x69,0xE3,0x8A,0x9F,0x17,0x0C,
 892     0x01,0x23,0x6B,0x05,0x01,0xAF,0x33,0xDE,0xDF,0x1A,0xBB,0x7B,
 893     0x6A,0x9F,0xD8,0xED,0x8D,0x5E,0x44,0x19,0x5B,0xE0,0xB6,0x23,
 894     0xF9,0x7A,0x96,0x6E,0x94,0x33,0x31,0x49,0xBA,0x84,0xD5,0x12,
 895     0xD7,0x6D,0xDC,0x35,0x54,0x64,0xA3,0xD8,0x04,0x26,0xC5,0xAF,
 896     0x7F,0xE3,0xFE,0x6F,0xBE,0xD5,0x17,0x72,0x4B,0xA6,0xD0,0xA7,
 897     0x5F,0x18,0xF5,0xF0,0x2D,0x11,0x9A,0xF6,0xD5,0x3B,0x6C,0x61,
 898     0x3C,0x6F,0x8E,0x09,0x4F,0x2C,0xE1,0x26,0x06,0x51,0xB3,0x19,
 899     0x85,0x85,0x13,0xF9,0xC2,0x6E,0x80,0x28,0x9E,0x8A,0xA0,0x01,
 900     0x46,0xD1,0x85,0x44,0x8C,0xE6,0xEE,0x7E,0x1E,0x17,0x3D,0xBA,
 901     0x54,0xFF,0xE8,0x0E,0xDD,0x51,0xF3,0x74,0x7F,0x0D,0x0B,0xAB,
 902     0xCA,0x84,0x8D,0x24,0x5D,0x56,0xD4,0x47,0x02,0xFC,0x93,0x9F,
 903     0xAE,0x9B,0x5C,0xDB,0x63,0xEB,0x65,0x01,0x38,0xC2,0x7B,0x30,
 904     0x1E,0x17,0x1C,0x75,0xF5,0x16,0x3B,0x4F,0x5F,0x41,0x32,0xB5,
 905     0xFF,0x9E,0x61,0xFD,0xD2,0x62,0x6E,0xFD,0x8A,0x28,0x93,0x59,
 906     0x2D,0x70,0x14,0x4D,0xE1,0x86,0xD5,0x90,0xB4,0xDF,0x72,0x71,
 907     0xE0,0xB4,0xD0,0xD6,0x82,0x3A,0x4A,0x04,0x58,0x32,0x0B,0xD3,
 908     0x51,0x13,0x32,0x63,
 909 };
 910 static unsigned char dh2048_g[]={
 911     0x02,
 912 };
 913
 914 static DH *
 915 get_dh512()
 916 {
 917     DH *dh=NULL;
 918
 919     if ((dh=DH_new()) == NULL)
 920         return(NULL);
 921     dh->p=BN_bin2bn(dh512_p,sizeof(dh512_p),NULL);
 922     dh->g=BN_bin2bn(dh512_g,sizeof(dh512_g),NULL);
 923     if ((dh->p == NULL) || (dh->g == NULL))
 924         return(NULL);
 925     return(dh);
 926 }
 927
 928 static DH *
 929 get_dh768()
 930 {
 931     DH *dh=NULL;
 932
 933     if ((dh=DH_new()) == NULL)
 934         return(NULL);
 935     dh->p=BN_bin2bn(dh768_p,sizeof(dh768_p),NULL);
 936     dh->g=BN_bin2bn(dh768_g,sizeof(dh768_g),NULL);
 937     if ((dh->p == NULL) || (dh->g == NULL))
 938         return(NULL);
 939     return(dh);
 940 }
 941
 942 static DH *
 943 get_dh1024()
 944 {
 945     DH *dh=NULL;
 946
 947     if ((dh=DH_new()) == NULL)
 948         return(NULL);
 949     dh->p=BN_bin2bn(dh1024_p,sizeof(dh1024_p),NULL);
 950     dh->g=BN_bin2bn(dh1024_g,sizeof(dh1024_g),NULL);
 951     if ((dh->p == NULL) || (dh->g == NULL))
 952         return(NULL);
 953     return(dh);
 954 }
 955
 956 static DH *
 957 get_dh1536()
 958 {
 959     DH *dh=NULL;
 960
 961     if ((dh=DH_new()) == NULL)
 962         return(NULL);
 963     dh->p=BN_bin2bn(dh1536_p,sizeof(dh1536_p),NULL);
 964     dh->g=BN_bin2bn(dh1536_g,sizeof(dh1536_g),NULL);
 965     if ((dh->p == NULL) || (dh->g == NULL))
 966         return(NULL);
 967     return(dh);
 968 }
 969
 970 static DH *
 971 get_dh2048()
 972 {
 973     DH *dh=NULL;
 974
 975     if ((dh=DH_new()) == NULL)
 976         return(NULL);
 977     dh->p=BN_bin2bn(dh2048_p,sizeof(dh2048_p),NULL);
 978     dh->g=BN_bin2bn(dh2048_g,sizeof(dh2048_g),NULL);
 979     if ((dh->p == NULL) || (dh->g == NULL))
 980         return(NULL);
 981     return(dh);
 982 }
 983 #endif /* NO_DH */
 984
 985 static DH MS_CALLBACK *
 986 #ifdef CK_ANSIC
 987 tmp_dh_cb(SSL * s, int export, int keylength)
 988 #else /* CK_ANSIC */
 989 tmp_dh_cb(s,export,keylength)
 990 SSL *s;
 991 int export;
 992 int keylength;
 993 #endif /* CK_ANSIC */
 994 {
 995     static DH *dh_tmp=NULL;
 996     BIO *bio=NULL;
 997     extern int quiet;
 998
 999 #ifndef NO_DH
1000     if (dh_tmp == NULL)
1001     {
1002         if (ssl_dh_param_file  &&
1003              (bio=BIO_new_file(ssl_dh_param_file,"r")) != NULL)
1004             dh_tmp=PEM_read_bio_DHparams(bio,NULL,NULL,NULL);
1005         if (bio != NULL)
1006             BIO_free(bio);
1007
1008         if ( dh_tmp == NULL ) {
1009             if ( keylength < 768 )
1010                 dh_tmp = get_dh512();
1011             else if ( keylength < 1024 )
1012                 dh_tmp = get_dh768();
1013             else if ( keylength < 1536 )
1014                 dh_tmp = get_dh1024();
1015             else if ( keylength < 2048 )
1016                 dh_tmp = get_dh1536();
1017             else
1018                 dh_tmp = get_dh2048();
1019         }
1020     }
1021 #else /* NO_DH */
1022     if (ssl_debug_flag)
1023         printf("DH not supported...\r\n");
1024 #endif /* NO_DH */
1025     return(dh_tmp);
1026 }
1027
1028 static void
1029 ssl_display_comp(SSL * ssl)
1030 {
1031     if ( !ck_ssleay_is_installed() )
1032         return;
1033
1034     if (ssl == NULL)
1035         return;
1036
1037     if (ssl->expand == NULL || ssl->expand->meth == NULL)
1038         printf("Compression: None\r\n");
1039     else {
1040         printf("Compression: %s\r\n",ssl->expand->meth->name);
1041     }
1042 }
1043
1044 int
1045 #ifdef CK_ANSIC
1046 ssl_display_connect_details(SSL * ssl_con, int server, int verbose)
1047 #else /* CK_ANSIC */
1048 ssl_display_connect_details(ssl_con,server,verbose)
1049 SSL *ssl_con;
1050 int server;
1051 int verbose;
1052 #endif /* CK_ANSIC */
1053 {
1054     X509 *peer;
1055     SSL_CIPHER * cipher;
1056     const char *cipher_list;
1057     char buf[512]="";
1058
1059     if ( !ck_ssleay_is_installed() )
1060         return(0);
1061
1062     if ( inserver && !tn_deb )
1063         return(0);
1064
1065     /* the cipher list *can* be NULL ... useless but it happens! */
1066     cipher = SSL_get_current_cipher(ssl_con);
1067     cipher_list = SSL_CIPHER_get_name(cipher);
1068     SSL_CIPHER_description(cipher,buf,sizeof(buf));
1069     if (cipher_list==NULL)
1070         cipher_list="<NULL>";
1071     printf("[TLS - %s",buf);
1072     ssl_display_comp(ssl_con);
1073
1074     if ( server ) {
1075         cipher_list=SSL_get_shared_ciphers(ssl_con,buf,512);
1076         if (cipher_list==NULL)
1077             cipher_list="<NULL>";
1078         printf("[TLS - shared ciphers=%s]\r\n",
1079                 cipher_list);
1080         }
1081     if ( server || tn_deb ) {
1082         peer=SSL_get_peer_certificate(ssl_con);
1083         if (peer != NULL) {
1084             X509_NAME_oneline(X509_get_subject_name(peer),buf,512);
1085             printf("[TLS - subject=%s]\r\n",buf);
1086             X509_NAME_oneline(X509_get_issuer_name(peer),buf,512);
1087             printf("[TLS - issuer=%s]\r\n",buf);
1088             /* X509_free(peer); */
1089         } else if (!tls_is_krb5(0)) {
1090             if ( !sstelnet && !tcp_incoming ) {
1091                 printf("[TLS - No certificate provided.]\r\n");
1092                 printf(
1093      "[TLS - The identity of the host could not be verified.]\r\n");
1094             }
1095         }
1096     }
1097     return(0);
1098 }
1099
1100 /*
1101  * Use SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *, void * userdata)
1102  * to set the value of the userdata.  We are going to use it to store the
1103  * prompt.
1104  */
1105
1106 int
1107 #ifdef CK_ANSIC
1108 ssl_passwd_callback(char *buf, int len, int rwflag, VOID * userdata)
1109 #else /* CK_ANSIC */
1110 ssl_passwd_callback(buf,len,rwflag,userdata)
1111     char * buf; int len; int rwflag; VOID *userdata;
1112 #endif /* CK_ANSIC */
1113 {
1114     extern char pwbuf[];
1115     extern int  pwflg, pwcrypt;
1116     int   ok;
1117     char *prompt=NULL;
1118
1119     if ( pwbuf[0] && pwflg ) {
1120         int n;
1121         n = ckstrncpy(buf,pwbuf,len);
1122 #ifdef OS2
1123         if ( pwcrypt )
1124             ck_encrypt((char *)buf);
1125 #endif /* OS2 */
1126         return(n);
1127     }
1128
1129     if ( userdata == NULL )
1130         prompt="Enter certificate passphrase: ";
1131     else
1132         prompt=(char*)userdata;
1133     ok = uq_txt(NULL,prompt,2,NULL,buf,len,NULL,DEFAULT_UQ_TIMEOUT);
1134     return(ok > 0 ? strlen(buf) : 0);
1135 }
1136
1137
1138 /* Attempts to load certificate data into the TLS context structures */
1139 /* Returns 1 on success; 0 on failure */
1140 int
1141 tls_load_certs(SSL_CTX * ctx, SSL * con, int server)
1142 {
1143     int rc = 1;
1144     extern int quiet;
1145
1146     if ( !ck_ssleay_is_installed() )
1147         return(0);
1148
1149     debug(F111,"tls_load_certs","SSL_CTX",ctx);
1150     debug(F111,"tls_load_certs","SSL",con);
1151     debug(F111,"tls_load_certs","server",server);
1152
1153     if ( con ) {
1154         if (ssl_rsa_cert_file) {
1155             if ( ssl_debug_flag )
1156                 printf("Loading RSA certificate into SSL\r\n");
1157
1158             rc = SSL_use_certificate_file(con, ssl_rsa_cert_file,
1159                                                X509_FILETYPE_PEM);
1160             if (!rc)
1161             {
1162                 if ( !quiet || ssl_debug_flag )
1163                     printf("Error loading certificate from %s\r\n",
1164                             ssl_rsa_cert_file);
1165             } else {
1166                 if (!ssl_rsa_key_file || !ssl_rsa_key_file[0])
1167                     makestr(&ssl_rsa_key_file,ssl_rsa_cert_file);
1168
1169                 rc = SSL_use_PrivateKey_file(con, ssl_rsa_key_file,
1170                                                   X509_FILETYPE_PEM);
1171                 if (!rc)
1172                     rc = SSL_use_PrivateKey_file(con, ssl_rsa_cert_file,
1173                                                       X509_FILETYPE_PEM);
1174                 if (!rc)
1175                 {
1176                     if ( !quiet || ssl_debug_flag )
1177                         printf("Error loading key from %s\r\n",
1178                                 ssl_rsa_key_file);
1179                 } else {
1180                     rc = SSL_check_private_key(con);
1181                     if (!rc)
1182                     {
1183                         if ( ssl_debug_flag )
1184                             printf(
1185                 "Private key does not match the certificate public key\r\n");
1186                     }
1187                 }
1188             }
1189         }
1190
1191         if (ssl_dsa_cert_file) {
1192             if ( ssl_debug_flag )
1193                 printf("Loading DSA certificate into SSL\r\n");
1194
1195             rc = SSL_use_certificate_file(con, ssl_dsa_cert_file,
1196                                                X509_FILETYPE_PEM);
1197             if (!rc)
1198             {
1199                 if ( ssl_debug_flag ) {
1200                     printf("Error loading certificate from %s\r\n",
1201                             ssl_dsa_cert_file);
1202                 }
1203             } else {
1204                 if (!ssl_dh_key_file || !ssl_dh_key_file[0])
1205                     makestr(&ssl_dh_key_file,ssl_dsa_cert_file);
1206                 rc = SSL_use_PrivateKey_file(con, ssl_dh_key_file,
1207                                                   X509_FILETYPE_PEM);
1208                 if (!rc)
1209                     rc = SSL_use_PrivateKey_file(con, ssl_dsa_cert_file,
1210                                                       X509_FILETYPE_PEM);
1211                 if (!rc)
1212                 {
1213                     if ( !quiet || ssl_debug_flag ) {
1214                         printf("Error loading key from %s\r\n",
1215                                 ssl_dh_key_file);
1216                     }
1217                 } else {
1218                     rc = SSL_check_private_key(con);
1219                     if (!rc)
1220                     {
1221                         if ( ssl_debug_flag )
1222                             printf(
1223                    "Private key does not match the certificate public key\n");
1224                     }
1225                 }
1226             }
1227         }
1228     } else {
1229         if (ssl_rsa_cert_file) {
1230             if ( ssl_debug_flag )
1231                 printf("Loading RSA certificate into SSL\r\n");
1232
1233             rc = SSL_CTX_use_certificate_file(ctx, ssl_rsa_cert_file,
1234                                        X509_FILETYPE_PEM);
1235             if (!rc)
1236             {
1237                 if ( !quiet || ssl_debug_flag )
1238                     printf("Error loading certificate from %s\r\n",
1239                             ssl_rsa_cert_file);
1240             } else {
1241                 if (!ssl_rsa_key_file || !ssl_rsa_key_file[0])
1242                     makestr(&ssl_rsa_key_file,ssl_rsa_cert_file);
1243
1244                 rc = SSL_CTX_use_PrivateKey_file(ctx, ssl_rsa_key_file,
1245                                                   X509_FILETYPE_PEM);
1246                 if (!rc)
1247                   rc = SSL_CTX_use_PrivateKey_file(ctx, ssl_rsa_cert_file,
1248                                                    X509_FILETYPE_PEM);
1249                 if (!rc) {
1250                     if ( ssl_debug_flag )
1251                       printf("Error loading key from %s\r\n",ssl_rsa_key_file);
1252                 } else {
1253                     rc = SSL_CTX_check_private_key(ctx);
1254                     if (!rc) {
1255                         if ( ssl_debug_flag )
1256                           printf(
1257                 "Private key does not match the certificate public key\r\n");
1258                     }
1259                 }
1260             }
1261         }
1262         if (ssl_dsa_cert_file) {
1263             if ( ssl_debug_flag )
1264               printf("Loading DSA certificate into SSL\r\n");
1265
1266             rc = SSL_CTX_use_certificate_file(ctx, ssl_dsa_cert_file,
1267                                               X509_FILETYPE_PEM);
1268             if (!rc) {
1269                 if ( ssl_debug_flag ) {
1270                     printf("Error loading certificate from %s\r\n",
1271                            ssl_dsa_cert_file);
1272                 }
1273             } else {
1274                 if (!ssl_dh_key_file || !ssl_dh_key_file[0])
1275                     makestr(&ssl_dh_key_file,ssl_dsa_cert_file);
1276                 rc = SSL_CTX_use_PrivateKey_file(ctx, ssl_dh_key_file,
1277                                                   X509_FILETYPE_PEM);
1278                 if (!rc)
1279                   rc = SSL_CTX_use_PrivateKey_file(ctx, ssl_dsa_cert_file,
1280                                                       X509_FILETYPE_PEM);
1281                 if (!rc) {
1282                     if ( ssl_debug_flag )
1283                       printf("Error loading key from %s\r\n",ssl_dh_key_file);
1284                 } else {
1285                     rc = SSL_CTX_check_private_key(ctx);
1286                     if (!rc) {
1287                         if ( ssl_debug_flag )
1288                           printf(
1289                    "Private key does not match the certificate public key\n");
1290                     }
1291                 }
1292             }
1293         }
1294     }
1295
1296     if (ssl_rsa_cert_chain_file && server) {
1297         int skip1st = 0;
1298         if (ssl_debug_flag)
1299             printf("Loading RSA Certificate Chain into SSL\r\n");
1300         if (!ckstrcmp(ssl_rsa_cert_chain_file,ssl_rsa_cert_file,-1,
1301 #ifdef OS2
1302                        0
1303 #else
1304                        1
1305 #endif /* OS2 */
1306                        ))
1307             skip1st = 1;
1308         rc = SSL_CTX_use_certificate_chain_file(ctx,ssl_rsa_cert_chain_file);
1309         if (!rc && ssl_debug_flag)
1310                 printf("Error loading RSA Certificate Chain into SSL\r\n");
1311     }
1312     if (ssl_dsa_cert_chain_file && server) {
1313         int skip1st = 0;
1314         if (ssl_debug_flag)
1315             printf("Loading DSA Certificate Chain into SSL\r\n");
1316         if (!ckstrcmp(ssl_dsa_cert_chain_file,ssl_dsa_cert_file,-1,
1317 #ifdef OS2
1318                        0
1319 #else
1320                        1
1321 #endif /* OS2 */
1322                        ))
1323             skip1st = 1;
1324         rc = SSL_CTX_use_certificate_chain_file(ctx,ssl_dsa_cert_chain_file);
1325         if (!rc && ssl_debug_flag)
1326                 printf("Error loading DSA Certificate Chain into SSL\r\n");
1327     }
1328     return(rc);
1329 }
1330
1331 VOID
1332 #ifdef CK_ANSIC
1333 ssl_once_init(void)
1334 #else
1335 ssl_once_init()
1336 #endif /* CK_ANSIC */
1337 {
1338     COMP_METHOD * cm;
1339
1340     if ( !ck_ssleay_is_installed() )
1341         return;
1342
1343     debug(F111,"Kermit built for OpenSSL",OPENSSL_VERSION_TEXT,SSLEAY_VERSION_NUMBER);
1344 #ifndef OS2ONLY
1345     debug(F111,"OpenSSL Library",SSLeay_version(SSLEAY_VERSION),
1346            SSLeay());
1347     debug(F110,"OpenSSL Library",SSLeay_version(SSLEAY_BUILT_ON),0);
1348     debug(F110,"OpenSSL Library",SSLeay_version(SSLEAY_CFLAGS),0);
1349     debug(F110,"OpenSSL Library",SSLeay_version(SSLEAY_PLATFORM),0);
1350
1351     /* The following test is suggested by Richard Levitte */
1352     if (((OPENSSL_VERSION_NUMBER ^ SSLeay()) & 0xffffff0f)
1353 #ifdef OS2
1354          || ckstrcmp(OPENSSL_VERSION_TEXT,(char *)SSLeay_version(SSLEAY_VERSION),-1,1)
1355 #endif /* OS2 */
1356          ) {
1357         ssl_installed = 0;
1358         debug(F111,"OpenSSL Version does not match.  Built with",
1359                SSLeay_version(SSLEAY_VERSION),SSLEAY_VERSION_NUMBER);
1360         printf("?OpenSSL libraries do not match required version.");
1361         printf("  SSL\\TLS support disabled\r\n\r\n");
1362         bleep(BP_FAIL);
1363 #ifdef SSLDLL
1364         ck_ssl_unloaddll();
1365         ck_crypto_unloaddll();
1366 #endif /* SSLDLL */
1367         return;
1368     }
1369 #endif /* OS2ONLY */
1370
1371     /* init things so we will get meaningful error messages
1372     * rather than numbers
1373     */
1374     SSL_load_error_strings();
1375
1376 #ifdef SSHBUILTIN
1377     OPENSSL_add_all_algorithms_noconf();
1378 #else
1379     /* SSL_library_init() only loads those ciphers needs for SSL  */
1380     /* These happen to be a similar set to those required for SSH */
1381     /* but they are not a complete set of ciphers provided by the */
1382     /* crypto library.                                            */
1383     SSL_library_init();
1384 #endif /* SSHBUILTIN */
1385
1386 #ifdef ZLIB
1387     cm = COMP_zlib();
1388     if (cm != NULL && cm->type != NID_undef) {
1389         SSL_COMP_add_compression_method(0xe0, cm); /* EAY's ZLIB ID */
1390     }
1391 #endif /* ZLIB */
1392     cm = COMP_rle();
1393     if (cm != NULL && cm->type != NID_undef)
1394         SSL_COMP_add_compression_method(0xe1, cm); /* EAY's RLE ID */
1395
1396     /* Ensure the Random number generator has enough entropy */
1397     if ( !RAND_status() ) {
1398         char buffer[256]="";
1399         char randombytes[256];
1400         int rc1 = -1, rc2 = 1;  /* assume failure and success */
1401
1402         debug(F110,"ssl_once_init","!RAND_status()",0);
1403
1404         if ( ssl_rnd_file == NULL ) {
1405             debug(F110,"ssl_rnd_file","ssl_rnd_file is NULL",0);
1406             RAND_file_name(buffer,256);
1407             if ( buffer[0] )
1408                 makestr(&ssl_rnd_file, buffer);
1409             else
1410                 makestr(&ssl_rnd_file,".rnd");
1411         }
1412         debug(F110,"ssl_rnd_file",ssl_rnd_file,0);
1413
1414         rc1 = RAND_egd(ssl_rnd_file);
1415         debug(F111,"ssl_once_init","RAND_egd()",rc1);
1416         if ( rc1 <= 0 ) {
1417             rc2 = RAND_load_file(ssl_rnd_file, -1);
1418             debug(F111,"ssl_once_init","RAND_load_file()",rc1);
1419         }
1420
1421         if ( rc1 <= 0 && !rc2 )
1422         {
1423             time_t t = time(NULL);
1424             int tlen = sizeof(time_t);
1425             int pid = getpid();
1426             int plen = sizeof(int);
1427             int n;
1428 #ifndef RAND_MAX
1429 #define RAND_MAX 0x7FFF
1430 #endif
1431             debug(F110,"ssl_once_init","calling RAND_seed()",0);
1432
1433             RAND_seed((unsigned char *)&t, tlen);
1434             RAND_seed((unsigned char *)&pid, plen);
1435
1436             srand((unsigned int)t);
1437             sprintf(buffer, "%.0f", (((double)(rand()%RAND_MAX)/RAND_MAX)*
1438                                       (sizeof(randombytes)-128-1)));
1439             n = (atoi(buffer)+1)%(sizeof(randombytes)-128-1);
1440             RAND_seed(randombytes, 128);
1441         }
1442
1443         if ( !RAND_status() ) {
1444             debug(F110,"ssl_once_init","Unable to initialize PRNG",0);
1445             printf(" Unable to load 'random state'\n");
1446             printf(" SSL and TLS are unavailble.\n");
1447             printf(" Use SET AUTH SSL RANDOM-FILE <file> command to provide random data.\n");
1448             printf(" Specified file will be overwritten with new random data after use.\n");
1449             return;
1450         }
1451
1452         if ( ssl_rnd_file ) {
1453             int rc = RAND_write_file(ssl_rnd_file);
1454             debug(F111,"ssl_once_init","RAND_write_file()",rc);
1455         }
1456     }
1457
1458 #ifdef NT
1459     // Initialize additional OID types for use when saving certs to a file
1460     OBJ_create("2.99999.3","SET.ex3","SET x509v3 extension 3");
1461 #endif /* NT */
1462
1463     /* make sure we have somewhere we can log errors to */
1464     bio_err=BIO_new(BIO_s_mem());
1465
1466     debug(F100,"ssl_once_init() complete","",0);
1467 }
1468
1469 int
1470 #ifdef CK_ANSIC
1471 ssl_tn_init(int mode)
1472 #else
1473 ssl_tn_init(mode) int mode;
1474 #endif /* CK_ANSIC */
1475 {
1476 #ifdef KRB5
1477     extern char * k5_keytab;
1478     extern char * krb5_d_srv;
1479 #endif /* KRB5 */
1480     static int last_ssl_mode = -1;
1481     SSL * ssl_conx=NULL, * tls_conx=NULL;
1482
1483     ssl_initialized = 0;
1484
1485     if ( !ck_ssleay_is_installed() )
1486         return(0);
1487
1488     debug(F111,"ssl_tn_init","mode",mode);
1489
1490     if (ssl_debug_flag)
1491         printf("SSL_DEBUG_FLAG on\r\n");
1492
1493     if (last_ssl_mode != mode) {
1494         if (ssl_ctx) {
1495             SSL_CTX_free(ssl_ctx);
1496             ssl_ctx = NULL;
1497         }
1498         if (tls_ctx) {
1499             SSL_CTX_free(tls_ctx);
1500             tls_ctx = NULL;
1501         }
1502     }
1503
1504     if ( (last_ssl_mode != mode) || !ssl_ctx || !tls_ctx ) {
1505         if ( mode == SSL_CLIENT ) {
1506             ssl_ctx=(SSL_CTX *)SSL_CTX_new(SSLv23_client_method());
1507             /* This can fail because we do not have RSA available */
1508             if ( !ssl_ctx ) {
1509                 debug(F110,"ssl_tn_init","SSLv23_client_method failed",0);
1510                 ssl_ctx=(SSL_CTX *)SSL_CTX_new(SSLv3_client_method());
1511             }
1512             if ( !ssl_ctx ) {
1513                 debug(F110,"ssl_tn_init","SSLv3_client_method failed",0);
1514                 last_ssl_mode = -1;
1515                 return(0);
1516             }
1517 #ifndef COMMENT
1518             tls_ctx=(SSL_CTX *)SSL_CTX_new(TLSv1_client_method());
1519 #else /* COMMENT */
1520             tls_ctx=(SSL_CTX *)SSL_CTX_new(SSLv23_client_method());
1521             /* This can fail because we do not have RSA available */
1522             if ( !tls_ctx ) {
1523                 debug(F110,"ssl_tn_init","SSLv23_client_method failed",0);
1524                 tls_ctx=(SSL_CTX *)SSL_CTX_new(SSLv3_client_method());
1525             }
1526 #endif /* COMMENT */
1527             if ( !tls_ctx ) {
1528                 debug(F110,"ssl_tn_init","TLSv1_client_method failed",0);
1529                 last_ssl_mode = -1;
1530                 return(0);
1531             }
1532 #ifdef USE_CERT_CB
1533             SSL_CTX_set_client_cert_cb(ssl_ctx,ssl_client_cert_callback);
1534             SSL_CTX_set_client_cert_cb(tls_ctx,ssl_client_cert_callback);
1535 #endif /* USE_CERT_CB */
1536         } else if (mode == SSL_SERVER) {
1537             /* We are a server */
1538             ssl_ctx=(SSL_CTX *)SSL_CTX_new(SSLv23_server_method());
1539             /* This can fail because we do not have RSA available */
1540             if ( !ssl_ctx ) {
1541                 debug(F110,"ssl_tn_init","SSLv23_server_method failed",0);
1542                 ssl_ctx=(SSL_CTX *)SSL_CTX_new(SSLv3_server_method());
1543             }
1544             if ( !ssl_ctx ) {
1545                 debug(F110,"ssl_tn_init","SSLv3_server_method failed",0);
1546                 last_ssl_mode = -1;
1547                 return(0);
1548             }
1549 #ifdef COMMENT
1550             tls_ctx=(SSL_CTX *)SSL_CTX_new(TLSv1_server_method());
1551 #else /* COMMENT */
1552             tls_ctx=(SSL_CTX *)SSL_CTX_new(SSLv23_server_method());
1553             /* This can fail because we do not have RSA available */
1554             if ( !tls_ctx ) {
1555                 debug(F110,"ssl_tn_init","SSLv23_server_method failed",0);
1556                 tls_ctx=(SSL_CTX *)SSL_CTX_new(TLSv1_server_method());
1557             }
1558 #endif /* COMMENT */
1559             if ( !tls_ctx ) {
1560                 debug(F110,"ssl_tn_init","TLSv1_server_method failed",0);
1561                 last_ssl_mode = -1;
1562                 return(0);
1563             }
1564         } else /* Unknown mode */
1565             return(0);
1566
1567         if ( !inserver ) {
1568             SSL_CTX_set_default_passwd_cb(ssl_ctx,
1569                                    (pem_password_cb *)ssl_passwd_callback);
1570             SSL_CTX_set_default_passwd_cb(tls_ctx,
1571                                    (pem_password_cb *)ssl_passwd_callback);
1572         }
1573
1574         /* for SSL switch on all the interoperability and bug
1575          * workarounds so that we will communicate with people
1576          * that cannot read poorly written specs :-)
1577          * for TLS be sure to prevent use of SSLv2
1578          */
1579         SSL_CTX_set_options(ssl_ctx,SSL_OP_ALL|SSL_OP_NO_SSLv2);
1580         SSL_CTX_set_options(tls_ctx,
1581                  SSL_OP_NO_SSLv2|SSL_OP_SINGLE_DH_USE|SSL_OP_EPHEMERAL_RSA);
1582
1583         SSL_CTX_set_info_callback(ssl_ctx,ssl_client_info_callback);
1584         SSL_CTX_set_info_callback(tls_ctx,ssl_client_info_callback);
1585
1586 #ifndef COMMENT
1587         /* Set the proper caching mode */
1588         if ( mode == SSL_SERVER ) {
1589             SSL_CTX_set_session_cache_mode(ssl_ctx,SSL_SESS_CACHE_SERVER);
1590             SSL_CTX_set_session_cache_mode(tls_ctx,SSL_SESS_CACHE_SERVER);
1591         } else {
1592             SSL_CTX_set_session_cache_mode(ssl_ctx,SSL_SESS_CACHE_CLIENT);
1593             SSL_CTX_set_session_cache_mode(tls_ctx,SSL_SESS_CACHE_CLIENT);
1594         }
1595         SSL_CTX_set_session_id_context(ssl_ctx,(CHAR *)"1",1);
1596         SSL_CTX_set_session_id_context(tls_ctx,(CHAR *)"2",1);
1597 #else /* COMMENT */
1598         SSL_CTX_set_session_cache_mode(ssl_ctx,SSL_SESS_CACHE_OFF);
1599         SSL_CTX_set_session_cache_mode(tls_ctx,SSL_SESS_CACHE_OFF);
1600 #endif /* COMMENT */
1601     }
1602
1603     /* The server uses defaults for the certificate files. */
1604     /* The client does not.                                */
1605     if (mode == SSL_SERVER) {
1606         char cert_filepath[1024];
1607         const char * defdir = NULL;
1608         DH * dh = NULL;
1609
1610         defdir = getenv("SSL_CERT_DIR");
1611         if ( !defdir ) {
1612 #ifdef OS2
1613             defdir = exedir;
1614 #else /* OS2 */
1615             defdir = X509_get_default_cert_dir();
1616 #endif /* OS2 */
1617             debug(F110,"ssl_tn_init - setting default directory to",defdir,0);
1618         }
1619         if ( !defdir )
1620             defdir = "";
1621
1622         if (!ssl_rsa_cert_file) {
1623             /* we need to know the fullpath to the location of the
1624             * certificate that we will be running with as we cannot
1625             * be sure of the cwd when we are launched
1626             */
1627             sprintf(cert_filepath,"%s/%s",defdir,"telnetd-rsa.pem");
1628             if (zchki(cert_filepath) > 0)
1629                 makestr(&ssl_rsa_cert_file,cert_filepath);
1630         }
1631         if (ssl_rsa_cert_file && !ssl_rsa_key_file) {
1632             /* we need to know the fullpath to the location of the
1633             * certificate that we will be running with as we cannot
1634             * be sure of the cwd when we are launched
1635             */
1636             sprintf(cert_filepath,"%s/%s",defdir,"telnetd-rsa-key.pem");
1637             if (zchki(cert_filepath) > 0)
1638                 makestr(&ssl_rsa_key_file,cert_filepath);
1639         }
1640         if (!ssl_dsa_cert_file) {
1641             /* we need to know the fullpath to the location of the
1642             * certificate that we will be running with as we cannot
1643             * be sure of the cwd when we are launched
1644             */
1645             sprintf(cert_filepath,"%s/%s",defdir,"telnetd-dsa.pem");
1646             if (zchki(cert_filepath) > 0)
1647                 makestr(&ssl_dsa_cert_file,cert_filepath);
1648         }
1649         if (ssl_dsa_cert_file && !ssl_dh_key_file) {
1650             /* we need to know the fullpath to the location of the
1651             * certificate that we will be running with as we cannot
1652             * be sure of the cwd when we are launched
1653             */
1654             sprintf(cert_filepath,"%s/%s",defdir,"telnetd-dsa-key.pem");
1655             if (zchki(cert_filepath) > 0)
1656                 makestr(&ssl_dh_key_file,cert_filepath);
1657         }
1658         if (!ssl_crl_dir) {
1659             /* we need to know the fullpath to the location of the
1660             * certificate that we will be running with as we cannot
1661             * be sure of the cwd when we are launched
1662             */
1663             sprintf(cert_filepath,"%s/crl",defdir);
1664             if (zchki(cert_filepath) > 0)
1665                 makestr(&ssl_crl_dir,cert_filepath);
1666         }
1667
1668         if (ssl_only_flag && !tls_load_certs(ssl_ctx,ssl_con,1)) {
1669             debug(F110,"ssl_tn_init","Unable to load SSL certs",0);
1670             last_ssl_mode = -1;
1671             return(0);
1672         }
1673         if (tls_only_flag && !tls_load_certs(tls_ctx,tls_con,1)) {
1674             debug(F110,"ssl_tn_init","Unable to load TLS certs",0);
1675             last_ssl_mode = -1;
1676             return(0);
1677         }
1678
1679         if ( (last_ssl_mode != mode) || !ssl_ctx || !tls_ctx ) {
1680             /* we may require a temp 512 bit RSA key because of the
1681              * wonderful way export things work ... if so we generate
1682              * one now!
1683              */
1684
1685             SSL_CTX_set_tmp_rsa_callback(ssl_ctx, tmp_rsa_cb);
1686             SSL_CTX_set_tmp_dh_callback( ssl_ctx, tmp_dh_cb);
1687             SSL_CTX_set_tmp_rsa_callback(tls_ctx, tmp_rsa_cb);
1688             SSL_CTX_set_tmp_dh_callback( tls_ctx, tmp_dh_cb);
1689
1690             dh = tmp_dh_cb(NULL,0,512);
1691             SSL_CTX_set_tmp_dh(ssl_ctx,dh);
1692             SSL_CTX_set_tmp_dh(tls_ctx,dh);
1693
1694             /* The following code is only called if we are using a
1695              * certificate with an RSA public key and where the
1696              * certificate has a key length less than 512 bits or is
1697              * marked for signing only.  This is so we can support
1698              * the greatest legal privacy level with exportable clients.
1699              */
1700
1701             if (SSL_CTX_need_tmp_RSA(ssl_ctx) ||
1702                  SSL_CTX_need_tmp_RSA(tls_ctx))
1703             {
1704                 RSA *rsa;
1705
1706                 if ( ssl_debug_flag )
1707                     printf("Generating temp (512 bit) RSA key ...\r\n");
1708                 rsa=RSA_generate_key(512,RSA_F4,NULL,NULL);
1709                 if ( ssl_debug_flag )
1710                     printf("Generation of temp (512 bit) RSA key done\r\n");
1711
1712                 if (SSL_CTX_need_tmp_RSA(ssl_ctx)) {
1713                     if (!SSL_CTX_set_tmp_rsa(ssl_ctx,rsa)) {
1714                         if ( ssl_debug_flag )
1715                             printf(
1716   "Failed to assign generated temp RSA key to SSL!\r\n");
1717                     }
1718                 }
1719                 if (SSL_CTX_need_tmp_RSA(tls_ctx)) {
1720                     if (!SSL_CTX_set_tmp_rsa(tls_ctx,rsa)) {
1721                         if ( ssl_debug_flag )
1722                             printf(
1723   "Failed to assign generated temp RSA key to TLS!\r\n");
1724                     }
1725                 }
1726                 RSA_free(rsa);
1727                 if ( ssl_debug_flag )
1728                     printf("Assigned temp (512 bit) RSA key\r\n");
1729             }
1730         }
1731     }
1732
1733     /* make sure we will find certificates in the standard
1734      * location ... otherwise we don't look anywhere for
1735      * these things which is going to make client certificate
1736      * exchange rather useless :-)
1737      * In OS2, default values for ssl_verify_file and ssl_verify_path.
1738      */
1739
1740 #ifdef OS2
1741 #ifdef NT
1742     {
1743         /* The defaults in the SSL crypto library are not appropriate for OS/2 */
1744         char path[CKMAXPATH];
1745
1746         ckmakmsg(path,CKMAXPATH,exedir,"certs",NULL,NULL);
1747         if (isdir(path) &&
1748             SSL_CTX_load_verify_locations(tls_ctx,NULL,path) == 1)  {
1749             debug(F110,"ssl_tn_init certificate verify dir",path,0);
1750             if (ssl_debug_flag)
1751                 printf("  Certificate Verification Directory: %s\r\n",path);
1752             SSL_CTX_load_verify_locations(ssl_ctx,NULL,path);
1753         }
1754         ckmakmsg(path,CKMAXPATH,GetAppData(1),"kermit 95/certs",NULL,NULL);
1755         if (isdir(path) &&
1756             SSL_CTX_load_verify_locations(tls_ctx,NULL,path) == 1)  {
1757             debug(F110,"ssl_tn_init certificate verify dir",path,0);
1758             if (ssl_debug_flag)
1759                 printf("  Certificate Verification Directory: %s\r\n",path);
1760             SSL_CTX_load_verify_locations(ssl_ctx,NULL,path);
1761         }
1762         ckmakmsg(path,CKMAXPATH,GetAppData(0),"kermit 95/certs",NULL,NULL);
1763         if (isdir(path) &&
1764             SSL_CTX_load_verify_locations(tls_ctx,NULL,path) == 1)  {
1765             debug(F110,"ssl_tn_init certificate verify dir",path,0);
1766             if (ssl_debug_flag)
1767                 printf("  Certificate Verification Directory: %s\r\n",path);
1768             SSL_CTX_load_verify_locations(ssl_ctx,NULL,path);
1769         }
1770         ckmakmsg(path,CKMAXPATH,exedir,"ca_certs.pem",NULL,NULL);
1771         if (zchki(path) > 0 &&
1772             SSL_CTX_load_verify_locations(tls_ctx,path,NULL) == 1) {
1773             debug(F110,"ssl_tn_init certificate verify file",path,0);
1774             if (ssl_debug_flag)
1775                 printf("  Certificate Verification File: %s\r\n",path);
1776             SSL_CTX_load_verify_locations(ssl_ctx,path,NULL);
1777         }
1778         ckmakmsg(path,CKMAXPATH,GetAppData(1),"kermit 95/ca_certs.pem",NULL,NULL);
1779         if (zchki(path) > 0 &&
1780             SSL_CTX_load_verify_locations(tls_ctx,path,NULL) == 1) {
1781             debug(F110,"ssl_tn_init certificate verify file",path,0);
1782             if (ssl_debug_flag)
1783                 printf("  Certificate Verification File: %s\r\n",path);
1784             SSL_CTX_load_verify_locations(ssl_ctx,path,NULL);
1785         }
1786         ckmakmsg(path,CKMAXPATH,GetAppData(0),"kermit 95/ca_certs.pem",NULL,NULL);
1787         if (zchki(path) > 0 &&
1788             SSL_CTX_load_verify_locations(tls_ctx,path,NULL) == 1) {
1789             debug(F110,"ssl_tn_init certificate verify file",path,0);
1790             if (ssl_debug_flag)
1791                 printf("  Certificate Verification File: %s\r\n",path);
1792             SSL_CTX_load_verify_locations(ssl_ctx,path,NULL);
1793         }
1794     }
1795 #else /* NT */
1796     {
1797         /* The defaults in the SSL crypto library are not appropriate for OS/2 */
1798         char path[CKMAXPATH];
1799
1800         ckmakmsg(path,CKMAXPATH,exedir,"certs",NULL,NULL);
1801         if (isdir(path) &&
1802             SSL_CTX_load_verify_locations(tls_ctx,NULL,path) == 1)  {
1803             debug(F110,"ssl_tn_init certificate verify dir",path,0);
1804             if (ssl_debug_flag)
1805                 printf("  Certificate Verification Directory: %s\r\n",path);
1806             SSL_CTX_load_verify_locations(ssl_ctx,NULL,path);
1807         }
1808         ckmakmsg(path,CKMAXPATH,exedir,"ca_certs.pem",NULL,NULL);
1809         if (zchki(path) > 0 &&
1810             SSL_CTX_load_verify_locations(tls_ctx,path,NULL) == 1) {
1811             debug(F110,"ssl_tn_init certificate verify file",path,0);
1812             if (ssl_debug_flag)
1813                 printf("  Certificate Verification File: %s\r\n",path);
1814             SSL_CTX_load_verify_locations(ssl_ctx,path,NULL);
1815         }
1816     }
1817 #endif /* NT */
1818 #else /* OS2 */
1819     SSL_CTX_set_default_verify_paths(ssl_ctx);
1820     SSL_CTX_set_default_verify_paths(tls_ctx);
1821 #endif /* OS2 */
1822
1823     if (ssl_verify_file) {
1824         if (zchki(ssl_verify_file) > 0 &&
1825             SSL_CTX_load_verify_locations(tls_ctx,ssl_verify_file,NULL) == 1) {
1826             debug(F110,"ssl_tn_init certificate verify file",ssl_verify_file,0);
1827             if (ssl_debug_flag)
1828                 printf("  Certificate Verification File: %s\r\n",ssl_verify_file);
1829             SSL_CTX_load_verify_locations(ssl_ctx,ssl_verify_file,NULL);
1830         }
1831     }
1832     if (ssl_verify_dir && isdir(ssl_verify_dir)) {
1833         if (SSL_CTX_load_verify_locations(tls_ctx,NULL,ssl_verify_dir) == 1)  {
1834             debug(F110,"ssl_tn_init certificate verify dir",ssl_verify_dir,0);
1835             if (ssl_debug_flag)
1836                 printf("  Certificate Verification Directory: %s\r\n",ssl_verify_dir);
1837             SSL_CTX_load_verify_locations(ssl_ctx,NULL,ssl_verify_dir);
1838         }
1839     }
1840     if (mode == SSL_SERVER) {
1841         SSL_CTX_set_verify(ssl_ctx,
1842                      ssl_verify_flag?ssl_verify_flag|SSL_VERIFY_CLIENT_ONCE:0,
1843                            ssl_server_verify_callback);
1844         SSL_CTX_set_verify(tls_ctx,
1845                      ssl_verify_flag?ssl_verify_flag|SSL_VERIFY_CLIENT_ONCE:0,
1846                            ssl_server_verify_callback);
1847     } else {
1848         SSL_CTX_set_verify(ssl_ctx,ssl_verify_flag,
1849                            ssl_client_verify_callback);
1850         SSL_CTX_set_verify(tls_ctx,ssl_verify_flag,
1851                            ssl_client_verify_callback);
1852     }
1853
1854     /* Free the existing CRL Store */
1855     if (crl_store) {
1856         X509_STORE_free(crl_store);
1857         crl_store = NULL;
1858     }
1859
1860     /* set up the new CRL Store */
1861     crl_store = X509_STORE_new();
1862     if (crl_store) {
1863 #ifdef OS2
1864         char path[CKMAXPATH];
1865
1866         ckmakmsg(path,CKMAXPATH,exedir,"crls",NULL,NULL);
1867         if (isdir(path) &&
1868             X509_STORE_load_locations(crl_store,NULL,path) == 1) {
1869             debug(F110,"ssl_tn_init crl dir",path,0);
1870             if (ssl_debug_flag)
1871                 printf("  CRL Directory: %s\r\n",path);
1872         }
1873 #ifdef NT
1874         ckmakmsg(path,CKMAXPATH,GetAppData(1),"kermit 95/crls",NULL,NULL);
1875         if (isdir(path) &&
1876             X509_STORE_load_locations(crl_store,NULL,path) == 1) {
1877             debug(F110,"ssl_tn_init crl dir",path,0);
1878             if (ssl_debug_flag)
1879                 printf("  CRL Directory: %s\r\n",path);
1880         }
1881         ckmakmsg(path,CKMAXPATH,GetAppData(0),"kermit 95/crls",NULL,NULL);
1882         if (isdir(path) &&
1883             X509_STORE_load_locations(crl_store,NULL,path) == 1) {
1884             debug(F110,"ssl_tn_init crl dir",path,0);
1885             if (ssl_debug_flag)
1886                 printf("  CRL Directory: %s\r\n",path);
1887         }
1888 #endif /* NT */
1889
1890         ckmakmsg(path,CKMAXPATH,exedir,"ca_crls.pem",NULL,NULL);
1891         if (zchki(path) > 0 &&
1892             X509_STORE_load_locations(crl_store,path,NULL) == 1) {
1893             debug(F110,"ssl_tn_init crl file",path,0);
1894             if (ssl_debug_flag)
1895                 printf("  CRL File: %s\r\n",path);
1896         }
1897 #ifdef NT
1898         ckmakmsg(path,CKMAXPATH,GetAppData(1),"kermit 95/ca_crls.pem",NULL,NULL);
1899         if (zchki(path) > 0 &&
1900             X509_STORE_load_locations(crl_store,path,NULL) == 1) {
1901             debug(F110,"ssl_tn_init crl file",path,0);
1902             if (ssl_debug_flag)
1903                 printf("  CRL File: %s\r\n",path);
1904         }
1905         ckmakmsg(path,CKMAXPATH,GetAppData(0),"kermit 95/ca_crls.pem",NULL,NULL);
1906         if (zchki(path) > 0 &&
1907             X509_STORE_load_locations(crl_store,path,NULL) == 1) {
1908             debug(F110,"ssl_tn_init crl file",path,0);
1909             if (ssl_debug_flag)
1910                 printf("  CRL File: %s\r\n",path);
1911         }
1912 #endif /* NT */
1913 #endif /* OS2 */
1914
1915         if (ssl_crl_file || ssl_crl_dir) {
1916             if (ssl_crl_file && zchki(ssl_crl_file) > 0 &&
1917                 X509_STORE_load_locations(crl_store,ssl_crl_file,NULL) == 1) {
1918                 debug(F110,"ssl_tn_init crl file",ssl_crl_file,0);
1919                 if (ssl_debug_flag)
1920                     printf("  CRL File: %s\r\n",ssl_crl_file);
1921             }
1922             if (ssl_crl_dir && isdir(ssl_crl_dir) &&
1923                 X509_STORE_load_locations(crl_store,NULL,ssl_crl_dir) == 1) {
1924                 debug(F110,"ssl_tn_init crl dir",ssl_crl_dir,0);
1925                 if (ssl_debug_flag)
1926                     printf("  CRL Directory: %s\r\n",ssl_crl_dir);
1927             }
1928         }
1929 #ifndef OS2
1930         else {
1931             X509_STORE_set_default_paths(crl_store);
1932         }
1933 #endif /* OS2 */
1934     }
1935
1936 #ifndef COMMENT
1937     ssl_conx = ssl_con;
1938     ssl_con=(SSL *)SSL_new(ssl_ctx);
1939     if ( !ssl_con ) {
1940         debug(F110,"ssl_tn_init","SSL_new(ssl_con) failed",0);
1941         last_ssl_mode = -1;
1942         ssl_con = ssl_conx;
1943         return(0);
1944     }
1945     if (ssl_conx) {
1946         if ( mode == SSL_CLIENT ) {
1947             SSL_set_session(ssl_con, SSL_get_session(ssl_conx));
1948         }
1949 #ifdef SSL_KRB5
1950                 if (ssl_conx->kssl_ctx) {
1951                         kssl_ctx_free(ssl_conx->kssl_ctx);
1952                         ssl_conx->kssl_ctx = NULL;
1953                 }
1954 #endif /* SSL_KRB5 */
1955         SSL_free(ssl_conx);
1956         ssl_conx = NULL;
1957     }
1958     tls_conx = tls_con;
1959     tls_con=(SSL *)SSL_new(tls_ctx);
1960     if ( !tls_con ) {
1961         debug(F110,"ssl_tn_init","SSL_new(tls_con) failed",0);
1962         last_ssl_mode = -1;
1963         tls_con = tls_conx;
1964         return(0);
1965     }
1966     if (tls_conx) {
1967         if ( mode == SSL_CLIENT )
1968             SSL_set_session(tls_con, SSL_get_session(tls_conx));
1969 #ifdef SSL_KRB5
1970                 if (tls_conx->kssl_ctx) {
1971                         kssl_ctx_free(tls_conx->kssl_ctx);
1972                         tls_conx->kssl_ctx = NULL;
1973                 }
1974 #endif /* SSL_KRB5 */
1975         SSL_free(tls_conx);
1976         tls_conx = NULL;
1977     }
1978 #else /* COMMENT */
1979     /* I don't know why this does not work to reuse the connection. */
1980     if ( ssl_con ) {
1981         SSL_clear(ssl_con);
1982         SSL_set_session(ssl_con,NULL);
1983         SSL_set_accept_state(ssl_con) ;
1984     } else {
1985         ssl_con=(SSL *)SSL_new(ssl_ctx);
1986         if (!ssl_con) {
1987             debug(F110,"ssl_tn_init","SSL_new(ssl_ctx) failed",0);
1988             last_ssl_mode = -1;
1989             ssl_con = ssl_conx;
1990             return(0);
1991         }
1992     }
1993
1994     if ( tls_con ) {
1995         SSL_clear(tls_con);
1996         SSL_set_session(tls_con,NULL);
1997         SSL_set_accept_state(tls_con) ;
1998     } else {
1999         tls_con=(SSL *)SSL_new(tls_ctx);
2000         if ( !tls_con ) {
2001             debug(F110,"ssl_tn_init","SSL_new(tls_ctx) failed",0);
2002             last_ssl_mode = -1;
2003             tls_con = tls_conx;
2004             return(0);
2005         }
2006     }
2007 #endif /* COMMENT */
2008
2009 #ifdef SSL_KRB5
2010 #ifndef KRB5_SERVICE_NAME
2011 #define KRB5_SERVICE_NAME    "host"
2012 #endif
2013
2014     if (ssl_con->kssl_ctx == NULL)
2015         ssl_con->kssl_ctx = kssl_ctx_new();
2016     if (tls_con->kssl_ctx == NULL)
2017     tls_con->kssl_ctx = kssl_ctx_new();
2018     if (mode == SSL_SERVER) {
2019         if (ssl_con->kssl_ctx != NULL)
2020             kssl_ctx_setstring(ssl_con->kssl_ctx, KSSL_KEYTAB, k5_keytab);
2021         if (tls_con->kssl_ctx != NULL)
2022             kssl_ctx_setstring(tls_con->kssl_ctx, KSSL_KEYTAB, k5_keytab);
2023     } else {
2024         if (ssl_con->kssl_ctx != NULL)
2025             kssl_ctx_setstring(ssl_con->kssl_ctx, KSSL_SERVER, szHostName);
2026         if (tls_con->kssl_ctx != NULL)
2027             kssl_ctx_setstring(tls_con->kssl_ctx, KSSL_SERVER, szHostName);
2028     }
2029     kssl_ctx_setstring(ssl_con->kssl_ctx, KSSL_SERVICE,
2030                         krb5_d_srv ? krb5_d_srv : KRB5_SERVICE_NAME);
2031     kssl_ctx_setstring(tls_con->kssl_ctx, KSSL_SERVICE,
2032                         krb5_d_srv ? krb5_d_srv : KRB5_SERVICE_NAME);
2033 #endif /* SSL_KRB5 */
2034
2035     if (ssl_cipher_list) {
2036         SSL_set_cipher_list(ssl_con,ssl_cipher_list);
2037         SSL_set_cipher_list(tls_con,ssl_cipher_list);
2038     } else {
2039         char * p;
2040         if (p = getenv("SSL_CIPHER")) {
2041             SSL_set_cipher_list(ssl_con,p);
2042             SSL_set_cipher_list(tls_con,p);
2043         } else {
2044             SSL_set_cipher_list(ssl_con,DEFAULT_CIPHER_LIST);
2045             SSL_set_cipher_list(tls_con,DEFAULT_CIPHER_LIST);
2046         }
2047     }
2048
2049     ssl_verify_depth = -1;
2050
2051     if ( ssl_debug_flag )
2052         printf("SSL/TLS init done!\r\n");
2053
2054     ssl_initialized = 1;
2055     last_ssl_mode = mode;
2056     debug(F110,"ssl_tn_init","done",0);
2057     return(1);
2058 }
2059
2060 #ifndef NOHTTP
2061 int
2062 #ifdef CK_ANSIC
2063 ssl_http_init(char * hostname)
2064 #else
2065 ssl_http_init(hostname) char * hostname;
2066 #endif /* CK_ANSIC */
2067 {
2068 #ifdef KRB5
2069     extern char * k5_keytab;
2070     extern char * krb5_d_srv;
2071 #endif /* KRB5 */
2072     SSL * tls_conx=NULL;
2073
2074     ssl_http_initialized = 0;
2075
2076     if ( !ck_ssleay_is_installed() )
2077         return(0);
2078     debug(F110,"ssl_http_init",hostname,0);
2079
2080     if (ssl_debug_flag)
2081         printf("SSL_DEBUG_FLAG on\r\n");
2082
2083     if (!tls_http_ctx ) {
2084 #ifdef COMMENT
2085         /* too many web servers still do not support TLSv1 */
2086         tls_http_ctx=(SSL_CTX *)SSL_CTX_new(TLSv1_client_method());
2087 #else /* COMMENT */
2088         tls_http_ctx=(SSL_CTX *)SSL_CTX_new(SSLv23_client_method());
2089         /* This can fail because we do not have RSA available */
2090         if ( !tls_http_ctx ) {
2091             debug(F110,"ssl_http_init","SSLv23_client_method failed",0);
2092             tls_http_ctx=(SSL_CTX *)SSL_CTX_new(SSLv3_client_method());
2093         }
2094 #endif /* COMMENT */
2095         if ( !tls_http_ctx ) {
2096             debug(F110,"ssl_http_init","TLSv1_client_method failed",0);
2097             return(0);
2098         }
2099 #ifdef USE_CERT_CB
2100         SSL_CTX_set_client_cert_cb(tls_http_ctx,ssl_client_cert_callback);
2101 #endif /* USE_CERT_CB */
2102     }
2103
2104     SSL_CTX_set_default_passwd_cb(tls_http_ctx,
2105                                   (pem_password_cb *)ssl_passwd_callback);
2106
2107     /* for SSL switch on all the interoperability and bug
2108      * workarounds so that we will communicate with people
2109      * that cannot read poorly written specs :-)
2110      * for TLS be sure to prevent use of SSLv2
2111      */
2112     SSL_CTX_set_options(tls_http_ctx,
2113             SSL_OP_NO_SSLv2|SSL_OP_SINGLE_DH_USE|SSL_OP_EPHEMERAL_RSA);
2114
2115     SSL_CTX_set_info_callback(tls_http_ctx,ssl_client_info_callback);
2116
2117 #ifndef COMMENT
2118     SSL_CTX_set_session_cache_mode(tls_http_ctx,SSL_SESS_CACHE_CLIENT);
2119     SSL_CTX_set_session_id_context(tls_http_ctx,(CHAR *)"3",1);
2120 #else /* COMMENT */
2121     SSL_CTX_set_session_cache_mode(tls_http_ctx,SSL_SESS_CACHE_OFF);
2122 #endif /* COMMENT */
2123
2124     /* make sure we will find certificates in the standard
2125      * location ... otherwise we don't look anywhere for
2126      * these things which is going to make client certificate
2127      * exchange rather useless :-)
2128      */
2129
2130 #ifdef OS2
2131 #ifdef NT
2132     {
2133         /* The defaults in the SSL crypto library are not appropriate for OS/2 */
2134         char path[CKMAXPATH];
2135
2136         ckmakmsg(path,CKMAXPATH,exedir,"certs",NULL,NULL);
2137         if (SSL_CTX_load_verify_locations(tls_http_ctx,NULL,path) == 0)  {
2138             debug(F110,"ssl_http_init unable to load path",path,0);
2139             if (ssl_debug_flag)
2140                 printf("?Unable to load verify-dir: %s\r\n",path);
2141         }
2142
2143         ckmakmsg(path,CKMAXPATH,GetAppData(1),"kermit 95/certs",NULL,NULL);
2144         if (SSL_CTX_load_verify_locations(tls_http_ctx,NULL,path) == 0)  {
2145             debug(F110,"ssl_http_init unable to load path",path,0);
2146             if (ssl_debug_flag)
2147                 printf("?Unable to load verify-dir: %s\r\n",path);
2148         }
2149
2150         ckmakmsg(path,CKMAXPATH,GetAppData(0),"kermit 95/certs",NULL,NULL);
2151         if (SSL_CTX_load_verify_locations(tls_http_ctx,NULL,path) == 0)  {
2152             debug(F110,"ssl_http_init unable to load path",path,0);
2153             if (ssl_debug_flag)
2154                 printf("?Unable to load verify-dir: %s\r\n",path);
2155         }
2156
2157         ckmakmsg(path,CKMAXPATH,exedir,"ca_certs.pem",NULL,NULL);
2158         if (SSL_CTX_load_verify_locations(tls_http_ctx,path,NULL) == 0) {
2159             debug(F110,"ssl_http_init unable to load path",path,0);
2160             if (ssl_debug_flag)
2161                 printf("?Unable to load verify-file: %s\r\n",path);
2162         }
2163
2164         ckmakmsg(path,CKMAXPATH,GetAppData(1),"kermit 95/ca_certs.pem",NULL,NULL);
2165         if (SSL_CTX_load_verify_locations(tls_http_ctx,path,NULL) == 0) {
2166             debug(F110,"ssl_http_init unable to load path",path,0);
2167             if (ssl_debug_flag)
2168                 printf("?Unable to load verify-file: %s\r\n",path);
2169         }
2170
2171         ckmakmsg(path,CKMAXPATH,GetAppData(0),"kermit 95/ca_certs.pem",NULL,NULL);
2172         if (SSL_CTX_load_verify_locations(tls_http_ctx,path,NULL) == 0) {
2173             debug(F110,"ssl_http_init unable to load path",path,0);
2174             if (ssl_debug_flag)
2175                 printf("?Unable to load verify-file: %s\r\n",path);
2176         }
2177     }
2178 #else /* NT */
2179     {
2180         /* The defaults in the SSL crypto library are not appropriate for OS/2 */
2181         char path[CKMAXPATH];
2182
2183         ckmakmsg(path,CKMAXPATH,exedir,"certs",NULL,NULL);
2184         if (SSL_CTX_load_verify_locations(tls_http_ctx,NULL,path) == 0)  {
2185             debug(F110,"ssl_http_init unable to load path",path,0);
2186             if (ssl_debug_flag)
2187                 printf("?Unable to load verify-dir: %s\r\n",path);
2188         }
2189         ckmakmsg(path,CKMAXPATH,exedir,"ca_certs.pem",NULL,NULL);
2190         if (SSL_CTX_load_verify_locations(tls_http_ctx,path,NULL) == 0) {
2191             debug(F110,"ssl_http_init unable to load path",path,0);
2192             if (ssl_debug_flag)
2193                 printf("?Unable to load verify-file: %s\r\n",path);
2194         }
2195     }
2196 #endif /* NT */
2197 #else /* OS2 */
2198     SSL_CTX_set_default_verify_paths(tls_http_ctx);
2199 #endif /* OS2 */
2200
2201     if (ssl_verify_file &&
2202         SSL_CTX_load_verify_locations(tls_http_ctx,ssl_verify_file,NULL) == 0)  {
2203         debug(F110,"ssl_http_init unable to load ssl_verify_file",ssl_verify_file,0);
2204         if (ssl_debug_flag)
2205             printf("?Unable to load verify-file: %s\r\n",ssl_verify_file);
2206     }
2207     if (ssl_verify_dir &&
2208         SSL_CTX_load_verify_locations(tls_http_ctx,NULL,ssl_verify_dir) == 0)  {
2209         debug(F110,"ssl_http_init unable to load ssl_verify_dir",ssl_verify_dir,0);
2210         if (ssl_debug_flag)
2211             printf("?Unable to load verify-dir: %s\r\n",ssl_verify_dir);
2212     }
2213
2214     SSL_CTX_set_verify(tls_http_ctx,ssl_verify_flag,
2215                            ssl_client_verify_callback);
2216
2217     /* Free the existing CRL Store */
2218     if (crl_store) {
2219         X509_STORE_free(crl_store);
2220         crl_store = NULL;
2221     }
2222
2223     /* set up the new CRL Store */
2224     crl_store = X509_STORE_new();
2225     if (crl_store) {
2226 #ifdef OS2
2227         char path[CKMAXPATH];
2228
2229         ckmakmsg(path,CKMAXPATH,exedir,"crls",NULL,NULL);
2230         if (X509_STORE_load_locations(crl_store,NULL,path) == 0) {
2231             debug(F110,"ssl_http_init unable to load dir",path,0);
2232             if (ssl_debug_flag)
2233                 printf("?Unable to load crl-dir: %s\r\n",path);
2234         }
2235 #ifdef NT
2236         ckmakmsg(path,CKMAXPATH,GetAppData(1),"kermit 95/crls",NULL,NULL);
2237         if (X509_STORE_load_locations(crl_store,NULL,path) == 0) {
2238             debug(F110,"ssl_http_init unable to load dir",path,0);
2239             if (ssl_debug_flag)
2240                 printf("?Unable to load crl-dir: %s\r\n",path);
2241         }
2242         ckmakmsg(path,CKMAXPATH,GetAppData(0),"kermit 95/crls",NULL,NULL);
2243         if (X509_STORE_load_locations(crl_store,NULL,path) == 0) {
2244             debug(F110,"ssl_http_init unable to load dir",path,0);
2245             if (ssl_debug_flag)
2246                 printf("?Unable to load crl-dir: %s\r\n",path);
2247         }
2248 #endif /* NT */
2249
2250         ckmakmsg(path,CKMAXPATH,exedir,"ca_crls.pem",NULL,NULL);
2251         if (X509_STORE_load_locations(crl_store,path,NULL) == 0) {
2252             debug(F110,"ssl_http_init unable to load file",path,0);
2253             if (ssl_debug_flag)
2254                 printf("?Unable to load crl-file: %s\r\n",path);
2255         }
2256 #ifdef NT
2257         ckmakmsg(path,CKMAXPATH,GetAppData(1),"kermit 95/ca_crls.pem",NULL,NULL);
2258         if (X509_STORE_load_locations(crl_store,path,NULL) == 0) {
2259             debug(F110,"ssl_http_init unable to load file",path,0);
2260             if (ssl_debug_flag)
2261                 printf("?Unable to load crl-file: %s\r\n",path);
2262         }
2263         ckmakmsg(path,CKMAXPATH,GetAppData(0),"kermit 95/ca_crls.pem",NULL,NULL);
2264         if (X509_STORE_load_locations(crl_store,path,NULL) == 0) {
2265             debug(F110,"ssl_http_init unable to load file",path,0);
2266             if (ssl_debug_flag)
2267                 printf("?Unable to load crl-file: %s\r\n",path);
2268         }
2269 #endif /* NT */
2270 #endif /* OS2 */
2271
2272         if (ssl_crl_file || ssl_crl_dir) {
2273             if (ssl_crl_file &&
2274                 X509_STORE_load_locations(crl_store,ssl_crl_file,NULL) == 0) {
2275                 debug(F110,"ssl_http_init unable to load ssl_crl_file",ssl_crl_file,0);
2276                 if (ssl_debug_flag)
2277                     printf("?Unable to load crl-file: %s\r\n",ssl_crl_file);
2278             }
2279             if (ssl_crl_dir &&
2280                 X509_STORE_load_locations(crl_store,NULL,ssl_crl_dir) == 0) {
2281                 debug(F110,"ssl_http_init unable to load ssl_crl_dir",ssl_crl_dir,0);
2282                 if (ssl_debug_flag)
2283                     printf("?Unable to load crl-dir: %s\r\n",ssl_crl_dir);
2284             }
2285         } else {
2286             X509_STORE_set_default_paths(crl_store);
2287         }
2288     }
2289
2290 #ifndef COMMENT
2291     tls_conx = tls_http_con;
2292     tls_http_con=(SSL *)SSL_new(tls_http_ctx);
2293     if ( !tls_http_con ) {
2294         debug(F110,"ssl_http_init","SSL_new(tls_http_con) failed",0);
2295         tls_http_con = tls_conx;
2296         return(0);
2297     }
2298     if (tls_conx) {
2299         SSL_set_session(tls_http_con, SSL_get_session(tls_conx));
2300 #ifdef SSL_KRB5
2301                 if (tls_conx->kssl_ctx) {
2302                         kssl_ctx_free(tls_conx->kssl_ctx);
2303                         tls_conx->kssl_ctx = NULL;
2304                 }
2305 #endif /* SSL_KRB5 */
2306         SSL_free(tls_conx);
2307         tls_conx = NULL;
2308     }
2309 #else /* COMMENT */
2310     /* I don't know why this does not work to reuse the connection. */
2311     if ( tls_http_con ) {
2312         SSL_clear(tls_http_con);
2313         SSL_set_session(tls_http_con,NULL);
2314         SSL_set_accept_state(tls_http_con) ;
2315     } else {
2316         tls_http_con=(SSL *)SSL_new(tls_http_ctx);
2317         if ( !tls_http_con ) {
2318             debug(F110,"ssl_http_init","SSL_new(tls_http_ctx) failed",0);
2319             tls_http_con = tls_conx;
2320             return(0);
2321         }
2322     }
2323 #endif /* COMMENT */
2324
2325 #ifdef SSL_KRB5
2326 #ifndef KRB5_SERVICE_NAME
2327 #define KRB5_SERVICE_NAME    "host"
2328 #endif
2329
2330     if (tls_http_con->kssl_ctx == NULL)
2331     tls_http_con->kssl_ctx = kssl_ctx_new();
2332     if (tls_http_con->kssl_ctx != NULL)
2333         kssl_ctx_setstring(tls_http_con->kssl_ctx, KSSL_SERVER, hostname);
2334
2335     kssl_ctx_setstring(tls_http_con->kssl_ctx, KSSL_SERVICE,
2336                         krb5_d_srv ? krb5_d_srv : KRB5_SERVICE_NAME);
2337 #endif /* SSL_KRB5 */
2338
2339     if (ssl_cipher_list)
2340         SSL_set_cipher_list(tls_http_con,ssl_cipher_list);
2341     else {
2342         char * p;
2343         if (p = getenv("SSL_CIPHER")) {
2344             SSL_set_cipher_list(tls_http_con,p);
2345         } else {
2346             SSL_set_cipher_list(tls_http_con,DEFAULT_CIPHER_LIST);
2347         }
2348     }
2349
2350     ssl_verify_depth = -1;
2351
2352     if ( ssl_debug_flag )
2353         printf("SSL/TLS init done!\r\n");
2354
2355     ssl_http_initialized = 1;
2356     return(1);
2357 }
2358 #endif /* NOHTTP */
2359
2360 char *
2361 ssl_get_dNSName(ssl) SSL * ssl;
2362 {
2363     static char *dns = NULL;
2364     X509 *server_cert = NULL;
2365     int i;
2366     X509_EXTENSION *ext = NULL;
2367     STACK_OF(GENERAL_NAME) *ialt = NULL;
2368     GENERAL_NAME *gen = NULL;
2369
2370     if ( dns ) {
2371         free(dns);
2372         dns = NULL;
2373     }
2374
2375     if (server_cert = SSL_get_peer_certificate(ssl)) {
2376         if ((i = X509_get_ext_by_NID(server_cert, NID_subject_alt_name, -1))<0)
2377             return NULL;
2378         if (!(ext = X509_get_ext(server_cert, i)))
2379             return NULL;
2380         X509V3_add_standard_extensions();
2381         if (!(ialt = X509V3_EXT_d2i(ext)))
2382             return NULL;
2383         for (i = 0; i < sk_GENERAL_NAME_num(ialt); i++) {
2384             gen = sk_GENERAL_NAME_value(ialt, i);
2385             if (gen->type == GEN_DNS) {
2386                 if(!gen->d.ia5 || !gen->d.ia5->length)
2387                     break;
2388                 dns = malloc(gen->d.ia5->length + 1);
2389                 if (dns) {
2390                     memcpy(dns, gen->d.ia5->data, gen->d.ia5->length);
2391                     dns[gen->d.ia5->length] = 0;
2392                 }
2393                 break;
2394             }
2395         }
2396         X509V3_EXT_cleanup();
2397     }
2398 cleanup:
2399     if (ialt)           sk_GENERAL_NAME_free(ialt);
2400     if (server_cert)    X509_free(server_cert);
2401     return dns;
2402 }
2403
2404 char *
2405 ssl_get_commonName(ssl) SSL * ssl;
2406 {
2407     static char name[256];
2408     int err;
2409     X509 *server_cert;
2410
2411     if (server_cert = SSL_get_peer_certificate(ssl)) {
2412         err = X509_NAME_get_text_by_NID(X509_get_subject_name(server_cert),
2413                 NID_commonName, name, sizeof(name));
2414         X509_free(server_cert);
2415     }
2416     if (err > 0)
2417         return name;
2418     else
2419         return NULL;
2420 }
2421
2422 char *
2423 ssl_get_issuer_name(ssl) SSL * ssl;
2424 {
2425     static char name[256];
2426     X509 *server_cert;
2427
2428     name[0] = '\0';
2429     if (server_cert = SSL_get_peer_certificate(ssl)) {
2430         X509_NAME_oneline(X509_get_issuer_name(server_cert),name,sizeof(name));
2431         X509_free(server_cert);
2432         return name;
2433     }
2434     else {
2435 #ifdef COMMENT
2436       fprintf(stderr, "Warning: No certificate from server!\r\n");
2437 #endif /* COMMENT */
2438         return NULL;
2439     }
2440 }
2441
2442 char *
2443 ssl_get_subject_name(ssl) SSL * ssl;
2444 {
2445     static char name[256];
2446     X509 *server_cert;
2447
2448     name[0] = '\0';
2449     if (server_cert = SSL_get_peer_certificate(ssl)) {
2450        X509_NAME_oneline(X509_get_subject_name(server_cert),name,sizeof(name));
2451        X509_free(server_cert);
2452        return name;
2453     }
2454     else
2455         return NULL;
2456 }
2457
2458 #ifdef COMMENT
2459 #ifdef CK_SSL
2460             && !(ck_ssleay_is_installed() &&
2461                (tls_active_flag || ssl_active_flag) &&
2462                ssl_anonymous_cipher(tls_active_flag?tls_con:ssl_con))
2463 #endif /* CK_SSL */
2464
2465 int
2466 ssl_anonymous_cipher(ssl) SSL * ssl;
2467 {
2468     X509 * cert;
2469
2470     if (sstelnet)
2471         cert = SSL_get_certificate(ssl);
2472     else
2473         cert = SSL_get_peer_certificate(ssl);
2474
2475     if ( cert ) {
2476         X509_free(cert);
2477         return 0;
2478     }
2479     return 1;
2480 }
2481 #endif /* COMMENT */
2482
2483 /*
2484   This one is (very much!) based on work by
2485   Ralf S. Engelschall <rse@engelschall.com>.
2486   Comments by Ralf.
2487 */
2488 int
2489 ssl_verify_crl(int ok, X509_STORE_CTX *ctx)
2490 {
2491     X509_OBJECT obj;
2492     X509_NAME *subject = NULL;
2493     X509_NAME *issuer = NULL;
2494     X509 *xs = NULL;
2495     X509_CRL *crl = NULL;
2496     X509_REVOKED *revoked = NULL;
2497     X509_STORE_CTX * store_ctx = NULL;
2498     long serial;
2499     BIO *bio = NULL;
2500     int i, n, rc;
2501     char *cp;
2502     char *cp2;
2503
2504     /*
2505      * Unless a revocation store for CRLs was created we
2506      * cannot do any CRL-based verification, of course.
2507      */
2508     if (!crl_store)
2509         return ok;
2510
2511     store_ctx = X509_STORE_CTX_new();
2512     if ( !store_ctx )
2513         return(ok);
2514
2515     /*
2516      * Determine certificate ingredients in advance
2517      */
2518     xs      = X509_STORE_CTX_get_current_cert(ctx);
2519     subject = X509_get_subject_name(xs);
2520     issuer  = X509_get_issuer_name(xs);
2521
2522     /*
2523      * OpenSSL provides the general mechanism to deal with CRLs but does not
2524      * use them automatically when verifying certificates, so we do it
2525      * explicitly here. We will check the CRL for the currently checked
2526      * certificate, if there is such a CRL in the store.
2527      *
2528      * We come through this procedure for each certificate in the certificate
2529      * chain, starting with the root-CA's certificate. At each step we've to
2530      * both verify the signature on the CRL (to make sure it's a valid CRL)
2531      * and it's revocation list (to make sure the current certificate isn't
2532      * revoked).  But because to check the signature on the CRL we need the
2533      * public key of the issuing CA certificate (which was already processed
2534      * one round before), we've a little problem. But we can both solve it and
2535      * at the same time optimize the processing by using the following
2536      * verification scheme (idea and code snippets borrowed from the GLOBUS
2537      * project):
2538      *
2539      * 1. We'll check the signature of a CRL in each step when we find a CRL
2540      *    through the _subject_ name of the current certificate. This CRL
2541      *    itself will be needed the first time in the next round, of course.
2542      *    But we do the signature processing one round before this where the
2543      *    public key of the CA is available.
2544      *
2545      * 2. We'll check the revocation list of a CRL in each step when
2546      *    we find a CRL through the _issuer_ name of the current certificate.
2547      *    This CRLs signature was then already verified one round before.
2548      *
2549      * This verification scheme allows a CA to revoke its own certificate as
2550      * well, of course.
2551      */
2552
2553     /*
2554      * Try to retrieve a CRL corresponding to the _subject_ of
2555      * the current certificate in order to verify it's integrity.
2556      */
2557     memset((char *)&obj, 0, sizeof(obj));
2558     X509_STORE_CTX_init(store_ctx, crl_store, NULL, NULL);
2559     rc = X509_STORE_get_by_subject(store_ctx, X509_LU_CRL, subject, &obj);
2560     X509_STORE_CTX_cleanup(store_ctx);
2561     crl = obj.data.crl;
2562     if (rc > 0 && crl != NULL) {
2563         /*
2564          * Verify the signature on this CRL
2565          */
2566         if (X509_CRL_verify(crl, X509_get_pubkey(xs)) <= 0) {
2567             fprintf(stderr, "Invalid signature on CRL!\n");
2568             X509_STORE_CTX_set_error(ctx, X509_V_ERR_CRL_SIGNATURE_FAILURE);
2569             X509_OBJECT_free_contents(&obj);
2570             X509_STORE_CTX_free(store_ctx);
2571             return 0;
2572         }
2573
2574         /*
2575          * Check date of CRL to make sure it's not expired
2576          */
2577         i = X509_cmp_current_time(X509_CRL_get_nextUpdate(crl));
2578         if (i == 0) {
2579             fprintf(stderr, "Found CRL has invalid nextUpdate field.\n");
2580             X509_STORE_CTX_set_error(ctx,
2581                                     X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD);
2582             X509_OBJECT_free_contents(&obj);
2583             X509_STORE_CTX_free(store_ctx);
2584             return 0;
2585         }
2586         if (i < 0) {
2587             fprintf(stderr,
2588 "Found CRL is expired - revoking all certificates until you get updated CRL.\n"
2589                     );
2590             X509_STORE_CTX_set_error(ctx, X509_V_ERR_CRL_HAS_EXPIRED);
2591             X509_OBJECT_free_contents(&obj);
2592             X509_STORE_CTX_free(store_ctx);
2593             return 0;
2594         }
2595         X509_OBJECT_free_contents(&obj);
2596     }
2597
2598     /*
2599      * Try to retrieve a CRL corresponding to the _issuer_ of
2600      * the current certificate in order to check for revocation.
2601      */
2602     memset((char *)&obj, 0, sizeof(obj));
2603     X509_STORE_CTX_init(store_ctx, crl_store, NULL, NULL);
2604     rc = X509_STORE_get_by_subject(store_ctx, X509_LU_CRL, issuer, &obj);
2605     X509_STORE_CTX_free(store_ctx);             /* calls X509_STORE_CTX_cleanup() */
2606     crl = obj.data.crl;
2607     if (rc > 0 && crl != NULL) {
2608         /*
2609          * Check if the current certificate is revoked by this CRL
2610          */
2611         n = sk_X509_REVOKED_num(X509_CRL_get_REVOKED(crl));
2612         for (i = 0; i < n; i++) {
2613             revoked = sk_X509_REVOKED_value(X509_CRL_get_REVOKED(crl), i);
2614             if (ASN1_INTEGER_cmp(revoked->serialNumber,
2615                                  X509_get_serialNumber(xs)) == 0) {
2616
2617                 serial = ASN1_INTEGER_get(revoked->serialNumber);
2618                 cp = X509_NAME_oneline(issuer, NULL, 0);
2619                 free(cp);
2620
2621                 X509_STORE_CTX_set_error(ctx, X509_V_ERR_CERT_REVOKED);
2622                 X509_OBJECT_free_contents(&obj);
2623                 return 0;
2624             }
2625         }
2626         X509_OBJECT_free_contents(&obj);
2627     }
2628     return ok;
2629 }
2630
2631 char *
2632 tls_userid_from_client_cert(ssl) SSL * ssl;
2633 {
2634     static char cn[256];
2635     static char *r = cn;
2636     int err;
2637     X509 *client_cert;
2638
2639     if (client_cert = SSL_get_peer_certificate(ssl)) {
2640         /* call the custom function */
2641         err = X509_to_user(client_cert, cn, sizeof(cn));
2642         X509_free(client_cert);
2643         if (err)
2644             return r = NULL;
2645         else
2646             return r;
2647     }
2648     else
2649         return r = NULL;
2650 }
2651
2652 unsigned char **
2653 tls_get_SAN_objs(SSL * ssl, int type)
2654 /* returns NULL or an array of malloc'ed objects of type `type' from the server's
2655  * subjectAltName, remember to free() them all!
2656  */
2657 {
2658 #define NUM_SAN_OBJS 64
2659     static unsigned char *objs[NUM_SAN_OBJS];
2660     unsigned char **rv = NULL;
2661     X509 *server_cert = NULL;
2662     int i, j;
2663     X509_EXTENSION *ext = NULL;
2664     STACK_OF(GENERAL_NAME) *ialt = NULL;
2665     GENERAL_NAME *gen = NULL;
2666
2667     memset(objs, 0, sizeof(objs));
2668     if (server_cert = SSL_get_peer_certificate(ssl)) {
2669         if ((i = X509_get_ext_by_NID(server_cert, NID_subject_alt_name, -1)) < 0)
2670             goto eject;
2671         if (!(ext = X509_get_ext(server_cert, i)))
2672             goto eject;
2673         X509V3_add_standard_extensions();
2674         if (!(ialt = X509V3_EXT_d2i(ext)))
2675             goto eject;
2676         rv = objs;
2677         for (i = 0, j = 0; i < sk_GENERAL_NAME_num(ialt) && j < NUM_SAN_OBJS - 2; i++) {
2678             gen = sk_GENERAL_NAME_value(ialt, i);
2679             /* The use of V_ASN1_CONTEXT_SPECIFIC is because OpenSSL 0.9.6 defined its
2680              * types | V_ASN1_CONTEXT_SPECIFIC.  0.9.7 does not.  In case, we are built
2681              * with one and linked to the other we use this hack.
2682              */
2683             if ((gen->type | V_ASN1_CONTEXT_SPECIFIC) == (type | V_ASN1_CONTEXT_SPECIFIC)) {
2684                 if(!gen->d.ia5 || !gen->d.ia5->length)
2685                     break;
2686                 objs[j] = malloc(gen->d.ia5->length + 1);
2687                 if (objs[j]) {
2688                     memcpy(objs[j], gen->d.ia5->data, gen->d.ia5->length);
2689                     objs[j][gen->d.ia5->length] = 0;
2690                     j++;
2691                 }
2692             }
2693         }
2694         X509V3_EXT_cleanup();
2695     }
2696 eject:
2697     if (ialt)           sk_GENERAL_NAME_free(ialt);
2698     if (server_cert)    X509_free(server_cert);
2699     return rv;
2700 }
2701
2702
2703 static int
2704 dNSName_cmp(const char *host, const char *dNSName)
2705 {
2706     int c1 = 0, c2 = 0, num_comp, rv = -1;
2707     char *p, *p1, *p2, *host_copy=NULL, *dNSName_copy=NULL;
2708
2709     /* first we count the number of domain name components in both parameters.
2710      * they should be equal many, or it's not a match
2711      */
2712     p = (char *) host;
2713     while (p = strstr(p, ".")) {
2714         c1++;
2715         p++;
2716     }
2717     p = (char *) dNSName;
2718     while (p = strstr(p, ".")) {
2719         c2++;
2720         p++;
2721     }
2722     if (c1 != c2)
2723         return -1;
2724     num_comp = c1;
2725
2726     makestr(&host_copy,host);
2727     makestr(&dNSName_copy,dNSName);
2728     if (host_copy == NULL || dNSName_copy == NULL)
2729         goto eject;
2730     /* make substrings by replacing '.' with '\0' */
2731     p = dNSName_copy;
2732     while (p = strstr(p, ".")) {
2733         *p = '\0';
2734         p++;
2735     }
2736     p = host_copy;
2737     while (p = strstr(p, ".")) {
2738         *p = '\0';
2739         p++;
2740     }
2741
2742     /* compare each component */
2743     p1 = host_copy;
2744     p2 = dNSName_copy;
2745     for (; num_comp; num_comp--) {
2746         if (!ckmatch(p2, p1,0,1))
2747             /* failed match */
2748             goto eject;
2749         p1 += strlen(p1) + 1;
2750         p2 += strlen(p2) + 1;
2751     }
2752     /* match ok */
2753     rv = 0;
2754
2755   eject:
2756     if (dNSName_copy)   free(dNSName_copy);
2757     if (host_copy)      free(host_copy);
2758     return rv;
2759 }
2760
2761
2762
2763 static int
2764 show_hostname_warning(char *s1, char *s2)
2765 {
2766     char prefix[1024];
2767     int ok = 1;
2768     ckmakxmsg(prefix,1024,
2769               "Warning: Hostname (\"", s1,
2770               "\") does not match server's certificate (\"", s2, "\")",
2771               NULL,NULL,NULL,NULL,NULL,NULL,NULL);
2772     if (ssl_verify_flag)
2773         ok = uq_ok(prefix,
2774                     "Continue? (Y/N) ",
2775                     3, NULL, 0);
2776     else if (ssl_verbose_flag)
2777         printf(prefix);
2778     return(ok);
2779 }
2780
2781 #ifndef HPUX10
2782 #ifndef HPUX1100
2783 #ifndef SCO_OSR505
2784 #ifndef OpenBSD
2785 #ifndef FREEBSD4
2786 #ifndef LINUX
2787 #ifndef AIX41
2788 #ifndef UW7
2789 #ifndef SOLARIS9
2790 #ifndef SOLARIS8
2791 #ifndef SOLARIS7
2792 #ifdef DEC_TCPIP
2793 #define inet_aton INET_ATON
2794 #endif /* DEC_TCPIP */
2795 static int
2796 inet_aton(char * ipaddress, struct in_addr * ia) {
2797     struct stringarray * q;
2798     union {
2799         unsigned long l;
2800         unsigned char b[4];
2801     } dummy;
2802
2803     q = cksplit(1,0,ipaddress,".","0123456789abcdefACDEF",8,0,0);
2804     if (q->a_size == 4) {
2805         dummy.b[0] = atoi(q->a_head[1]);
2806         dummy.b[1] = atoi(q->a_head[2]);
2807         dummy.b[2] = atoi(q->a_head[3]);
2808         dummy.b[3] = atoi(q->a_head[4]);
2809         ia->s_addr = dummy.l;
2810         return(ia->s_addr != 0);
2811     }
2812     return(0);
2813 }
2814 #endif /* SOLARIS7 */
2815 #endif /* SOLARIS8 */
2816 #endif /* SOLARIS9 */
2817 #endif /* UW7 */
2818 #endif /* AIX41 */
2819 #endif /* LINUX */
2820 #endif /* FREEBSD4 */
2821 #endif /* OpenBSD */
2822 #endif /* SCO_OSR505 */
2823 #endif /* HPUX1100 */
2824 #endif /* HPUX10 */
2825
2826 int
2827 ssl_check_server_name(SSL * ssl, char * hostname)
2828 /* returns 0 if hostname and server's cert matches, else -1 */
2829 {
2830     char * commonName;
2831     unsigned char ** dNSName;
2832     unsigned char ** ipAddress;
2833     struct in_addr ia;
2834     int rv;
2835
2836     if (ssl_verbose_flag && !inserver) {
2837         if (dNSName = tls_get_SAN_objs(ssl,GEN_DNS)) {
2838             int i = 0;
2839             for (i = 0; dNSName[i]; i++) {
2840                 printf("Certificate[0] altSubjectName DNS=%s\r\n",dNSName[i]);
2841                 free(dNSName[i]);
2842             }
2843         }
2844         if (ipAddress = tls_get_SAN_objs(ssl,GEN_IPADD)) {
2845             int i = 0;
2846             char *server_ip;
2847             struct in_addr ia;
2848
2849             for (i = 0; ipAddress[i]; i++) {
2850                 if (ipAddress[i]) {
2851                     ia.s_addr = *(unsigned long *)ipAddress[i];
2852                     server_ip = inet_ntoa(ia);
2853                     printf("Certificate[0] altSubjectName IPAddr=%s\r\n",server_ip);
2854                 }
2855                 free(ipAddress[i]);
2856             }
2857             /* ipAddress points to a static - don't free */
2858         }
2859         if (dNSName = tls_get_SAN_objs(ssl,GEN_EMAIL)) {
2860             int i = 0;
2861             for (i = 0; dNSName[i]; i++) {
2862                 printf("Certificate[0] altSubjectName Email=%s\r\n",dNSName[i]);
2863                 free(dNSName[i]);
2864             }
2865         }
2866         if (dNSName = tls_get_SAN_objs(ssl,GEN_URI)) {
2867             int i = 0;
2868             for (i = 0; dNSName[i]; i++) {
2869                 printf("Certificate[0] altSubjectName URI=%s\r\n",dNSName[i]);
2870                 free(dNSName[i]);
2871             }
2872         }
2873         if (dNSName = tls_get_SAN_objs(ssl,GEN_OTHERNAME)) {
2874             int i = 0;
2875             for (i = 0; dNSName[i]; i++) {
2876                 printf("Certificate[0] altSubjectName Other=%s\r\n",dNSName[i]);
2877                 free(dNSName[i]);
2878             }
2879         }
2880     }
2881
2882     /* first we check if `hostname' is in fact an ip address */
2883     if (inet_aton(hostname, &ia)) {
2884         ipAddress = tls_get_SAN_objs(ssl,GEN_IPADD);
2885         if (ipAddress) {
2886             int i = 0;
2887             char *server_ip = "UNKNOWN";
2888
2889             for (i = 0; ipAddress[i]; i++)
2890                 if (*(unsigned long *)ipAddress[i] == ia.s_addr)
2891                     return 0;
2892
2893             if (ipAddress[i - 1]) {
2894                 ia.s_addr = *(unsigned long *)ipAddress[i - 1];
2895                 server_ip = inet_ntoa(ia);
2896             }
2897             rv = show_hostname_warning(hostname, server_ip) ? 0 : -1;
2898             for (i = 0; ipAddress[i]; i++)
2899                 free(ipAddress[i]);
2900         } else {
2901             rv = show_hostname_warning(hostname, "NO IP IN CERT") ? 0 : -1;
2902         }
2903         return(rv);
2904     }
2905
2906     /* look for dNSName(s) in subjectAltName in the server's certificate */
2907     dNSName = tls_get_SAN_objs(ssl,GEN_DNS);
2908     if (dNSName) {
2909         int i = 0;
2910         for (i = 0; dNSName[i]; i++) {
2911             if (!dNSName_cmp(hostname,(char *)dNSName[i]))
2912                 return 0;
2913         }
2914         rv = show_hostname_warning(hostname,
2915                                    (char *)((dNSName[i - 1] == NULL) ?
2916                                    (char *)"UNKNOWN" : (char *)dNSName[i - 1]))
2917              ? 0 : -1;
2918         for (i = 0; dNSName[i]; i++)
2919             free(dNSName[i]);
2920         return rv;
2921     } else if ((commonName = ssl_get_commonName(ssl))) {
2922        /* so the server didn't have any dNSName's, check the commonName */
2923        if (!dNSName_cmp(hostname, commonName))
2924            return 0;
2925        else
2926            return (show_hostname_warning(hostname, commonName) ? 0 : -1);
2927     }
2928     return -1;
2929 }
2930
2931 /* Is 'user' authorized to access the system without a login */
2932 int
2933 tls_is_user_valid(SSL * ssl, const char *user)
2934 {
2935     X509 *client_cert;
2936     int r = 0;
2937
2938     if ( !ssl || !user || !user[0] )
2939         return(0);
2940
2941     if (!(client_cert = SSL_get_peer_certificate(ssl)))
2942         return 0;
2943
2944     /* Use user supplied function */
2945     r = X509_userok(client_cert,user);
2946
2947     X509_free(client_cert);
2948     return r;
2949 }
2950
2951 int
2952 tls_is_anon(int x)
2953 {
2954     char buf[128];
2955     SSL_CIPHER * cipher;
2956     SSL * ssl = NULL;
2957
2958     switch ( x ) {
2959 #ifndef NOFTP
2960 #ifndef SYSFTP
2961     case 1:     /* ftp command */
2962         if ( ssl_ftp_active_flag )
2963             ssl = ssl_ftp_con;
2964         else
2965             return(0);
2966         break;
2967     case 2:     /* ftp data */
2968         if ( ssl_ftp_data_active_flag )
2969             ssl = ssl_ftp_data_con;
2970         else
2971             return(0);
2972         break;
2973 #endif /* SYSFTP */
2974 #endif /* NOFTP */
2975     default:
2976         if (tls_active_flag)
2977             ssl = tls_con;
2978         else if (ssl_active_flag)
2979             ssl = ssl_con;
2980         else
2981             return(0);
2982     }
2983
2984     cipher = SSL_get_current_cipher(ssl);
2985     if (SSL_CIPHER_description(cipher,buf,sizeof(buf))) {
2986         if (ckindex("Au=None",buf,0,0,0) != 0)
2987             return(1);                  /* anonymous */
2988         return(0);                  /* known */
2989     } else {
2990         /* could not get cipher description.  Assume anonymous */
2991         return(1);
2992     }
2993 }
2994
2995 int
2996 tls_is_krb5(int x)
2997 {
2998     char buf[128];
2999     SSL_CIPHER * cipher;
3000     SSL * ssl = NULL;
3001
3002     switch ( x ) {
3003 #ifndef NOFTP
3004 #ifndef SYSFTP
3005     case 1:     /* ftp command */
3006         if ( ssl_ftp_active_flag )
3007             ssl = ssl_ftp_con;
3008         else
3009             return(0);
3010         break;
3011     case 2:     /* ftp data */
3012         if ( ssl_ftp_data_active_flag )
3013             ssl = ssl_ftp_data_con;
3014         else
3015             return(0);
3016         break;
3017 #endif /* SYSFTP */
3018 #endif /* NOFTP */
3019 #ifndef NOHTTP
3020     case 3:
3021         if ( tls_http_active_flag )
3022             ssl = tls_http_con;
3023         break;
3024 #endif /* NOHTTP */
3025     default:
3026         if (tls_active_flag)
3027             ssl = tls_con;
3028         else if (ssl_active_flag)
3029             ssl = ssl_con;
3030         else
3031             return(0);
3032     }
3033
3034     cipher = SSL_get_current_cipher(ssl);
3035     if (cipher && SSL_CIPHER_description(cipher,buf,sizeof(buf))) {
3036         if (ckindex("Au=KRB5",buf,0,0,0) != 0)
3037             return(1);                  /* krb5 */
3038     }
3039     return(0);                          /* not */
3040 }
3041
3042 int
3043 ssl_get_client_finished(char *buf, int count)
3044 {
3045 #ifdef NO_GET_FINISHED
3046     return(0);
3047 #else
3048     if (sstelnet || tcp_incoming) {
3049         return(SSL_get_peer_finished(ssl_active_flag?ssl_con:tls_con,
3050                                       buf,count));
3051     } else {
3052         return(SSL_get_finished(ssl_active_flag?ssl_con:tls_con,
3053                                       buf,count));
3054     }
3055 #endif /* NO_GET_FINISHED */
3056 }
3057
3058 int
3059 ssl_get_server_finished(char *buf, int count)
3060 {
3061 #ifdef NO_GET_FINISHED
3062     return(0);
3063 #else
3064     if (sstelnet || tcp_incoming) {
3065         return(SSL_get_finished(ssl_active_flag?ssl_con:tls_con,
3066                                       buf,count));
3067     } else {
3068         return(SSL_get_peer_finished(ssl_active_flag?ssl_con:tls_con,
3069                                       buf,count));
3070     }
3071 #endif /* NO_GET_FINISHED */
3072 }
3073
3074
3075 #ifdef CK_AUTHENTICATION
3076 int
3077 #ifdef CK_ANSIC
3078 ssl_reply(int how, unsigned char *data, int cnt)
3079 #else
3080 ssl_reply(how,data,cnt) int how; unsigned char *data; int cnt;
3081 #endif
3082 {
3083     char * str=NULL;
3084
3085     data += 4;                          /* Point to status byte */
3086     cnt  -= 4;
3087
3088     if(cnt-- < 1) {
3089         auth_finished(AUTH_REJECT);
3090         return AUTH_FAILURE;
3091     }
3092
3093     switch(*data++) {
3094     case SSL_ACCEPT:
3095         if (tn_deb || debses)
3096             tn_debug("[SSL - handshake starting]");
3097         else if ( ssl_verbose_flag )
3098             printf("[SSL - handshake starting]\r\n");
3099         debug(F110,"ssl_reply","[SSL - handshake starting]",0);
3100
3101         /* right ... now we drop into the SSL library */
3102         if (!ssl_only_flag) {
3103             if (ssl_dummy_flag) {
3104                 if (tn_deb || debses)
3105                     tn_debug("[SSL - Dummy Connected]");
3106                 else if ( ssl_verbose_flag ) {
3107                     printf("[SSL - Dummy Connected]\r\n");
3108                 }
3109                 debug(F110,"ssl_reply","[SSL - Dummy Connected]",0);
3110                 auth_finished(AUTH_UNKNOWN);
3111                 accept_complete = 1;
3112                 return AUTH_SUCCESS;
3113             }
3114
3115             if (SSL_connect(ssl_con) <= 0) {
3116                 int len;
3117                 if (tn_deb || debses) {
3118                     tn_debug("[SSL - FAILED]");
3119                     ERR_print_errors(bio_err);
3120                     len = BIO_read(bio_err,ssl_err,SSL_ERR_BFSZ);
3121                     ssl_err[len < SSL_ERR_BFSZ ? len : SSL_ERR_BFSZ] = '\0';
3122                     printf(ssl_err);
3123                 } else if ( ssl_verbose_flag ) {
3124                     printf("[SSL - FAILED]\r\n");
3125                     ERR_print_errors(bio_err);
3126                     len = BIO_read(bio_err,ssl_err,SSL_ERR_BFSZ);
3127                     ssl_err[len < SSL_ERR_BFSZ ? len : SSL_ERR_BFSZ] = '\0';
3128                     printf(ssl_err);
3129                 }
3130                 debug(F110,"ssl_reply","[SSL - FAILED]",0);
3131                 auth_finished(AUTH_REJECT);
3132                 ttclos(0);
3133                 return AUTH_FAILURE;
3134             } else {
3135                 if (tn_deb || debses)
3136                     tn_debug("[SSL - OK]");
3137                 else if ( ssl_verbose_flag ) {
3138                     printf("[SSL - OK]\r\n");
3139                 }
3140                 debug(F110,"ssl_reply","[SSL - OK]",0);
3141
3142                 ssl_active_flag = 1;
3143                 ssl_display_connect_details(ssl_con,0,ssl_verbose_flag);
3144             }
3145         }
3146         auth_finished(AUTH_UNKNOWN);
3147         accept_complete = 1;
3148         break;
3149
3150     case SSL_REJECT:
3151         if (tn_deb || debses) {
3152             tn_debug(
3153                  "[SSL - failed to switch on SSL - trying plaintext login]");
3154         } else if ( ssl_verbose_flag ) {
3155             printf("[SSL - failed to switch on SSL]\r\n");
3156             printf("Trying plaintext login:\r\n");
3157         }
3158         debug(F110,"ssl_reply","[SSL - failed to switch on SSL]",0);
3159         auth_finished(AUTH_REJECT);
3160         return AUTH_FAILURE;
3161
3162     default:
3163         return AUTH_FAILURE;
3164     }
3165     return AUTH_SUCCESS;
3166 }
3167
3168 int
3169 #ifdef CK_ANSIC
3170 ssl_is(unsigned char *data, int cnt)
3171 #else
3172 ssl_is(data,cnt) unsigned char *data; int cnt;
3173 #endif
3174 {
3175     if ((cnt -= 4) < 1)
3176         return AUTH_FAILURE;
3177
3178     data += 4;
3179     switch(*data++) {
3180     case SSL_START:
3181         /* server starts the SSL stuff now ... */
3182         if (!ssl_only_flag) {
3183             if ( !tls_load_certs(ssl_ctx,ssl_con,1) ) {
3184                 auth_finished(AUTH_REJECT);
3185                 return AUTH_FAILURE;
3186             }
3187
3188             if (tn_deb || debses)
3189                 tn_debug("[SSL - handshake starting]");
3190             else if ( ssl_verbose_flag )
3191                 printf("[SSL - handshake starting]\r\n");
3192             debug(F110,"ssl_is","[SSL - handshake starting]",0);
3193
3194             SendSSLAuthSB(SSL_ACCEPT, (void *)0, 0);
3195
3196             auth_ssl_valid = 1;
3197
3198             if (ssl_dummy_flag) {
3199                 if (tn_deb || debses)
3200                     tn_debug("[SSL - Dummy Connected]");
3201                 else if ( ssl_verbose_flag ) {
3202                     printf("[SSL - Dummy Connected]\r\n");
3203                 }
3204                 debug(F110,"ssl_is","[SSL - Dummy Connected]",0);
3205                 accept_complete = 1;
3206                 auth_finished(AUTH_UNKNOWN);
3207                 return AUTH_SUCCESS;
3208             }
3209
3210             if (SSL_accept(ssl_con) <= 0) {
3211                 char errbuf[1024];
3212
3213                 sprintf(errbuf,"[SSL - SSL_accept error: %s",
3214                          ERR_error_string(ERR_get_error(),NULL));
3215
3216                 if (tn_deb || debses)
3217                     tn_debug(errbuf);
3218                 else if ( ssl_debug_flag )
3219                     printf("%s\r\n",errbuf);
3220                 else if ( ssl_verbose_flag )
3221                     printf("[SSL - SSL_accept error]\r\n");
3222
3223                 debug(F110,"ssl_is",errbuf,0);
3224
3225                 auth_finished(AUTH_REJECT);
3226                 ttclos(0);
3227                 return AUTH_FAILURE;
3228             }
3229
3230             if (tn_deb || debses)
3231                 tn_debug("[SSL - OK]");
3232             else if ( ssl_verbose_flag ) {
3233                 printf("[SSL - OK]\r\n");
3234             }
3235             debug(F110,"ssl_is","[SSL - OK]",0);
3236             ssl_active_flag = 1;
3237             ssl_display_connect_details(ssl_con,1,ssl_verbose_flag);
3238
3239             /* now check to see that we got exactly what we
3240             * wanted from the caller ... if a certificate is
3241             * required then we make 100% sure that we were
3242             * given one during the handshake (as it is an optional
3243             * part of SSL)
3244             */
3245
3246 #ifdef SSL_KRB5
3247             if ( tls_is_krb5(0) ) {
3248                 if (ssl_con->kssl_ctx->client_princ)
3249                     debug(F110,"ssl_is KRB5",ssl_con->kssl_ctx->client_princ,0);
3250             } else
3251 #endif /* SSL_KRB5 */
3252             if (ssl_verify_flag & SSL_VERIFY_FAIL_IF_NO_PEER_CERT) {
3253                 X509 * peer = SSL_get_peer_certificate(ssl_con);
3254                 if (peer == NULL) {
3255                     if (tn_deb || debses)
3256                         tn_debug("[SSL - peer check failed]");
3257                     else if (ssl_debug_flag)
3258                         printf("[SSL - peer check failed]\r\n");
3259                     debug(F110,"ssl_is","[SSL - peer check failed]",0);
3260
3261                     /* LOGGING REQUIRED HERE! */
3262                     auth_finished(AUTH_REJECT);
3263                     return AUTH_FAILURE;
3264                 }
3265             }
3266             auth_finished(AUTH_UNKNOWN);
3267             accept_complete = 1;
3268         }
3269         break;
3270
3271     default:
3272         SendSSLAuthSB(SSL_REJECT, (void *) "Unknown option received", -1);
3273         if (tn_deb || debses)
3274             tn_debug("[SSL - Unknown option received]");
3275         else
3276             printf("Unknown SSL option %d\r\n", data[-1]);
3277         debug(F111,"ssl_is","[SSL - Unknown option received]",data[-1]);
3278         auth_ssl_valid = 0;
3279         auth_finished(AUTH_REJECT);
3280         return(AUTH_FAILURE);
3281     }
3282     return AUTH_SUCCESS;
3283 }
3284
3285 #endif /* CK_AUTHENTICATION */
3286
3287 int
3288 ck_tn_tls_negotiate(VOID)
3289 {
3290     X509 * peer = NULL;
3291     char str[256], *uid=NULL;
3292     extern int sstelnet;
3293
3294     if ( !ck_ssleay_is_installed() )
3295         return(-1);
3296
3297     if (sstelnet) {
3298         /* server starts the TLS stuff now ... */
3299         if (!tls_only_flag) {
3300             if ( !tls_load_certs(tls_ctx,tls_con,1) ) {
3301                 auth_finished(AUTH_REJECT);
3302                 return -1;
3303             }
3304
3305             if (tn_deb || debses)
3306                 tn_debug("[TLS - handshake starting]");
3307             else if ( ssl_verbose_flag )
3308                 printf("[TLS - handshake starting]\r\n");
3309             debug(F110,"ck_tn_tls_negotiate","[TLS - handshake starting]",0);
3310
3311             if (ssl_dummy_flag) {
3312                 if (tn_deb || debses)
3313                     tn_debug("[TLS - Dummy Connected]");
3314                 else if ( ssl_verbose_flag ) {
3315                     printf("[TLS - Dummy Connected]\r\n");
3316                 }
3317                 debug(F110,"ck_tn_tls_negotiate","[TLS - Dummy Connected]",0);
3318                 accept_complete = 1;
3319                 auth_finished(AUTH_REJECT);
3320                 return 0;
3321             }
3322
3323             if (SSL_accept(tls_con) <= 0) {
3324                 char errbuf[1024];
3325
3326                 sprintf(errbuf,"[TLS - SSL_accept error: %s",
3327                          ERR_error_string(ERR_get_error(),NULL));
3328
3329                 if (tn_deb || debses)
3330                     tn_debug(errbuf);
3331                 else if ( ssl_debug_flag )
3332                     printf("%s\r\n",errbuf);
3333                 else if ( ssl_verbose_flag )
3334                     printf("[TLS - SSL_accept error]\r\n");
3335
3336                 debug(F110,"ck_tn_tls_negotiate",errbuf,0);
3337                 auth_finished(AUTH_REJECT);
3338                 return -1;
3339             }
3340
3341             if (tn_deb || debses)
3342                 tn_debug("[TLS - OK]");
3343             else if ( ssl_verbose_flag ) {
3344                 printf("[TLS - OK]\r\n");
3345             }
3346
3347             debug(F110,"ck_tn_tls_negotiate","[TLS - OK]",0);
3348             tls_active_flag = 1;
3349             ssl_display_connect_details(tls_con,1,ssl_verbose_flag);
3350
3351
3352 #ifdef SSL_KRB5
3353             if ( tls_is_krb5(0) ) {
3354                 if (tls_con->kssl_ctx->client_princ) {
3355                     char *p;
3356                     ckstrncpy(szUserNameAuthenticated,
3357                                tls_con->kssl_ctx->client_princ,
3358                                UIDBUFLEN);
3359                     ckstrncpy(szUserNameRequested,
3360                                tls_con->kssl_ctx->client_princ,
3361                                UIDBUFLEN);
3362                     for ( p = szUserNameRequested; *p ; p++ ) {
3363                         if ( *p == '@' || *p == '/' ) {
3364                             *p = '\0';
3365                             break;
3366                         }
3367                     }
3368                 } else {
3369                     szUserNameRequested[0] = '\0';
3370                     szUserNameAuthenticated[0] = '\0';
3371                 }
3372 #ifdef CK_LOGIN
3373                 if (zvuser(szUserNameRequested))
3374                     auth_finished(AUTH_VALID);
3375                 else
3376 #endif /* CK_LOGIN */
3377                     auth_finished(AUTH_USER);
3378             } else
3379 #endif /* SSL_KRB5 */
3380             {
3381             /* now check to see that we got exactly what we
3382             * wanted from the caller ... if a certificate is
3383             * required then we make 100% sure that we were
3384             * given one during the handshake (as it is an optional
3385             * part of TLS)
3386             */
3387             peer=SSL_get_peer_certificate(tls_con);
3388             if (peer == NULL) {
3389                 debug(F100,"SSL_get_peer_certificate() == NULL","",0);
3390                 auth_finished(AUTH_REJECT);
3391                 if (ssl_verify_flag & SSL_VERIFY_FAIL_IF_NO_PEER_CERT) {
3392                     if (tn_deb || debses)
3393                         tn_debug("[TLS - peer check failed]");
3394                     else if (ssl_debug_flag) {
3395                         printf("[TLS - peer check failed]\r\n");
3396                     }
3397                     debug(F110,
3398                            "ck_tn_tls_negotiate",
3399                            "[TLS - peer check failed]",
3400                            0
3401                            );
3402                     /* LOGGING REQUIRED HERE! */
3403                     return -1;
3404                 }
3405             } else {
3406                 debug(F100,"SSL_get_peer_certificate() != NULL","",0);
3407                 X509_NAME_get_text_by_NID(X509_get_subject_name(peer),
3408                                            NID_commonName,str,
3409                                            256
3410                                            );
3411                 if ( ssl_verbose_flag )
3412                     printf("[TLS - commonName=%s]\r\n",str);
3413
3414                 X509_NAME_get_text_by_NID(X509_get_subject_name(peer),
3415 #ifndef NID_x500UniqueIdentifier
3416                                            NID_uniqueIdentifier,
3417 #else
3418                                            NID_x500UniqueIdentifier,
3419 #endif
3420                                            str,
3421                                            256
3422                                            );
3423                 if ( ssl_verbose_flag )
3424                     printf("[TLS - uniqueIdentifier=%s]\r\n",str);
3425
3426                 /* Try to determine user name */
3427                 uid = tls_userid_from_client_cert(tls_con);
3428                 if ( uid ) {
3429                     /* This code is very questionable.
3430                      * How should it behave?
3431                      * The client has presented a certificate that
3432                      * contains a username.  We have validated the
3433                      * certificate but we do not automatically
3434                      * log the user in unless there is a .tlslogin
3435                      * file.
3436                      */
3437
3438                     ckstrncpy(szUserNameRequested,uid,UIDBUFLEN);
3439 #ifdef CK_LOGIN
3440                     if (zvuser(uid))
3441                         auth_finished(AUTH_VALID);
3442                     else
3443 #endif /* CK_LOGIN */
3444                         auth_finished(AUTH_USER);
3445                 }
3446                 else {
3447                     szUserNameRequested[0] = '\0';
3448                     auth_finished(AUTH_REJECT);
3449                 }
3450             }
3451             }
3452         }
3453     } else {
3454         char * str=NULL;
3455
3456         if (tn_deb || debses)
3457             tn_debug("[TLS - handshake starting]");
3458         else if ( ssl_verbose_flag )
3459             printf("[TLS - handshake starting]\r\n");
3460         debug(F110,"ck_tn_tls_negotiate","[TLS - handshake starting]",0);
3461
3462         /* right ... now we drop into the SSL library */
3463         if (!tls_only_flag) {
3464             char *subject=NULL, *issuer=NULL, *commonName=NULL, *dNSName=NULL;
3465
3466             if (ssl_dummy_flag) {
3467                 if (tn_deb || debses)
3468                     tn_debug("[TLS - Dummy Connected]");
3469                 else if ( ssl_verbose_flag ) {
3470                     printf("[TLS - Dummy Connected]\r\n");
3471                 }
3472                 debug(F110,"ck_tn_tls_negotiate","[TLS - Dummy Connected]",0);
3473                 auth_finished(AUTH_REJECT);
3474                 accept_complete = 1;
3475                 return 0;
3476             }
3477
3478 #ifndef USE_CERT_CB
3479             if (!tls_load_certs(tls_ctx,tls_con,0))
3480                 return(-1);
3481 #endif /* USE_CERT_CB */
3482             if (SSL_connect(tls_con) <= 0) {
3483                 int len;
3484                 if (tn_deb || debses) {
3485                     tn_debug("[TLS - FAILED]");
3486                     ERR_print_errors(bio_err);
3487                     len = BIO_read(bio_err,ssl_err,SSL_ERR_BFSZ);
3488                     ssl_err[len < SSL_ERR_BFSZ ? len : SSL_ERR_BFSZ] = '\0';
3489                     printf(ssl_err);
3490                 } else if ( ssl_verbose_flag ) {
3491                     printf("[TLS - FAILED]\r\n");
3492                     ERR_print_errors(bio_err);
3493                     len = BIO_read(bio_err,ssl_err,SSL_ERR_BFSZ);
3494                     ssl_err[len < SSL_ERR_BFSZ ? len : SSL_ERR_BFSZ] = '\0';
3495                     printf(ssl_err);
3496                 }
3497                 debug(F110,"ck_tn_tls_negotiate","[TLS - FAILED]",0);
3498                 auth_finished(AUTH_REJECT);
3499                 return -1;
3500             }
3501
3502             tls_active_flag = 1;
3503             if ( !ssl_certsok_flag && (ssl_verify_flag & SSL_VERIFY_PEER)
3504                  && !tls_is_krb5(0)) {
3505                 char prmpt[1024];
3506                 subject = ssl_get_subject_name(tls_con);
3507
3508                 if (!subject) {
3509                     if (ssl_verify_flag & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)
3510                     {
3511                         if (tn_deb || debses)
3512                             tn_debug("[TLS - FAILED]");
3513                         else if ( ssl_verbose_flag )
3514                             printf("[TLS - FAILED]\r\n");
3515                         debug(F110,"ck_tn_tls_negotiate","[TLS - FAILED]",0);
3516                         auth_finished(AUTH_REJECT);
3517                         return -1;
3518                     } else {
3519                         int ok;
3520                         ok = uq_ok("Warning: Server didn't provide a certificate",
3521                                    "Continue? (Y/N)", 3, NULL, 0);
3522                         if (!ok) {
3523                             if (tn_deb || debses)
3524                                 tn_debug("[TLS - FAILED]");
3525                             else if ( ssl_verbose_flag )
3526                                 printf("[TLS - FAILED]\r\n");
3527                             debug(F110,
3528                                    "ck_tn_tls_negotiate","[TLS - FAILED]",0);
3529                             auth_finished(AUTH_REJECT);
3530                             return -1;
3531                         }
3532                     }
3533                 } else if (ssl_check_server_name(tls_con, szHostName)) {
3534                     if (tn_deb || debses)
3535                         tn_debug("[TLS - FAILED]");
3536                     else if ( ssl_verbose_flag )
3537                         printf("[TLS - FAILED]\r\n");
3538                     debug(F110,
3539                            "ck_tn_tls_negotiate","[TLS - FAILED]",0);
3540                     auth_finished(AUTH_REJECT);
3541                     return -1;
3542                 }
3543             }
3544
3545             if ( ssl_debug_flag && ssl_finished_messages) {
3546                 char msg[32];
3547                 int i, len=32;
3548                 extern char tn_msg[], hexbuf[];
3549
3550                 tn_msg[0] = '\0';
3551                 len = ssl_get_client_finished(msg,len);
3552                 if ( len > 0 ) {
3553                     for ( i=0;i<len;i++ ) {
3554                         sprintf(hexbuf,"%02X ",msg[i]);
3555                         ckstrncat(tn_msg,hexbuf,TN_MSG_LEN);
3556                     }
3557                     printf("TLS client finished: %s\r\n",tn_msg);
3558                 }
3559                 tn_msg[0] = '\0';
3560                 len = ssl_get_server_finished(msg,len);
3561                 if ( len > 0 ) {
3562                     for ( i=0;i<len;i++ ) {
3563                         sprintf(hexbuf,"%02X ",msg[i]);
3564                         ckstrncat(tn_msg,hexbuf,TN_MSG_LEN);
3565                     }
3566                     printf("TLS server finished: %s\r\n",tn_msg);
3567                 }
3568             }
3569
3570             if (tn_deb || debses)
3571                 tn_debug("[TLS - OK]");
3572             else if ( ssl_verbose_flag )
3573                 printf("[TLS - OK]\r\n");
3574             debug(F110,"ck_tn_tls_negotiate","[TLS - OK]",0);
3575
3576             ssl_display_connect_details(tls_con,0,ssl_verbose_flag);
3577         }
3578         auth_finished(AUTH_REJECT);
3579     }
3580     accept_complete = 1;
3581     auth_ssl_valid = 1;
3582     return(0);
3583 }
3584
3585 int
3586 ck_ssl_incoming(fd) int fd;
3587 {
3588     /* if we are not running in debug then any error
3589     * stuff from SSL debug *must* not go down
3590     * the socket (which 0,1,2 are all pointing to by
3591     * default)
3592     */
3593
3594     int timo = 2000;
3595
3596     if ( !ck_ssleay_is_installed() )
3597         return(-1);
3598
3599     /* do the SSL stuff now ... before we play with pty's */
3600     SSL_set_fd(ssl_con,fd);
3601     SSL_set_fd(tls_con,fd);
3602
3603     if (tls_only_flag) {
3604         if (tn_deb || debses)
3605             tn_debug("[TLS - handshake starting]");
3606         else if ( ssl_verbose_flag )
3607             printf("[TLS - handshake starting]\r\n");
3608         debug(F110,"ck_ssl_incoming","[TLS - handshake starting]",0);
3609
3610         /* hmm ... only when running talking to things like
3611         * https servers should we hit this code and then
3612         * we really don't care *who* we talk to :-)
3613         */
3614         if (SSL_accept(tls_con) <= 0) {
3615             char errbuf[1024];
3616
3617             sprintf(errbuf,"[TLS - SSL_accept error: %s",
3618                      ERR_error_string(ERR_get_error(),NULL));
3619
3620             if (tn_deb || debses)
3621                 tn_debug(errbuf);
3622             else if ( ssl_debug_flag )
3623                 printf("%s\r\n",errbuf);
3624             else if ( ssl_verbose_flag )
3625                 printf("[TLS - SSL_accept error]\r\n");
3626
3627             debug(F110,"ck_ssl_incoming",errbuf,0);
3628             return(-1);
3629         } else {
3630             if (tn_deb || debses)
3631                 tn_debug("[TLS - OK]");
3632             else if ( ssl_verbose_flag )
3633                 printf("[TLS - OK]\r\n");
3634             debug(F110,"ck_ssl_incoming","[TLS - OK]",0);
3635             tls_active_flag = 1;
3636         }
3637     } else if (ssl_only_flag) {
3638         if (tn_deb || debses)
3639             tn_debug("[SSL - handshake starting]");
3640         else if ( ssl_verbose_flag )
3641             printf("[SSL - handshake starting]\r\n");
3642         debug(F110,"ck_ssl_incoming","[SSL - handshake starting]",0);
3643
3644         /* hmm ... only when running talking to things like
3645          * https servers should we hit this code and then
3646          * we really don't care *who* we talk to :-)
3647          */
3648         if (SSL_accept(ssl_con) <= 0) {
3649             char errbuf[1024];
3650
3651             sprintf(errbuf,"[SSL - SSL_accept error: %s",
3652                      ERR_error_string(ERR_get_error(),NULL));
3653
3654             if (tn_deb || debses)
3655                 tn_debug(errbuf);
3656             else if ( ssl_debug_flag )
3657                 printf("%s\r\n",errbuf);
3658             else if ( ssl_verbose_flag )
3659                 printf("[SSL - SSL_accept error]\r\n");
3660
3661             debug(F110,"ck_ssl_incoming",errbuf,0);
3662             return(-1);
3663         } else {
3664             if (tn_deb || debses)
3665                 tn_debug("[SSL - OK]");
3666             else if ( ssl_verbose_flag )
3667             printf("[SSL - OK]\r\n");
3668             debug(F110,"ssl_is","[SSL - OK]",0);
3669             ssl_active_flag = 1;
3670         }
3671     }
3672     if (ssl_active_flag || tls_active_flag) {
3673         X509 *peer;
3674         char str[256], *uid=NULL;
3675
3676         /* now check to see that we got exactly what we
3677          * wanted from the caller ... if a certificate is
3678          * required then we make 100% sure that we were
3679          * given on during the handshake (as it is an optional
3680          * part of SSL and TLS)
3681          */
3682
3683         if ( tls_active_flag ) {
3684             peer=SSL_get_peer_certificate(tls_con);
3685         } else if ( ssl_active_flag ) {
3686             peer=SSL_get_peer_certificate(ssl_con);
3687         }
3688
3689         if (peer == NULL) {
3690             debug(F100,"SSL_get_peer_certificate() == NULL","",0);
3691             auth_finished(AUTH_REJECT);
3692
3693             if (ssl_verify_flag & SSL_VERIFY_FAIL_IF_NO_PEER_CERT) {
3694                 if (tn_deb || debses)
3695                     tn_debug("[SSL/TLS - peer check failed]");
3696                 else if (ssl_debug_flag) {
3697                     printf("[SSL/TLS - peer check failed]\r\n");
3698                 }
3699                 debug(F110,
3700                        "ck_tn_tls_negotiate",
3701                        "[SSL/TLS - peer check failed]",
3702                        0
3703                        );
3704                 /* LOGGING REQUIRED HERE! */
3705                 return -1;
3706             }
3707
3708         } else {
3709             debug(F100,"SSL_get_peer_certificate() != NULL","",0);
3710             X509_NAME_get_text_by_NID(X509_get_subject_name(peer),
3711                                        NID_commonName,str,
3712                                        256
3713                                        );
3714             printf("[TLS - commonName=%s]\r\n",str);
3715
3716             X509_NAME_get_text_by_NID(X509_get_subject_name(peer),
3717 #ifndef NID_x500UniqueIdentifier
3718                                        NID_uniqueIdentifier,
3719 #else
3720                                        NID_x500UniqueIdentifier,
3721 #endif
3722                                        str,256
3723                                        );
3724             printf("[TLS - uniqueIdentifier=%s]\r\n",str);
3725
3726             /* Try to determine user name */
3727             uid = tls_userid_from_client_cert(tls_con);
3728             if ( uid ) {
3729                 /* This code is very questionable.
3730                 * How should it behave?
3731                 * The client has presented a certificate that
3732                 * contains a username.  We have validated the
3733                 * certificate but we do not automatically
3734                 * log the user in unless there is a .tlslogin
3735                 * file.
3736                 */
3737
3738                 ckstrncpy(szUserNameRequested,uid,UIDBUFLEN);
3739 #ifdef CK_LOGIN
3740                 if (zvuser(uid))
3741                     auth_finished(AUTH_VALID);
3742                 else
3743 #endif /* CK_LOGIN */
3744                     auth_finished(AUTH_USER);
3745             }
3746             else {
3747                 szUserNameRequested[0] = '\0';
3748                 auth_finished(AUTH_REJECT);
3749             }
3750         }
3751     }
3752     return(0);  /* success */
3753 }
3754
3755 int
3756 ck_ssl_outgoing(fd) int fd;
3757 {
3758     int timo = 2000;
3759
3760     if ( !ck_ssleay_is_installed() )
3761         return(-1);
3762
3763     /* bind in the network descriptor */
3764     SSL_set_fd(ssl_con,fd);
3765     SSL_set_fd(tls_con,fd);
3766
3767     /* If we are doing raw TLS then start it now ... */
3768     if (tls_only_flag) {
3769 #ifndef USE_CERT_CB
3770         if (!tls_load_certs(tls_ctx,tls_con,0)) {
3771             debug(F110,"ck_ssl_outgoing","tls_load_certs() failed",0);
3772             return(-1);
3773         }
3774 #endif /* USE_CERT_CB */
3775         if (tn_deb || debses)
3776             tn_debug("[TLS - handshake starting]");
3777         else if (ssl_verbose_flag)
3778             printf("[TLS - handshake starting]\r\n");
3779         debug(F110,"ck_ssl_outgoing","[TLS - handshake starting]",0);
3780         if (SSL_connect(tls_con) <= 0) {
3781             char errbuf[1024];
3782
3783             sprintf(errbuf,"[TLS - SSL_connect error: %s",
3784                      ERR_error_string(ERR_get_error(),NULL));
3785
3786             if (tn_deb || debses)
3787                 tn_debug(errbuf);
3788             else if ( ssl_debug_flag )
3789                 printf("%s\r\n",errbuf);
3790
3791             if (tn_deb || debses)
3792                 tn_debug("[TLS - FAILED]");
3793             else if ( ssl_verbose_flag )
3794                 printf("[TLS - FAILED]\r\n");
3795             debug(F110,"ck_ssl_outgoing","[TLS - FAILED]",0);
3796             netclos();
3797             return(-1);
3798         } else {
3799             tls_active_flag = 1;
3800             if ( !ssl_certsok_flag && (ssl_verify_flag & SSL_VERIFY_PEER) &&
3801                  !tls_is_krb5(0) ) {
3802                 char *subject = ssl_get_subject_name(tls_con);
3803
3804                 if (!subject) {
3805                     if (ssl_verify_flag & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)
3806                     {
3807                         if (tn_deb || debses)
3808                             tn_debug("[TLS - FAILED]");
3809                         else if ( ssl_verbose_flag )
3810                             printf("[TLS - FAILED]\r\n");
3811                         debug(F110,"ck_tn_tls_negotiate","[TLS - FAILED]",0);
3812
3813                         auth_finished(AUTH_REJECT);
3814                         return -1;
3815                     } else {
3816                         char prmpt[1024];
3817                         int ok;
3818                         ok = uq_ok("Warning: Server didn't provide a certificate",
3819                                    "Continue? (Y/N)", 3, NULL, 0);
3820                         if (!ok) {
3821                             if (tn_deb || debses)
3822                                 tn_debug("[TLS - FAILED]");
3823                             else if ( ssl_verbose_flag )
3824                                 printf("[TLS - FAILED]\r\n");
3825                             debug(F110,
3826                                    "ck_tn_tls_negotiate","[TLS - FAILED]",0);
3827                             auth_finished(AUTH_REJECT);
3828                             return -1;
3829                         }
3830                     }
3831                 } else if (ssl_check_server_name(tls_con, szHostName)) {
3832                     if (tn_deb || debses)
3833                         tn_debug("[TLS - FAILED]");
3834                     else if ( ssl_verbose_flag )
3835                         printf("[TLS - FAILED]\r\n");
3836                     debug(F110,
3837                            "ck_tn_tls_negotiate","[TLS - FAILED]",0);
3838                     auth_finished(AUTH_REJECT);
3839                     return -1;
3840                 }
3841             }
3842
3843             printf("[TLS - OK]\r\n");
3844             if (tn_deb || debses)
3845                 tn_debug("[TLS - OK]");
3846             debug(F110,"ck_ssl_outgoing","[TLS - OK]",0);
3847             ssl_display_connect_details(tls_con,0,ssl_verbose_flag);
3848         }
3849     }
3850     /* if we are doing raw SSL then start it now ... */
3851     else if (ssl_only_flag) {
3852 #ifndef USE_CERT_CB
3853         if (!tls_load_certs(ssl_ctx,ssl_con,0))
3854             return(-1);
3855 #endif /* USE_CERT_CB */
3856         if (tn_deb || debses)
3857             tn_debug("[SSL - handshake starting]");
3858         else if ( ssl_verbose_flag )
3859             printf("[SSL - handshake starting]\r\n");
3860         debug(F110,"ck_ssl_outgoing","[SSL - handshake starting]",0);
3861         if (SSL_connect(ssl_con) <= 0) {
3862             if ( ssl_debug_flag ) {
3863                 char errbuf[1024];
3864
3865                 sprintf(errbuf,"[SSL - SSL_connect error: %s",
3866                          ERR_error_string(ERR_get_error(),NULL));
3867                 printf("%s\r\n",errbuf);
3868             }
3869             if (tn_deb || debses)
3870                 tn_debug("[SSL - FAILED]");
3871             else if ( ssl_verbose_flag )
3872                 printf("[SSL - FAILED]\r\n");
3873             debug(F110,"ck_ssl_outgoing","[SSL - FAILED]",0);
3874             return(-1);
3875         } else {
3876             ssl_active_flag = 1;
3877
3878             if ( !ssl_certsok_flag && (ssl_verify_flag & SSL_VERIFY_PEER) &&
3879                  !tls_is_krb5(0)) {
3880                 char *subject = ssl_get_subject_name(ssl_con);
3881
3882                 if (!subject) {
3883                     if (ssl_verify_flag & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)
3884                     {
3885                         if (tn_deb || debses)
3886                             tn_debug("[SSL - FAILED]");
3887                         else if ( ssl_verbose_flag )
3888                             printf("[SSL - FAILED]\r\n");
3889                         debug(F110,"ck_tn_tls_negotiate","[SSL - FAILED]",0);
3890
3891                         auth_finished(AUTH_REJECT);
3892                         return -1;
3893                     } else {
3894                         char prmpt[1024];
3895                         int ok;
3896                         ok = uq_ok("Warning: Server didn't provide a certificate",
3897                                    "Continue? (Y/N)", 3, NULL, 0);
3898                         if (!ok) {
3899                             if (tn_deb || debses)
3900                                 tn_debug("[SSL - FAILED]");
3901                             else if ( ssl_verbose_flag )
3902                                 printf("[SSL - FAILED]\r\n");
3903                             debug(F110,
3904                                    "ck_tn_tls_negotiate","[SSL - FAILED]",0);
3905                             auth_finished(AUTH_REJECT);
3906                             return -1;
3907                         }
3908                     }
3909                 } else if (ssl_check_server_name(ssl_con, szHostName)) {
3910                     if (tn_deb || debses)
3911                         tn_debug("[SSL - FAILED]");
3912                     else if ( ssl_verbose_flag )
3913                         printf("[SSL - FAILED]\r\n");
3914                     debug(F110, "ck_tn_tls_negotiate","[SSL - FAILED]",0);
3915                     auth_finished(AUTH_REJECT);
3916                     return -1;
3917                 }
3918             }
3919
3920             printf("[SSL - OK]\r\n");
3921             if (tn_deb || debses)
3922                 tn_debug("[SSL - OK]");
3923             debug(F110,"ck_ssl_outgoing","[SSL - OK]",0);
3924             ssl_display_connect_details(ssl_con,0,ssl_verbose_flag);
3925         }
3926     }
3927     return(0);  /* success */
3928 }
3929
3930 #ifndef NOHTTP
3931 int
3932 ck_ssl_http_client(fd, hostname) int fd; char * hostname;
3933 {
3934     int timo = 2000;
3935
3936     if ( !ck_ssleay_is_installed() )
3937         return(-1);
3938
3939     /* bind in the network descriptor */
3940     SSL_set_fd(tls_http_con,fd);
3941
3942     /* If we are doing raw TLS then start it now ... */
3943     if (1) {
3944 #ifndef USE_CERT_CB
3945         if (!tls_load_certs(tls_http_ctx,tls_http_con,0)) {
3946             debug(F110,"ck_ssl_http_client","tls_load_certs() failed",0);
3947             return(-1);
3948         }
3949 #endif /* USE_CERT_CB */
3950         if (tn_deb || debses)
3951             tn_debug("[TLS - handshake starting]");
3952         else if (ssl_verbose_flag)
3953             printf("[TLS - handshake starting]\r\n");
3954         debug(F110,"ck_ssl_outgoing","[TLS - handshake starting]",0);
3955         if (SSL_connect(tls_http_con) <= 0) {
3956             char errbuf[1024];
3957
3958             sprintf(errbuf,"[TLS - SSL_connect error: %s",
3959                      ERR_error_string(ERR_get_error(),NULL));
3960
3961             if (tn_deb || debses)
3962                 tn_debug(errbuf);
3963             else if ( ssl_debug_flag )
3964                 printf("%s\r\n",errbuf);
3965
3966             if (tn_deb || debses)
3967                 tn_debug("[TLS - FAILED]");
3968             else if ( ssl_verbose_flag )
3969                 printf("[TLS - FAILED]\r\n");
3970             debug(F110,"ck_ssl_http_client","[TLS - FAILED]",0);
3971             http_close();
3972             return(-1);
3973         } else {
3974             tls_http_active_flag = 1;
3975             if ( !ssl_certsok_flag && (ssl_verify_flag & SSL_VERIFY_PEER) &&
3976                  !tls_is_krb5(3) ) {
3977                 char *subject = ssl_get_subject_name(tls_http_con);
3978
3979                 if (!subject) {
3980                     if (ssl_verify_flag & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)
3981                     {
3982                         if (tn_deb || debses)
3983                             tn_debug("[TLS - FAILED]");
3984                         else if ( ssl_verbose_flag )
3985                             printf("[TLS - FAILED]\r\n");
3986                         debug(F110,"ck_tn_tls_negotiate","[TLS - FAILED]",0);
3987                         return -1;
3988                     } else {
3989                         char prmpt[1024];
3990                         int ok;
3991                         ok = uq_ok("Warning: Server didn't provide a certificate",
3992                                    "Continue? (Y/N)", 3, NULL, 0);
3993                         if (!ok) {
3994                             if (tn_deb || debses)
3995                                 tn_debug("[TLS - FAILED]");
3996                             else if ( ssl_verbose_flag )
3997                                 printf("[TLS - FAILED]\r\n");
3998                             debug(F110,
3999                                    "ck_tn_tls_negotiate","[TLS - FAILED]",0);
4000                             return -1;
4001                         }
4002                     }
4003                 } else if (ssl_check_server_name(tls_http_con, hostname)) {
4004                     if (tn_deb || debses)
4005                         tn_debug("[TLS - FAILED]");
4006                     else if ( ssl_verbose_flag )
4007                         printf("[TLS - FAILED]\r\n");
4008                     debug(F110,
4009                            "ck_tn_tls_negotiate","[TLS - FAILED]",0);
4010                     return -1;
4011                 }
4012             }
4013
4014             printf("[TLS - OK]\r\n");
4015             if (tn_deb || debses)
4016                 tn_debug("[TLS - OK]");
4017             debug(F110,"ck_ssl_outgoing","[TLS - OK]",0);
4018             ssl_display_connect_details(tls_http_con,0,ssl_verbose_flag);
4019         }
4020     }
4021     return(0);  /* success */
4022 }
4023 #endif /* NOHTTP */
4024 int
4025 ck_ssl_renegotiate_ciphers()
4026 {
4027
4028     if ( !ck_ssleay_is_installed() )
4029         return(0);
4030
4031     if ( !sstelnet )
4032         return(0);
4033
4034     if ( ssl_active_flag )
4035         return SSL_renegotiate(ssl_con);
4036     else if ( tls_active_flag )
4037         return SSL_renegotiate(tls_con);
4038     return(0);
4039 }
4040
4041 #ifdef NT
4042 int
4043 ck_X509_save_cert_to_user_store(X509 *cert)
4044 {
4045 #ifdef X509V3_EXT_DUMP_UNKNOWN
4046     char path[CKMAXPATH];
4047     char hash[16];
4048     char * GetAppData(int);
4049     BIO * out=NULL;
4050
4051     if ( cert == NULL )
4052         return(0);
4053
4054     sprintf(hash,"%08lx",X509_subject_name_hash(cert));
4055     ckmakmsg(path,CKMAXPATH,GetAppData(0),"kermit 95/certs/",
4056              hash,".0");
4057
4058
4059     out=BIO_new(BIO_s_file());
4060     if (out == NULL)
4061     {
4062         ERR_print_errors(bio_err);
4063         return(0);
4064     }
4065     if (BIO_write_filename(out,path) <= 0) {
4066         perror(path);
4067         return(0);
4068     }
4069
4070     X509_print_ex(out, cert, XN_FLAG_SEP_MULTILINE, X509V3_EXT_DUMP_UNKNOWN);
4071     if (!PEM_write_bio_X509(out,cert)) {
4072         BIO_printf(bio_err,"unable to write certificate\n");
4073         ERR_print_errors(bio_err);
4074         BIO_free_all(out);
4075         return(0);
4076     }
4077     BIO_free_all(out);
4078     return(1);
4079 #else /* X509V3_EXT_DUMP_UNKNOWN */
4080     return(0);
4081 #endif /* X509V3_EXT_DUMP_UNKNOWN */
4082 }
4083 #endif /* NT */
4084
4085 #ifndef OS2
4086 /* The following function should be replaced by institution specific */
4087 /* code that will convert an X509 cert structure to a userid for the */
4088 /* purposes of client to host login.  The example code included      */
4089 /* simply returns the UID field of the Subject if it exists.         */
4090
4091 /* X509_to_user() returns 0 if valid userid in 'userid', else -1 */
4092 int
4093 X509_to_user(X509 *peer_cert, char *userid, int len)
4094 {
4095 #ifdef X509_UID_TO_USER
4096     /* BEGIN EXAMPLE */
4097     int err;
4098
4099     if (!(peer_cert && userid) || len <= 0)
4100         return -1;
4101
4102     userid[0] = '\0';
4103     debug(F110,"X509_to_user() subject",
4104            X509_NAME_oneline(X509_get_subject_name(peer_cert),NULL,0),0);
4105
4106     /* userid is in cert subject /UID */
4107     err = X509_NAME_get_text_by_NID(X509_get_subject_name(peer_cert),
4108 #ifndef NID_x500UniqueIdentifier
4109                                      NID_uniqueIdentifier,
4110 #else
4111                                      NID_x500UniqueIdentifier,
4112 #endif
4113                                      userid, len);
4114
4115     debug(F111,"X509_to_user() userid",userid,err);
4116     if (err > 0)
4117         return 0;
4118
4119     /* END EXAMPLE */
4120 #else /* X509_UID_TO_USER */
4121 #ifdef X509_SUBJECT_ALT_NAME_TO_USER
4122     /* BEGIN EXAMPLE */
4123     int i;
4124     X509_EXTENSION *ext = NULL;
4125     STACK_OF(GENERAL_NAME) *ialt = NULL;
4126     GENERAL_NAME *gen = NULL;
4127     char email[256];
4128
4129     if (!(peer_cert && userid) || len <= 0)
4130         return -1;
4131
4132     userid[0] = '\0';
4133     email[0] = '\0';
4134     debug(F110,"X509_to_user() subject",
4135            X509_NAME_oneline(X509_get_subject_name(peer_cert),NULL,0),0);
4136
4137     if ((i = X509_get_ext_by_NID(peer_cert, NID_subject_alt_name, -1))<0)
4138         return -1;
4139     if (!(ext = X509_get_ext(peer_cert, i)))
4140         return -1;
4141     X509V3_add_standard_extensions();
4142     if (!(ialt = X509V3_EXT_d2i(ext)))
4143         return -1;
4144     for (i = 0; i < sk_GENERAL_NAME_num(ialt); i++) {
4145         gen = sk_GENERAL_NAME_value(ialt, i);
4146         if (gen->type == GEN_DNS) {
4147             if(!gen->d.ia5 || !gen->d.ia5->length)
4148                 break;
4149             if ( gen->d.ia5->length + 1 > sizeof(email) ) {
4150                 goto cleanup;
4151             }
4152             memcpy(email, gen->d.ia5->data, gen->d.ia5->length);
4153             email[gen->d.ia5->length] = 0;
4154             break;
4155         }
4156     }
4157   cleanup:
4158     X509V3_EXT_cleanup();
4159     if (ialt)
4160         sk_GENERAL_NAME_free(ialt);
4161
4162     debug(F110,"X509_to_user() email",email,0);
4163
4164     if ( email[0] ) {
4165         char * domain = NULL;
4166
4167         /* Find domain */
4168         for ( i=0 ; email[i] ; i++ ) {
4169             if ( email[i] == '@' ) {
4170                 email[i] = '\0';
4171                 domain = &email[i+1];
4172                 break;
4173             }
4174         }
4175
4176         if ( domain ) {
4177             /* XXX - Put code to Verify domain here */
4178
4179             if ( /* domain is okay */ 1 )
4180                 ckstrncpy(userid,email,len);
4181         }
4182     }
4183
4184     return(userid[0] ? 0 : -1);
4185     /* END EXAMPLE */
4186 #endif /* X509_SUBJECT_ALT_NAME_TO_USER */
4187 #endif /* X509_UID_TO_USER */
4188     return -1;
4189 }
4190
4191 /* The following function should be replaced by institution specific */
4192 /* code that will determine whether or not the combination of the    */
4193 /* provided X509 certificate and username is valid for automatic     */
4194 /* login.   Whereas X509_to_user() is used to provide authentication */
4195 /* of the user, the X509_userok() function is used to provide        */
4196 /* authorization.  The certificate passed into X509_userok() does    */
4197 /* need to map to a userid; nor would the userid it would map to     */
4198 /* need to match the userid provided to the function.  There are     */
4199 /* numerous circumstances in which it is beneficial to have the ability */
4200 /* for multiple users to gain access to a common account such as     */
4201 /* 'root' on Unix; or a class account on a web server.  In Unix we   */
4202 /* implement this capability with the ~userid/.tlslogin file which   */
4203 /* a list of X509 certificates which may be used to access the       */
4204 /* account 'userid'.                                                 */
4205
4206 /* X509_to_user() returns 0 if access is denied; 1 is access is permitted */
4207 int
4208 X509_userok(X509 * peer_cert, const char * userid)
4209 {
4210 #ifndef VMS
4211     /* check if clients cert is in "user"'s ~/.tlslogin file */
4212     char buf[512];
4213     int r = 0;
4214     FILE *fp;
4215     struct passwd *pwd;
4216     X509 *file_cert;
4217
4218     if ( peer_cert == NULL )
4219         return(0);
4220
4221     if (!(pwd = getpwnam(userid)))
4222        return 0;
4223     if (strlen(pwd->pw_dir) > 500)
4224        return(0);
4225     sprintf(buf, "%s/.tlslogin", pwd->pw_dir);
4226
4227     if (!(fp = fopen(buf, "r")))
4228         return 0;
4229     while (!r && (file_cert = PEM_read_X509(fp, NULL, NULL, NULL))) {
4230         if (!ASN1_STRING_cmp(peer_cert->signature, file_cert->signature))
4231             r = 1;
4232         X509_free(file_cert);
4233     }
4234     fclose(fp);
4235     return(r);
4236 #else /* VMS */
4237     /* Need to implement an appropriate function for VMS */
4238     return(0);
4239 #endif /* VMS */
4240 }
4241 #endif /* OS2 */
4242 #endif /* CK_SSL */