git.sur5r.net Git - openldap/blob - libraries/libldap/tls.c

   1 /* $OpenLDAP$ */
   2 /*
   3  * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.
   4  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   5  *
   6  * tls.c - Handle tls/ssl using SSLeay or OpenSSL.
   7  */
   8
   9 #include "portable.h"
  10 #include "ldap_config.h"
  11
  12 #include <stdio.h>
  13
  14 #include <ac/stdlib.h>
  15 #include <ac/errno.h>
  16 #include <ac/socket.h>
  17 #include <ac/string.h>
  18 #include <ac/time.h>
  19 #include <ac/unistd.h>
  20 #include <ac/param.h>
  21 #include <ac/dirent.h>
  22
  23 #include "ldap-int.h"
  24
  25 #ifdef HAVE_TLS
  26
  27 #ifdef LDAP_R_COMPILE
  28 #include <ldap_pvt_thread.h>
  29 #endif
  30
  31 #ifdef HAVE_OPENSSL_SSL_H
  32 #include <openssl/ssl.h>
  33 #include <openssl/x509v3.h>
  34 #include <openssl/err.h>
  35 #include <openssl/rand.h>
  36 #include <openssl/safestack.h>
  37 #elif defined( HAVE_SSL_H )
  38 #include <ssl.h>
  39 #endif
  40
  41 static int  tls_opt_trace = 1;
  42 static char *tls_opt_certfile = NULL;
  43 static char *tls_opt_keyfile = NULL;
  44 static char *tls_opt_cacertfile = NULL;
  45 static char *tls_opt_cacertdir = NULL;
  46 static int  tls_opt_require_cert = LDAP_OPT_X_TLS_DEMAND;
  47 static char *tls_opt_ciphersuite = NULL;
  48 static char *tls_opt_randfile = NULL;
  49
  50 #define HAS_TLS( sb )   ber_sockbuf_ctrl( sb, LBER_SB_OPT_HAS_IO, \
  51                                 (void *)&sb_tls_sbio )
  52
  53 static void tls_report_error( void );
  54
  55 static void tls_info_cb( SSL *ssl, int where, int ret );
  56 static int tls_verify_cb( int ok, X509_STORE_CTX *ctx );
  57 static int tls_verify_ok( int ok, X509_STORE_CTX *ctx );
  58 static RSA * tls_tmp_rsa_cb( SSL *ssl, int is_export, int key_length );
  59 static STACK_OF(X509_NAME) * get_ca_list( char * bundle, char * dir );
  60
  61 #if 0   /* Currently this is not used by anyone */
  62 static DH * tls_tmp_dh_cb( SSL *ssl, int is_export, int key_length );
  63 #endif
  64
  65 static SSL_CTX *tls_def_ctx = NULL;
  66
  67 static int tls_seed_PRNG( const char *randfile );
  68
  69 #ifdef LDAP_R_COMPILE
  70 /*
  71  * provide mutexes for the SSLeay library.
  72  */
  73 static ldap_pvt_thread_mutex_t  tls_mutexes[CRYPTO_NUM_LOCKS];
  74
  75 static void tls_locking_cb( int mode, int type, const char *file, int line )
  76 {
  77         if ( mode & CRYPTO_LOCK ) {
  78                 ldap_pvt_thread_mutex_lock( &tls_mutexes[type] );
  79         } else {
  80                 ldap_pvt_thread_mutex_unlock( &tls_mutexes[type] );
  81         }
  82 }
  83
  84 /*
  85  * an extra mutex for the default ctx.
  86  */
  87
  88 static ldap_pvt_thread_mutex_t tls_def_ctx_mutex;
  89
  90 static void tls_init_threads( void )
  91 {
  92         int i;
  93
  94         for( i=0; i< CRYPTO_NUM_LOCKS ; i++ ) {
  95                 ldap_pvt_thread_mutex_init( &tls_mutexes[i] );
  96         }
  97         CRYPTO_set_locking_callback( tls_locking_cb );
  98         /* FIXME: the thread id should be added somehow... */
  99
 100         ldap_pvt_thread_mutex_init( &tls_def_ctx_mutex );
 101 }
 102 #endif /* LDAP_R_COMPILE */
 103
 104 /*
 105  * Tear down the TLS subsystem. Should only be called once.
 106  */
 107 void
 108 ldap_pvt_tls_destroy( void )
 109 {
 110         SSL_CTX_free(tls_def_ctx);
 111         tls_def_ctx = NULL;
 112
 113         EVP_cleanup();
 114         ERR_free_strings();
 115
 116         if ( tls_opt_certfile ) {
 117                 LDAP_FREE( tls_opt_certfile );
 118                 tls_opt_certfile = NULL;
 119         }
 120         if ( tls_opt_keyfile ) {
 121                 LDAP_FREE( tls_opt_keyfile );
 122                 tls_opt_keyfile = NULL;
 123         }
 124         if ( tls_opt_cacertfile ) {
 125                 LDAP_FREE( tls_opt_cacertfile );
 126                 tls_opt_cacertfile = NULL;
 127         }
 128         if ( tls_opt_cacertdir ) {
 129                 LDAP_FREE( tls_opt_cacertdir );
 130                 tls_opt_cacertdir = NULL;
 131         }
 132         if ( tls_opt_ciphersuite ) {
 133                 LDAP_FREE( tls_opt_ciphersuite );
 134                 tls_opt_ciphersuite = NULL;
 135         }
 136         if ( tls_opt_randfile ) {
 137                 LDAP_FREE( tls_opt_randfile );
 138                 tls_opt_randfile = NULL;
 139         }
 140 }
 141
 142 /*
 143  * Initialize TLS subsystem. Should be called only once.
 144  */
 145 int
 146 ldap_pvt_tls_init( void )
 147 {
 148         static int tls_initialized = 0;
 149
 150         if ( tls_initialized ) return 0;
 151         tls_initialized = 1;
 152
 153 #ifdef HAVE_EBCDIC
 154         {
 155                 char *file = LDAP_STRDUP( tls_opt_randfile );
 156                 if ( file ) __atoe( file );
 157                 (void) tls_seed_PRNG( file );
 158                 LDAP_FREE( file );
 159         }
 160 #else
 161         (void) tls_seed_PRNG( tls_opt_randfile );
 162 #endif
 163
 164 #ifdef LDAP_R_COMPILE
 165         tls_init_threads();
 166 #endif
 167
 168         SSL_load_error_strings();
 169         SSLeay_add_ssl_algorithms();
 170
 171         /* FIXME: mod_ssl does this */
 172         X509V3_add_standard_extensions();
 173         return 0;
 174 }
 175
 176 /*
 177  * initialize the default context
 178  */
 179 int
 180 ldap_pvt_tls_init_def_ctx( void )
 181 {
 182         STACK_OF(X509_NAME) *calist;
 183         int rc = 0;
 184         char *ciphersuite = tls_opt_ciphersuite;
 185         char *cacertfile = tls_opt_cacertfile;
 186         char *cacertdir = tls_opt_cacertdir;
 187         char *certfile = tls_opt_certfile;
 188         char *keyfile = tls_opt_keyfile;
 189
 190 #ifdef HAVE_EBCDIC
 191         /* This ASCII/EBCDIC handling is a real pain! */
 192         if ( ciphersuite ) {
 193                 ciphersuite = LDAP_STRDUP( ciphersuite );
 194                 __atoe( ciphersuite );
 195         }
 196         if ( cacertfile ) {
 197                 cacertfile = LDAP_STRDUP( cacertfile );
 198                 __atoe( cacertfile );
 199         }
 200         if ( cacertdir ) {
 201                 cacertdir = LDAP_STRDUP( cacertdir );
 202                 __atoe( cacertdir );
 203         }
 204         if ( certfile ) {
 205                 certfile = LDAP_STRDUP( certfile );
 206                 __atoe( certfile );
 207         }
 208         if ( keyfile ) {
 209                 keyfile = LDAP_STRDUP( keyfile );
 210                 __atoe( keyfile );
 211         }
 212 #endif
 213
 214 #ifdef LDAP_R_COMPILE
 215         ldap_pvt_thread_mutex_lock( &tls_def_ctx_mutex );
 216 #endif
 217         if ( tls_def_ctx == NULL ) {
 218                 int i;
 219                 tls_def_ctx = SSL_CTX_new( SSLv23_method() );
 220                 if ( tls_def_ctx == NULL ) {
 221 #ifdef NEW_LOGGING
 222                         LDAP_LOG ( TRANSPORT, ERR, "ldap_pvt_tls_init_def_ctx: "
 223                                 "TLS could not allocate default ctx (%d).\n",
 224                                 ERR_peek_error(), 0, 0 );
 225 #else
 226                         Debug( LDAP_DEBUG_ANY,
 227                            "TLS: could not allocate default ctx (%lu).\n",
 228                                 ERR_peek_error(),0,0);
 229 #endif
 230                         rc = -1;
 231                         goto error_exit;
 232                 }
 233
 234                 if ( tls_opt_ciphersuite &&
 235                         !SSL_CTX_set_cipher_list( tls_def_ctx, ciphersuite ) )
 236                 {
 237 #ifdef NEW_LOGGING
 238                         LDAP_LOG ( TRANSPORT, ERR, "ldap_pvt_tls_init_def_ctx: "
 239                                 "TLS could not set cipher list %s.\n",
 240                                 tls_opt_ciphersuite, 0, 0 );
 241 #else
 242                         Debug( LDAP_DEBUG_ANY,
 243                                    "TLS: could not set cipher list %s.\n",
 244                                    tls_opt_ciphersuite, 0, 0 );
 245 #endif
 246                         tls_report_error();
 247                         rc = -1;
 248                         goto error_exit;
 249                 }
 250
 251                 if (tls_opt_cacertfile != NULL || tls_opt_cacertdir != NULL) {
 252                         if ( !SSL_CTX_load_verify_locations( tls_def_ctx,
 253                                         cacertfile, cacertdir ) ||
 254                                 !SSL_CTX_set_default_verify_paths( tls_def_ctx ) )
 255                         {
 256 #ifdef NEW_LOGGING
 257                                 LDAP_LOG ( TRANSPORT, ERR,
 258                                         "ldap_pvt_tls_init_def_ctx: "
 259                                         "TLS could not load verify locations "
 260                                         "(file:`%s',dir:`%s').\n",
 261                                         tls_opt_cacertfile ? tls_opt_cacertfile : "",
 262                                         tls_opt_cacertdir ? tls_opt_cacertdir : "", 0 );
 263 #else
 264                                 Debug( LDAP_DEBUG_ANY, "TLS: "
 265                                         "could not load verify locations (file:`%s',dir:`%s').\n",
 266                                         tls_opt_cacertfile ? tls_opt_cacertfile : "",
 267                                         tls_opt_cacertdir ? tls_opt_cacertdir : "",
 268                                         0 );
 269 #endif
 270                                 tls_report_error();
 271                                 rc = -1;
 272                                 goto error_exit;
 273                         }
 274
 275                         calist = get_ca_list( cacertfile, cacertdir );
 276                         if ( !calist ) {
 277 #ifdef NEW_LOGGING
 278                                 LDAP_LOG ( TRANSPORT, ERR, "ldap_pvt_tls_init_def_ctx: "
 279                                         "TLS could not load client CA list (file: `%s',dir:`%s')\n",
 280                                         tls_opt_cacertfile ? tls_opt_cacertfile : "",
 281                                         tls_opt_cacertdir ? tls_opt_cacertdir : "", 0 );
 282 #else
 283                                 Debug( LDAP_DEBUG_ANY, "TLS: "
 284                                         "could not load client CA list (file:`%s',dir:`%s').\n",
 285                                         tls_opt_cacertfile ? tls_opt_cacertfile : "",
 286                                         tls_opt_cacertdir ? tls_opt_cacertdir : "",
 287                                         0 );
 288 #endif
 289                                 tls_report_error();
 290                                 rc = -1;
 291                                 goto error_exit;
 292                         }
 293
 294                         SSL_CTX_set_client_CA_list( tls_def_ctx, calist );
 295                 }
 296
 297                 if ( tls_opt_keyfile &&
 298                         !SSL_CTX_use_PrivateKey_file( tls_def_ctx,
 299                                 keyfile, SSL_FILETYPE_PEM ) )
 300                 {
 301 #ifdef NEW_LOGGING
 302                         LDAP_LOG ( TRANSPORT, ERR, "ldap_pvt_tls_init_def_ctx: "
 303                                 "TLS could not use key file `%s'.\n", tls_opt_keyfile, 0, 0 );
 304 #else
 305                         Debug( LDAP_DEBUG_ANY,
 306                                 "TLS: could not use key file `%s'.\n",
 307                                 tls_opt_keyfile,0,0);
 308 #endif
 309                         tls_report_error();
 310                         rc = -1;
 311                         goto error_exit;
 312                 }
 313
 314                 if ( tls_opt_certfile &&
 315                         !SSL_CTX_use_certificate_file( tls_def_ctx,
 316                                 certfile, SSL_FILETYPE_PEM ) )
 317                 {
 318 #ifdef NEW_LOGGING
 319                         LDAP_LOG ( TRANSPORT, ERR, "ldap_pvt_tls_init_def_ctx: "
 320                                 "TLS could not use certificate `%s'.\n",
 321                                 tls_opt_certfile, 0, 0 );
 322 #else
 323                         Debug( LDAP_DEBUG_ANY,
 324                                 "TLS: could not use certificate `%s'.\n",
 325                                 tls_opt_certfile,0,0);
 326 #endif
 327                         tls_report_error();
 328                         rc = -1;
 329                         goto error_exit;
 330                 }
 331
 332                 if ( ( tls_opt_certfile || tls_opt_keyfile ) &&
 333                         !SSL_CTX_check_private_key( tls_def_ctx ) )
 334                 {
 335 #ifdef NEW_LOGGING
 336                         LDAP_LOG ( TRANSPORT, ERR,
 337                                 "ldap_pvt_tls_init_def_ctx: TLS private key mismatch.\n",
 338                                 0, 0, 0 );
 339 #else
 340                         Debug( LDAP_DEBUG_ANY,
 341                                 "TLS: private key mismatch.\n",
 342                                 0,0,0);
 343 #endif
 344                         tls_report_error();
 345                         rc = -1;
 346                         goto error_exit;
 347                 }
 348
 349                 if ( tls_opt_trace ) {
 350                         SSL_CTX_set_info_callback( tls_def_ctx, tls_info_cb );
 351                 }
 352
 353                 i = SSL_VERIFY_NONE;
 354                 if ( tls_opt_require_cert ) {
 355                         i = SSL_VERIFY_PEER;
 356                         if ( tls_opt_require_cert == LDAP_OPT_X_TLS_DEMAND ||
 357                                  tls_opt_require_cert == LDAP_OPT_X_TLS_HARD ) {
 358                                 i |= SSL_VERIFY_FAIL_IF_NO_PEER_CERT;
 359                         }
 360                 }
 361
 362                 SSL_CTX_set_verify( tls_def_ctx, i,
 363                         tls_opt_require_cert == LDAP_OPT_X_TLS_ALLOW ?
 364                         tls_verify_ok : tls_verify_cb );
 365                 SSL_CTX_set_tmp_rsa_callback( tls_def_ctx, tls_tmp_rsa_cb );
 366                 /* SSL_CTX_set_tmp_dh_callback( tls_def_ctx, tls_tmp_dh_cb ); */
 367         }
 368 error_exit:
 369         if ( rc == -1 && tls_def_ctx != NULL ) {
 370                 SSL_CTX_free( tls_def_ctx );
 371                 tls_def_ctx = NULL;
 372         }
 373 #ifdef HAVE_EBCDIC
 374         LDAP_FREE( ciphersuite );
 375         LDAP_FREE( cacertfile );
 376         LDAP_FREE( cacertdir );
 377         LDAP_FREE( certfile );
 378         LDAP_FREE( keyfile );
 379 #endif
 380 #ifdef LDAP_R_COMPILE
 381         ldap_pvt_thread_mutex_unlock( &tls_def_ctx_mutex );
 382 #endif
 383         return rc;
 384 }
 385
 386 static STACK_OF(X509_NAME) *
 387 get_ca_list( char * bundle, char * dir )
 388 {
 389         STACK_OF(X509_NAME) *ca_list = NULL;
 390
 391         if ( bundle ) {
 392                 ca_list = SSL_load_client_CA_file( bundle );
 393         }
 394 #if defined(HAVE_DIRENT_H) || defined(dirent)
 395         if ( dir ) {
 396                 int freeit = 0;
 397
 398                 if ( !ca_list ) {
 399                         ca_list = sk_X509_NAME_new_null();
 400                         freeit = 1;
 401                 }
 402                 if ( !SSL_add_dir_cert_subjects_to_stack( ca_list, dir ) &&
 403                         freeit ) {
 404                         sk_X509_NAME_free( ca_list );
 405                         ca_list = NULL;
 406                 }
 407         }
 408 #endif
 409 done:
 410         return ca_list;
 411 }
 412
 413 static SSL *
 414 alloc_handle( void *ctx_arg )
 415 {
 416         SSL_CTX *ctx;
 417         SSL     *ssl;
 418
 419         if ( ctx_arg ) {
 420                 ctx = (SSL_CTX *) ctx_arg;
 421         } else {
 422                 if ( ldap_pvt_tls_init_def_ctx() < 0 ) return NULL;
 423                 ctx = tls_def_ctx;
 424         }
 425
 426         ssl = SSL_new( ctx );
 427         if ( ssl == NULL ) {
 428 #ifdef NEW_LOGGING
 429                 LDAP_LOG ( TRANSPORT, ERR,
 430                         "alloc_handle: TLS can't create ssl handle.\n", 0, 0, 0 );
 431 #else
 432                 Debug( LDAP_DEBUG_ANY,"TLS: can't create ssl handle.\n",0,0,0);
 433 #endif
 434                 return NULL;
 435         }
 436         return ssl;
 437 }
 438
 439 static int
 440 update_flags( Sockbuf *sb, SSL * ssl, int rc )
 441 {
 442         int err = SSL_get_error(ssl, rc);
 443
 444         sb->sb_trans_needs_read  = 0;
 445         sb->sb_trans_needs_write = 0;
 446
 447         if (err == SSL_ERROR_WANT_READ) {
 448                 sb->sb_trans_needs_read  = 1;
 449                 return 1;
 450
 451         } else if (err == SSL_ERROR_WANT_WRITE) {
 452                 sb->sb_trans_needs_write = 1;
 453                 return 1;
 454
 455         } else if (err == SSL_ERROR_WANT_CONNECT) {
 456                 return 1;
 457         }
 458         return 0;
 459 }
 460
 461 /*
 462  * TLS support for LBER Sockbufs
 463  */
 464
 465 struct tls_data {
 466         SSL                     *ssl;
 467         Sockbuf_IO_Desc         *sbiod;
 468 };
 469
 470 static BIO_METHOD sb_tls_bio_method;
 471
 472 static int
 473 sb_tls_setup( Sockbuf_IO_Desc *sbiod, void *arg )
 474 {
 475         struct tls_data         *p;
 476         BIO                     *bio;
 477
 478         assert( sbiod != NULL );
 479
 480         p = LBER_MALLOC( sizeof( *p ) );
 481         if ( p == NULL ) {
 482                 return -1;
 483         }
 484
 485         p->ssl = (SSL *)arg;
 486         p->sbiod = sbiod;
 487         bio = BIO_new( &sb_tls_bio_method );
 488         bio->ptr = (void *)p;
 489         SSL_set_bio( p->ssl, bio, bio );
 490         sbiod->sbiod_pvt = p;
 491         return 0;
 492 }
 493
 494 static int
 495 sb_tls_remove( Sockbuf_IO_Desc *sbiod )
 496 {
 497         struct tls_data         *p;
 498
 499         assert( sbiod != NULL );
 500         assert( sbiod->sbiod_pvt != NULL );
 501
 502         p = (struct tls_data *)sbiod->sbiod_pvt;
 503         SSL_free( p->ssl );
 504         LBER_FREE( sbiod->sbiod_pvt );
 505         sbiod->sbiod_pvt = NULL;
 506         return 0;
 507 }
 508
 509 static int
 510 sb_tls_close( Sockbuf_IO_Desc *sbiod )
 511 {
 512         struct tls_data         *p;
 513
 514         assert( sbiod != NULL );
 515         assert( sbiod->sbiod_pvt != NULL );
 516
 517         p = (struct tls_data *)sbiod->sbiod_pvt;
 518         SSL_shutdown( p->ssl );
 519         return 0;
 520 }
 521
 522 static int
 523 sb_tls_ctrl( Sockbuf_IO_Desc *sbiod, int opt, void *arg )
 524 {
 525         struct tls_data         *p;
 526
 527         assert( sbiod != NULL );
 528         assert( sbiod->sbiod_pvt != NULL );
 529
 530         p = (struct tls_data *)sbiod->sbiod_pvt;
 531
 532         if ( opt == LBER_SB_OPT_GET_SSL ) {
 533                 *((SSL **)arg) = p->ssl;
 534                 return 1;
 535
 536         } else if ( opt == LBER_SB_OPT_DATA_READY ) {
 537                 if( SSL_pending( p->ssl ) > 0 ) {
 538                         return 1;
 539                 }
 540         }
 541
 542         return LBER_SBIOD_CTRL_NEXT( sbiod, opt, arg );
 543 }
 544
 545 static ber_slen_t
 546 sb_tls_read( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len)
 547 {
 548         struct tls_data         *p;
 549         ber_slen_t              ret;
 550         int                     err;
 551
 552         assert( sbiod != NULL );
 553         assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
 554
 555         p = (struct tls_data *)sbiod->sbiod_pvt;
 556
 557         ret = SSL_read( p->ssl, (char *)buf, len );
 558 #ifdef HAVE_WINSOCK
 559         errno = WSAGetLastError();
 560 #endif
 561         err = SSL_get_error( p->ssl, ret );
 562         if (err == SSL_ERROR_WANT_READ ) {
 563                 sbiod->sbiod_sb->sb_trans_needs_read = 1;
 564                 errno = EWOULDBLOCK;
 565         }
 566         else
 567                 sbiod->sbiod_sb->sb_trans_needs_read = 0;
 568         return ret;
 569 }
 570
 571 static ber_slen_t
 572 sb_tls_write( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len)
 573 {
 574         struct tls_data         *p;
 575         ber_slen_t              ret;
 576         int                     err;
 577
 578         assert( sbiod != NULL );
 579         assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
 580
 581         p = (struct tls_data *)sbiod->sbiod_pvt;
 582
 583         ret = SSL_write( p->ssl, (char *)buf, len );
 584 #ifdef HAVE_WINSOCK
 585         errno = WSAGetLastError();
 586 #endif
 587         err = SSL_get_error( p->ssl, ret );
 588         if (err == SSL_ERROR_WANT_WRITE ) {
 589                 sbiod->sbiod_sb->sb_trans_needs_write = 1;
 590                 errno = EWOULDBLOCK;
 591
 592         } else {
 593                 sbiod->sbiod_sb->sb_trans_needs_write = 0;
 594         }
 595         return ret;
 596 }
 597
 598 static Sockbuf_IO sb_tls_sbio =
 599 {
 600         sb_tls_setup,           /* sbi_setup */
 601         sb_tls_remove,          /* sbi_remove */
 602         sb_tls_ctrl,            /* sbi_ctrl */
 603         sb_tls_read,            /* sbi_read */
 604         sb_tls_write,           /* sbi_write */
 605         sb_tls_close            /* sbi_close */
 606 };
 607
 608 static int
 609 sb_tls_bio_create( BIO *b ) {
 610         b->init = 1;
 611         b->num = 0;
 612         b->ptr = NULL;
 613         b->flags = 0;
 614         return 1;
 615 }
 616
 617 static int
 618 sb_tls_bio_destroy( BIO *b )
 619 {
 620         if ( b == NULL ) return 0;
 621
 622         b->ptr = NULL;          /* sb_tls_remove() will free it */
 623         b->init = 0;
 624         b->flags = 0;
 625         return 1;
 626 }
 627
 628 static int
 629 sb_tls_bio_read( BIO *b, char *buf, int len )
 630 {
 631         struct tls_data         *p;
 632         int                     ret;
 633
 634         if ( buf == NULL || len <= 0 ) return 0;
 635
 636         p = (struct tls_data *)b->ptr;
 637
 638         if ( p == NULL || p->sbiod == NULL ) {
 639                 return 0;
 640         }
 641
 642         ret = LBER_SBIOD_READ_NEXT( p->sbiod, buf, len );
 643
 644         BIO_clear_retry_flags( b );
 645         if ( ret < 0 && errno == EWOULDBLOCK ) {
 646                 BIO_set_retry_read( b );
 647         }
 648
 649         return ret;
 650 }
 651
 652 static int
 653 sb_tls_bio_write( BIO *b, const char *buf, int len )
 654 {
 655         struct tls_data         *p;
 656         int                     ret;
 657
 658         if ( buf == NULL || len <= 0 ) return 0;
 659
 660         p = (struct tls_data *)b->ptr;
 661
 662         if ( p == NULL || p->sbiod == NULL ) {
 663                 return 0;
 664         }
 665
 666         ret = LBER_SBIOD_WRITE_NEXT( p->sbiod, (char *)buf, len );
 667
 668         BIO_clear_retry_flags( b );
 669         if ( ret < 0 && errno == EWOULDBLOCK ) {
 670                 BIO_set_retry_write( b );
 671         }
 672
 673         return ret;
 674 }
 675
 676 static long
 677 sb_tls_bio_ctrl( BIO *b, int cmd, long num, void *ptr )
 678 {
 679         if ( cmd == BIO_CTRL_FLUSH ) {
 680                 /* The OpenSSL library needs this */
 681                 return 1;
 682         }
 683         return 0;
 684 }
 685
 686 static int
 687 sb_tls_bio_gets( BIO *b, char *buf, int len )
 688 {
 689         return -1;
 690 }
 691
 692 static int
 693 sb_tls_bio_puts( BIO *b, const char *str )
 694 {
 695         return sb_tls_bio_write( b, str, strlen( str ) );
 696 }
 697
 698 static BIO_METHOD sb_tls_bio_method =
 699 {
 700         ( 100 | 0x400 ),                /* it's a source/sink BIO */
 701         "sockbuf glue",
 702         sb_tls_bio_write,
 703         sb_tls_bio_read,
 704         sb_tls_bio_puts,
 705         sb_tls_bio_gets,
 706         sb_tls_bio_ctrl,
 707         sb_tls_bio_create,
 708         sb_tls_bio_destroy
 709 };
 710
 711 /*
 712  * Call this to do a TLS connect on a sockbuf. ctx_arg can be
 713  * a SSL_CTX * or NULL, in which case the default ctx is used.
 714  *
 715  * Return value:
 716  *
 717  *  0 - Success. Connection is ready for communication.
 718  * <0 - Error. Can't create a TLS stream.
 719  * >0 - Partial success.
 720  *        Do a select (using information from lber_pvt_sb_needs_{read,write}
 721  *              and call again.
 722  */
 723
 724 static int
 725 ldap_int_tls_connect( LDAP *ld, LDAPConn *conn )
 726 {
 727         Sockbuf *sb = conn->lconn_sb;
 728         int     err;
 729         SSL     *ssl;
 730
 731         if ( HAS_TLS( sb ) ) {
 732                 ber_sockbuf_ctrl( sb, LBER_SB_OPT_GET_SSL, (void *)&ssl );
 733
 734         } else {
 735                 void *ctx = ld->ld_defconn
 736                         ? ld->ld_defconn->lconn_tls_ctx : NULL;
 737
 738                 ssl = alloc_handle( ctx );
 739
 740                 if ( ssl == NULL ) return -1;
 741
 742 #ifdef LDAP_DEBUG
 743                 ber_sockbuf_add_io( sb, &ber_sockbuf_io_debug,
 744                         LBER_SBIOD_LEVEL_TRANSPORT, (void *)"tls_" );
 745 #endif
 746                 ber_sockbuf_add_io( sb, &sb_tls_sbio,
 747                         LBER_SBIOD_LEVEL_TRANSPORT, (void *)ssl );
 748
 749                 if( ctx == NULL ) {
 750                         conn->lconn_tls_ctx = tls_def_ctx;
 751                 }
 752         }
 753
 754         err = SSL_connect( ssl );
 755
 756 #ifdef HAVE_WINSOCK
 757         errno = WSAGetLastError();
 758 #endif
 759
 760         if ( err <= 0 ) {
 761                 if ( update_flags( sb, ssl, err )) {
 762                         return 1;
 763                 }
 764
 765                 if ((err = ERR_peek_error())) {
 766                         char buf[256];
 767                         ld->ld_error = LDAP_STRDUP(ERR_error_string(err, buf));
 768 #ifdef HAVE_EBCDIC
 769                         if ( ld->ld_error ) __etoa(ld->ld_error);
 770 #endif
 771                 }
 772
 773 #ifdef NEW_LOGGING
 774                 LDAP_LOG ( TRANSPORT, ERR,
 775                         "ldap_int_tls_connect: TLS can't connect.\n", 0, 0, 0 );
 776 #else
 777                 Debug( LDAP_DEBUG_ANY,"TLS: can't connect.\n",0,0,0);
 778 #endif
 779
 780                 ber_sockbuf_remove_io( sb, &sb_tls_sbio,
 781                         LBER_SBIOD_LEVEL_TRANSPORT );
 782 #ifdef LDAP_DEBUG
 783                 ber_sockbuf_remove_io( sb, &ber_sockbuf_io_debug,
 784                         LBER_SBIOD_LEVEL_TRANSPORT );
 785 #endif
 786                 return -1;
 787         }
 788
 789         return 0;
 790 }
 791
 792 /*
 793  * Call this to do a TLS accept on a sockbuf.
 794  * Everything else is the same as with tls_connect.
 795  */
 796 int
 797 ldap_pvt_tls_accept( Sockbuf *sb, void *ctx_arg )
 798 {
 799         int     err;
 800         SSL     *ssl;
 801
 802         if ( HAS_TLS( sb ) ) {
 803                 ber_sockbuf_ctrl( sb, LBER_SB_OPT_GET_SSL, (void *)&ssl );
 804
 805         } else {
 806                 ssl = alloc_handle( ctx_arg );
 807                 if ( ssl == NULL ) return -1;
 808
 809 #ifdef LDAP_DEBUG
 810                 ber_sockbuf_add_io( sb, &ber_sockbuf_io_debug,
 811                         LBER_SBIOD_LEVEL_TRANSPORT, (void *)"tls_" );
 812 #endif
 813                 ber_sockbuf_add_io( sb, &sb_tls_sbio,
 814                         LBER_SBIOD_LEVEL_TRANSPORT, (void *)ssl );
 815         }
 816
 817         err = SSL_accept( ssl );
 818
 819 #ifdef HAVE_WINSOCK
 820         errno = WSAGetLastError();
 821 #endif
 822         if ( err <= 0 ) {
 823                 if ( update_flags( sb, ssl, err )) return 1;
 824
 825 #ifdef NEW_LOGGING
 826                 LDAP_LOG ( TRANSPORT, ERR,
 827                         "ldap_pvt_tls_accept: TLS can't accept.\n", 0, 0, 0 );
 828 #else
 829                 Debug( LDAP_DEBUG_ANY,"TLS: can't accept.\n",0,0,0 );
 830 #endif
 831
 832                 tls_report_error();
 833                 ber_sockbuf_remove_io( sb, &sb_tls_sbio,
 834                         LBER_SBIOD_LEVEL_TRANSPORT );
 835 #ifdef LDAP_DEBUG
 836                 ber_sockbuf_remove_io( sb, &ber_sockbuf_io_debug,
 837                         LBER_SBIOD_LEVEL_TRANSPORT );
 838 #endif
 839                 return -1;
 840         }
 841
 842         return 0;
 843 }
 844
 845 int
 846 ldap_pvt_tls_inplace ( Sockbuf *sb )
 847 {
 848         return HAS_TLS( sb ) ? 1 : 0;
 849 }
 850
 851 void *
 852 ldap_pvt_tls_sb_ctx( Sockbuf *sb )
 853 {
 854         void                    *p;
 855
 856         if (HAS_TLS( sb )) {
 857                 ber_sockbuf_ctrl( sb, LBER_SB_OPT_GET_SSL, (void *)&p );
 858                 return p;
 859         }
 860
 861         return NULL;
 862 }
 863
 864 int
 865 ldap_pvt_tls_get_strength( void *s )
 866 {
 867         SSL_CIPHER *c;
 868
 869         c = SSL_get_current_cipher((SSL *)s);
 870         return SSL_CIPHER_get_bits(c, NULL);
 871 }
 872
 873
 874 int
 875 ldap_pvt_tls_get_my_dn( void *s, struct berval *dn, LDAPDN_rewrite_dummy *func, unsigned flags )
 876 {
 877         X509 *x;
 878         X509_NAME *xn;
 879         int rc;
 880
 881         x = SSL_get_certificate((SSL *)s);
 882
 883         if (!x) return LDAP_INVALID_CREDENTIALS;
 884
 885         xn = X509_get_subject_name(x);
 886         rc = ldap_X509dn2bv(xn, dn, (LDAPDN_rewrite_func *)func, flags );
 887         X509_free(x);
 888         return rc;
 889 }
 890
 891 static X509 *
 892 tls_get_cert( SSL *s )
 893 {
 894         /* If peer cert was bad, treat as if no cert was given */
 895         if (SSL_get_verify_result(s)) {
 896                 /* If we can send an alert, do so */
 897                 if (SSL_version(s) != SSL2_VERSION) {
 898                         ssl3_send_alert(s,SSL3_AL_WARNING,SSL3_AD_BAD_CERTIFICATE);
 899                 }
 900                 return NULL;
 901         }
 902         return SSL_get_peer_certificate(s);
 903 }
 904
 905 int
 906 ldap_pvt_tls_get_peer_dn( void *s, struct berval *dn, LDAPDN_rewrite_dummy *func, unsigned flags )
 907 {
 908         X509 *x;
 909         X509_NAME *xn;
 910         int rc;
 911
 912         x = tls_get_cert((SSL *)s);
 913
 914         if (!x) return LDAP_INVALID_CREDENTIALS;
 915
 916         xn = X509_get_subject_name(x);
 917         rc = ldap_X509dn2bv(xn, dn, (LDAPDN_rewrite_func *)func, flags);
 918         X509_free(x);
 919         return rc;
 920 }
 921
 922 char *
 923 ldap_pvt_tls_get_peer_hostname( void *s )
 924 {
 925         X509 *x;
 926         X509_NAME *xn;
 927         char buf[2048], *p;
 928         int ret;
 929
 930         x = tls_get_cert((SSL *)s);
 931         if (!x) return NULL;
 932
 933         xn = X509_get_subject_name(x);
 934
 935         ret = X509_NAME_get_text_by_NID(xn, NID_commonName, buf, sizeof(buf));
 936         if( ret == -1 ) {
 937                 X509_free(x);
 938                 return NULL;
 939         }
 940
 941         p = LDAP_STRDUP(buf);
 942         X509_free(x);
 943         return p;
 944 }
 945
 946 int
 947 ldap_pvt_tls_check_hostname( LDAP *ld, void *s, const char *name_in )
 948 {
 949         int i, ret = LDAP_LOCAL_ERROR;
 950         X509 *x;
 951         const char *name;
 952
 953         if( ldap_int_hostname &&
 954                 ( !name_in || !strcasecmp( name_in, "localhost" ) ) )
 955         {
 956                 name = ldap_int_hostname;
 957         } else {
 958                 name = name_in;
 959         }
 960
 961         x = tls_get_cert((SSL *)s);
 962         if (!x) {
 963 #ifdef NEW_LOGGING
 964                 LDAP_LOG ( TRANSPORT, ERR,
 965                         "ldap_pvt_tls_check_hostname: "
 966                         "TLS unable to get peer certificate.\n" , 0, 0, 0 );
 967 #else
 968                 Debug( LDAP_DEBUG_ANY,
 969                         "TLS: unable to get peer certificate.\n",
 970                         0, 0, 0 );
 971 #endif
 972                 /* If this was a fatal condition, things would have
 973                  * aborted long before now.
 974                  */
 975                 return LDAP_SUCCESS;
 976         }
 977
 978         i = X509_get_ext_by_NID(x, NID_subject_alt_name, -1);
 979         if (i >= 0) {
 980                 X509_EXTENSION *ex;
 981                 STACK_OF(GENERAL_NAME) *alt;
 982
 983                 ex = X509_get_ext(x, i);
 984                 alt = X509V3_EXT_d2i(ex);
 985                 if (alt) {
 986                         int n, len1, len2 = 0;
 987                         char *domain;
 988                         GENERAL_NAME *gn;
 989
 990                         len1 = strlen(name);
 991                         n = sk_GENERAL_NAME_num(alt);
 992                         domain = strchr(name, '.');
 993                         if (domain) {
 994                                 len2 = len1 - (domain-name);
 995                         }
 996                         for (i=0; i<n; i++) {
 997                                 gn = sk_GENERAL_NAME_value(alt, i);
 998                                 if (gn->type == GEN_DNS) {
 999                                         char *sn = ASN1_STRING_data(gn->d.ia5);
1000                                         int sl = ASN1_STRING_length(gn->d.ia5);
1001
1002                                         /* Is this an exact match? */
1003                                         if ((len1 == sl) && !strncasecmp(name, sn, len1)) {
1004                                                 break;
1005                                         }
1006
1007                                         /* Is this a wildcard match? */
1008                                         if ((*sn == '*') && domain && (len2 == sl-1) &&
1009                                                 !strncasecmp(domain, sn+1, len2))
1010                                         {
1011                                                 break;
1012                                         }
1013
1014 #if 0
1015                                         /* Is this a RFC 2549 style wildcard match? */
1016                                         if ((*sn == '.') && domain && (len2 == sl) &&
1017                                                 !strncasecmp(domain, sn, len2))
1018                                         {
1019                                                 break;
1020                                         }
1021 #endif
1022                                 }
1023                         }
1024
1025                         GENERAL_NAMES_free(alt);
1026                         if (i < n) {    /* Found a match */
1027                                 ret = LDAP_SUCCESS;
1028                         }
1029                 }
1030         }
1031
1032         if (ret != LDAP_SUCCESS) {
1033                 X509_NAME *xn;
1034                 char buf[2048];
1035
1036                 xn = X509_get_subject_name(x);
1037
1038                 if( X509_NAME_get_text_by_NID( xn, NID_commonName,
1039                         buf, sizeof(buf)) == -1)
1040                 {
1041 #ifdef NEW_LOGGING
1042                         LDAP_LOG ( TRANSPORT, ERR, "ldap_pvt_tls_check_hostname: "
1043                                 "TLS unable to get common name from peer certificate.\n",
1044                                 0, 0, 0 );
1045 #else
1046                         Debug( LDAP_DEBUG_ANY,
1047                                 "TLS: unable to get common name from peer certificate.\n",
1048                                 0, 0, 0 );
1049 #endif
1050                         ld->ld_error = LDAP_STRDUP("TLS: unable to get CN from peer certificate");
1051
1052                 } else if (strcasecmp(name, buf)) {
1053 #ifdef NEW_LOGGING
1054                         LDAP_LOG ( TRANSPORT, ERR, "ldap_pvt_tls_check_hostname: "
1055                                 "TLS hostname (%s) does not match "
1056                                 "common name in certificate (%s).\n", name, buf, 0 );
1057 #else
1058                         Debug( LDAP_DEBUG_ANY, "TLS: hostname (%s) does not match "
1059                                 "common name in certificate (%s).\n",
1060                                 name, buf, 0 );
1061 #endif
1062                         ret = LDAP_CONNECT_ERROR;
1063                         ld->ld_error = LDAP_STRDUP("TLS: hostname does not match CN in peer certificate");
1064
1065                 } else {
1066                         ret = LDAP_SUCCESS;
1067                 }
1068         }
1069         X509_free(x);
1070         return ret;
1071 }
1072
1073 const char *
1074 ldap_pvt_tls_get_peer_issuer( void *s )
1075 {
1076 #if 0   /* currently unused; see ldap_pvt_tls_get_peer_dn() if needed */
1077         X509 *x;
1078         X509_NAME *xn;
1079         char buf[2048], *p;
1080
1081         x = SSL_get_peer_certificate((SSL *)s);
1082
1083         if (!x) return NULL;
1084
1085         xn = X509_get_issuer_name(x);
1086         p = LDAP_STRDUP(X509_NAME_oneline(xn, buf, sizeof(buf)));
1087         X509_free(x);
1088         return p;
1089 #else
1090         return NULL;
1091 #endif
1092 }
1093
1094 int
1095 ldap_int_tls_config( LDAP *ld, int option, const char *arg )
1096 {
1097         int i;
1098
1099         switch( option ) {
1100         case LDAP_OPT_X_TLS_CACERTFILE:
1101         case LDAP_OPT_X_TLS_CACERTDIR:
1102         case LDAP_OPT_X_TLS_CERTFILE:
1103         case LDAP_OPT_X_TLS_KEYFILE:
1104         case LDAP_OPT_X_TLS_RANDOM_FILE:
1105                 return ldap_pvt_tls_set_option( ld, option, (void *) arg );
1106
1107         case LDAP_OPT_X_TLS_REQUIRE_CERT:
1108         case LDAP_OPT_X_TLS:
1109                 i = -1;
1110                 if ( strcasecmp( arg, "never" ) == 0 ) {
1111                         i = LDAP_OPT_X_TLS_NEVER ;
1112
1113                 } else if ( strcasecmp( arg, "demand" ) == 0 ) {
1114                         i = LDAP_OPT_X_TLS_DEMAND ;
1115
1116                 } else if ( strcasecmp( arg, "allow" ) == 0 ) {
1117                         i = LDAP_OPT_X_TLS_ALLOW ;
1118
1119                 } else if ( strcasecmp( arg, "try" ) == 0 ) {
1120                         i = LDAP_OPT_X_TLS_TRY ;
1121
1122                 } else if ( ( strcasecmp( arg, "hard" ) == 0 ) ||
1123                         ( strcasecmp( arg, "on" ) == 0 ) ||
1124                         ( strcasecmp( arg, "yes" ) == 0) ||
1125                         ( strcasecmp( arg, "true" ) == 0 ) )
1126                 {
1127                         i = LDAP_OPT_X_TLS_HARD ;
1128                 }
1129
1130                 if (i >= 0) {
1131                         return ldap_pvt_tls_set_option( ld, option, &i );
1132                 }
1133                 return -1;
1134         }
1135
1136         return -1;
1137 }
1138
1139 int
1140 ldap_pvt_tls_get_option( LDAP *ld, int option, void *arg )
1141 {
1142         struct ldapoptions *lo;
1143
1144         if( ld != NULL ) {
1145                 assert( LDAP_VALID( ld ) );
1146
1147                 if( !LDAP_VALID( ld ) ) {
1148                         return LDAP_OPT_ERROR;
1149                 }
1150
1151                 lo = &ld->ld_options;
1152
1153         } else {
1154                 /* Get pointer to global option structure */
1155                 lo = LDAP_INT_GLOBAL_OPT();
1156                 if ( lo == NULL ) {
1157                         return LDAP_NO_MEMORY;
1158                 }
1159         }
1160
1161         switch( option ) {
1162         case LDAP_OPT_X_TLS:
1163                 *(int *)arg = lo->ldo_tls_mode;
1164                 break;
1165         case LDAP_OPT_X_TLS_CTX:
1166                 if ( ld == NULL ) {
1167                         *(void **)arg = (void *) tls_def_ctx;
1168                 } else {
1169                         *(void **)arg = ld->ld_defconn->lconn_tls_ctx;
1170                 }
1171                 break;
1172         case LDAP_OPT_X_TLS_CACERTFILE:
1173                 *(char **)arg = tls_opt_cacertfile ?
1174                         LDAP_STRDUP( tls_opt_cacertfile ) : NULL;
1175                 break;
1176         case LDAP_OPT_X_TLS_CACERTDIR:
1177                 *(char **)arg = tls_opt_cacertdir ?
1178                         LDAP_STRDUP( tls_opt_cacertdir ) : NULL;
1179                 break;
1180         case LDAP_OPT_X_TLS_CERTFILE:
1181                 *(char **)arg = tls_opt_certfile ?
1182                         LDAP_STRDUP( tls_opt_certfile ) : NULL;
1183                 break;
1184         case LDAP_OPT_X_TLS_KEYFILE:
1185                 *(char **)arg = tls_opt_keyfile ?
1186                         LDAP_STRDUP( tls_opt_keyfile ) : NULL;
1187                 break;
1188         case LDAP_OPT_X_TLS_REQUIRE_CERT:
1189                 *(int *)arg = tls_opt_require_cert;
1190                 break;
1191         case LDAP_OPT_X_TLS_RANDOM_FILE:
1192                 *(char **)arg = tls_opt_randfile ?
1193                         LDAP_STRDUP( tls_opt_randfile ) : NULL;
1194                 break;
1195         case LDAP_OPT_X_TLS_SSL_CTX: {
1196                 void *retval = 0;
1197                 if ( ld != NULL ) {
1198                         LDAPConn *conn = ld->ld_defconn;
1199                         if ( conn != NULL ) {
1200                                 Sockbuf *sb = conn->lconn_sb;
1201                                 retval = ldap_pvt_tls_sb_ctx( sb );
1202                         }
1203                 }
1204                 *(void **)arg = retval;
1205                 break;
1206         }
1207         default:
1208                 return -1;
1209         }
1210         return 0;
1211 }
1212
1213 int
1214 ldap_pvt_tls_set_option( LDAP *ld, int option, void *arg )
1215 {
1216         struct ldapoptions *lo;
1217
1218         if( ld != NULL ) {
1219                 assert( LDAP_VALID( ld ) );
1220
1221                 if( !LDAP_VALID( ld ) ) {
1222                         return LDAP_OPT_ERROR;
1223                 }
1224
1225                 lo = &ld->ld_options;
1226
1227         } else {
1228                 /* Get pointer to global option structure */
1229                 lo = LDAP_INT_GLOBAL_OPT();
1230                 if ( lo == NULL ) {
1231                         return LDAP_NO_MEMORY;
1232                 }
1233         }
1234
1235         switch( option ) {
1236         case LDAP_OPT_X_TLS:
1237                 switch( *(int *) arg ) {
1238                 case LDAP_OPT_X_TLS_NEVER:
1239                 case LDAP_OPT_X_TLS_DEMAND:
1240                 case LDAP_OPT_X_TLS_ALLOW:
1241                 case LDAP_OPT_X_TLS_TRY:
1242                 case LDAP_OPT_X_TLS_HARD:
1243                         if (lo != NULL) {
1244                                 lo->ldo_tls_mode = *(int *)arg;
1245                         }
1246
1247                         return 0;
1248                 }
1249                 return -1;
1250
1251         case LDAP_OPT_X_TLS_CTX:
1252                 if ( ld == NULL ) {
1253                         tls_def_ctx = (SSL_CTX *) arg;
1254
1255                 } else {
1256                         ld->ld_defconn->lconn_tls_ctx = arg;
1257                 }
1258                 return 0;
1259         }
1260
1261         if ( ld != NULL ) {
1262                 return -1;
1263         }
1264
1265         switch( option ) {
1266         case LDAP_OPT_X_TLS_CACERTFILE:
1267                 if ( tls_opt_cacertfile ) LDAP_FREE( tls_opt_cacertfile );
1268                 tls_opt_cacertfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
1269                 break;
1270         case LDAP_OPT_X_TLS_CACERTDIR:
1271                 if ( tls_opt_cacertdir ) LDAP_FREE( tls_opt_cacertdir );
1272                 tls_opt_cacertdir = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
1273                 break;
1274         case LDAP_OPT_X_TLS_CERTFILE:
1275                 if ( tls_opt_certfile ) LDAP_FREE( tls_opt_certfile );
1276                 tls_opt_certfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
1277                 break;
1278         case LDAP_OPT_X_TLS_KEYFILE:
1279                 if ( tls_opt_keyfile ) LDAP_FREE( tls_opt_keyfile );
1280                 tls_opt_keyfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
1281                 break;
1282         case LDAP_OPT_X_TLS_REQUIRE_CERT:
1283                 switch( *(int *) arg ) {
1284                 case LDAP_OPT_X_TLS_NEVER:
1285                 case LDAP_OPT_X_TLS_DEMAND:
1286                 case LDAP_OPT_X_TLS_ALLOW:
1287                 case LDAP_OPT_X_TLS_TRY:
1288                 case LDAP_OPT_X_TLS_HARD:
1289                         tls_opt_require_cert = * (int *) arg;
1290                         return 0;
1291                 }
1292                 return -1;
1293         case LDAP_OPT_X_TLS_CIPHER_SUITE:
1294                 if ( tls_opt_ciphersuite ) LDAP_FREE( tls_opt_ciphersuite );
1295                 tls_opt_ciphersuite = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
1296                 break;
1297         case LDAP_OPT_X_TLS_RANDOM_FILE:
1298                 if (tls_opt_randfile ) LDAP_FREE (tls_opt_randfile );
1299                 tls_opt_randfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
1300                 break;
1301         default:
1302                 return -1;
1303         }
1304         return 0;
1305 }
1306
1307 int
1308 ldap_int_tls_start ( LDAP *ld, LDAPConn *conn, LDAPURLDesc *srv )
1309 {
1310         Sockbuf *sb = conn->lconn_sb;
1311         char *host;
1312         void *ssl;
1313
1314         if( srv ) {
1315                 host = srv->lud_host;
1316         } else {
1317                 host = conn->lconn_server->lud_host;
1318         }
1319
1320         /* avoid NULL host */
1321         if( host == NULL ) {
1322                 host = "localhost";
1323         }
1324
1325         (void) ldap_pvt_tls_init();
1326
1327         /*
1328          * Fortunately, the lib uses blocking io...
1329          */
1330         if ( ldap_int_tls_connect( ld, conn ) < 0 ) {
1331                 ld->ld_errno = LDAP_CONNECT_ERROR;
1332                 return (ld->ld_errno);
1333         }
1334
1335         ssl = ldap_pvt_tls_sb_ctx( sb );
1336         assert( ssl != NULL );
1337
1338         /*
1339          * compare host with name(s) in certificate
1340          */
1341         ld->ld_errno = ldap_pvt_tls_check_hostname( ld, ssl, host );
1342         if (ld->ld_errno != LDAP_SUCCESS) {
1343                 return ld->ld_errno;
1344         }
1345
1346         /*
1347          * set SASL properties to TLS ssf and authid
1348          */
1349         {
1350                 struct berval authid = { 0, NULL };
1351                 ber_len_t ssf;
1352
1353                 /* we need to let SASL know */
1354                 ssf = ldap_pvt_tls_get_strength( ssl );
1355                 /* failure is OK, we just can't use SASL EXTERNAL */
1356                 (void) ldap_pvt_tls_get_my_dn( ssl, &authid, NULL, 0 );
1357
1358                 (void) ldap_int_sasl_external( ld, conn, authid.bv_val, ssf );
1359                 LDAP_FREE( authid.bv_val );
1360         }
1361
1362         return LDAP_SUCCESS;
1363 }
1364
1365 /* Derived from openssl/apps/s_cb.c */
1366 static void
1367 tls_info_cb( SSL *ssl, int where, int ret )
1368 {
1369         int w;
1370         char *op;
1371         char *state = SSL_state_string_long( ssl );
1372
1373         w = where & ~SSL_ST_MASK;
1374         if ( w & SSL_ST_CONNECT ) {
1375                 op = "SSL_connect";
1376         } else if ( w & SSL_ST_ACCEPT ) {
1377                 op = "SSL_accept";
1378         } else {
1379                 op = "undefined";
1380         }
1381
1382 #ifdef HAVE_EBCDIC
1383         if ( state ) {
1384                 state = LDAP_STRDUP( state );
1385                 __etoa( state );
1386         }
1387 #endif
1388         if ( where & SSL_CB_LOOP ) {
1389 #ifdef NEW_LOGGING
1390                 LDAP_LOG ( TRANSPORT, DETAIL1, "tls_info_cb: "
1391                         "TLS trace: %s:%s\n", op, state, 0 );
1392 #else
1393                 Debug( LDAP_DEBUG_TRACE,
1394                            "TLS trace: %s:%s\n",
1395                            op, state, 0 );
1396 #endif
1397
1398         } else if ( where & SSL_CB_ALERT ) {
1399                 char *atype = SSL_alert_type_string_long( ret );
1400                 char *adesc = SSL_alert_desc_string_long( ret );
1401                 op = ( where & SSL_CB_READ ) ? "read" : "write";
1402 #ifdef HAVE_EBCDIC
1403                 if ( atype ) {
1404                         atype = LDAP_STRDUP( atype );
1405                         __etoa( atype );
1406                 }
1407                 if ( adesc ) {
1408                         adesc = LDAP_STRDUP( adesc );
1409                         __etoa( adesc );
1410                 }
1411 #endif
1412 #ifdef NEW_LOGGING
1413                 LDAP_LOG ( TRANSPORT, DETAIL1,
1414                         "tls_info_cb: TLS trace: SSL3 alert %s:%s:%s\n",
1415                         op, atype, adesc );
1416 #else
1417                 Debug( LDAP_DEBUG_TRACE,
1418                            "TLS trace: SSL3 alert %s:%s:%s\n",
1419                            op, atype, adesc );
1420 #endif
1421 #ifdef HAVE_EBCDIC
1422                 if ( atype ) LDAP_FREE( atype );
1423                 if ( adesc ) LDAP_FREE( adesc );
1424 #endif
1425         } else if ( where & SSL_CB_EXIT ) {
1426                 if ( ret == 0 ) {
1427 #ifdef NEW_LOGGING
1428                         LDAP_LOG ( TRANSPORT, ERR,
1429                                 "tls_info_cb: TLS trace: %s:failed in %s\n",
1430                                 op, state, 0 );
1431 #else
1432                         Debug( LDAP_DEBUG_TRACE,
1433                                    "TLS trace: %s:failed in %s\n",
1434                                    op, state, 0 );
1435 #endif
1436                 } else if ( ret < 0 ) {
1437 #ifdef NEW_LOGGING
1438                         LDAP_LOG ( TRANSPORT, ERR,
1439                                 "tls_info_cb: TLS trace: %s:error in %s\n",
1440                                 op, state, 0 );
1441 #else
1442                         Debug( LDAP_DEBUG_TRACE,
1443                                    "TLS trace: %s:error in %s\n",
1444                                    op, state, 0 );
1445 #endif
1446                 }
1447         }
1448 #ifdef HAVE_EBCDIC
1449         if ( state ) LDAP_FREE( state );
1450 #endif
1451 }
1452
1453 static int
1454 tls_verify_cb( int ok, X509_STORE_CTX *ctx )
1455 {
1456         X509 *cert;
1457         int errnum;
1458         int errdepth;
1459         X509_NAME *subject;
1460         X509_NAME *issuer;
1461         char *sname;
1462         char *iname;
1463         char *certerr = NULL;
1464
1465         cert = X509_STORE_CTX_get_current_cert( ctx );
1466         errnum = X509_STORE_CTX_get_error( ctx );
1467         errdepth = X509_STORE_CTX_get_error_depth( ctx );
1468
1469         /*
1470          * X509_get_*_name return pointers to the internal copies of
1471          * those things requested.  So do not free them.
1472          */
1473         subject = X509_get_subject_name( cert );
1474         issuer = X509_get_issuer_name( cert );
1475         /* X509_NAME_oneline, if passed a NULL buf, allocate memomry */
1476         sname = X509_NAME_oneline( subject, NULL, 0 );
1477         iname = X509_NAME_oneline( issuer, NULL, 0 );
1478         if ( !ok ) certerr = (char *)X509_verify_cert_error_string( errnum );
1479 #ifdef HAVE_EBCDIC
1480         if ( sname ) __etoa( sname );
1481         if ( iname ) __etoa( iname );
1482         if ( certerr ) {
1483                 certerr = LDAP_STRDUP( certerr );
1484                 __etoa( certerr );
1485         }
1486 #endif
1487 #ifdef NEW_LOGGING
1488         LDAP_LOG( TRANSPORT, ERR,
1489                    "TLS certificate verification: depth: %d, err: %d, subject: %s,",
1490                    errdepth, errnum,
1491                    sname ? sname : "-unknown-" );
1492         LDAP_LOG( TRANSPORT, ERR, " issuer: %s\n", iname ? iname : "-unknown-", 0, 0 );
1493         if ( !ok ) {
1494                 LDAP_LOG ( TRANSPORT, ERR,
1495                         "TLS certificate verification: Error, %s\n",
1496                         certerr, 0, 0 );
1497         }
1498 #else
1499         Debug( LDAP_DEBUG_TRACE,
1500                    "TLS certificate verification: depth: %d, err: %d, subject: %s,",
1501                    errdepth, errnum,
1502                    sname ? sname : "-unknown-" );
1503         Debug( LDAP_DEBUG_TRACE, " issuer: %s\n", iname ? iname : "-unknown-", 0, 0 );
1504         if ( !ok ) {
1505                 Debug( LDAP_DEBUG_ANY,
1506                         "TLS certificate verification: Error, %s\n",
1507                         certerr, 0, 0 );
1508         }
1509 #endif
1510         if ( sname )
1511                 CRYPTO_free ( sname );
1512         if ( iname )
1513                 CRYPTO_free ( iname );
1514 #ifdef HAVE_EBCDIC
1515         if ( certerr ) LDAP_FREE( certerr );
1516 #endif
1517         return ok;
1518 }
1519
1520 static int
1521 tls_verify_ok( int ok, X509_STORE_CTX *ctx )
1522 {
1523         (void) tls_verify_cb( ok, ctx );
1524         return 1;
1525 }
1526
1527 /* Inspired by ERR_print_errors in OpenSSL */
1528 static void
1529 tls_report_error( void )
1530 {
1531         unsigned long l;
1532         char buf[200];
1533         const char *file;
1534         int line;
1535
1536         while ( ( l = ERR_get_error_line( &file, &line ) ) != 0 ) {
1537                 ERR_error_string_n( l, buf, sizeof( buf ) );
1538 #ifdef HAVE_EBCDIC
1539                 if ( file ) {
1540                         file = LDAP_STRDUP( file );
1541                         __etoa( (char *)file );
1542                 }
1543                 __etoa( buf );
1544 #endif
1545 #ifdef NEW_LOGGING
1546                 LDAP_LOG ( TRANSPORT, ERR,
1547                         "tls_report_error: TLS %s %s:%d\n",
1548                         buf, file, line );
1549 #else
1550                 Debug( LDAP_DEBUG_ANY, "TLS: %s %s:%d\n",
1551                         buf, file, line );
1552 #endif
1553 #ifdef HAVE_EBCDIC
1554                 if ( file ) LDAP_FREE( (void *)file );
1555 #endif
1556         }
1557 }
1558
1559 static RSA *
1560 tls_tmp_rsa_cb( SSL *ssl, int is_export, int key_length )
1561 {
1562         RSA *tmp_rsa;
1563
1564         /* FIXME:  Pregenerate the key on startup */
1565         /* FIXME:  Who frees the key? */
1566         tmp_rsa = RSA_generate_key( key_length, RSA_F4, NULL, NULL );
1567
1568         if ( !tmp_rsa ) {
1569 #ifdef NEW_LOGGING
1570                 LDAP_LOG ( TRANSPORT, ERR,
1571                         "tls_tmp_rsa_cb: TLS Failed to generate temporary %d-bit %s "
1572                         "RSA key\n", key_length, is_export ? "export" : "domestic", 0 );
1573 #else
1574                 Debug( LDAP_DEBUG_ANY,
1575                         "TLS: Failed to generate temporary %d-bit %s RSA key\n",
1576                         key_length, is_export ? "export" : "domestic", 0 );
1577 #endif
1578                 return NULL;
1579         }
1580         return tmp_rsa;
1581 }
1582
1583 static int
1584 tls_seed_PRNG( const char *randfile )
1585 {
1586 #ifndef URANDOM_DEVICE
1587         /* no /dev/urandom (or equiv) */
1588         long total=0;
1589         char buffer[MAXPATHLEN];
1590
1591         if (randfile == NULL) {
1592                 /* The seed file is $RANDFILE if defined, otherwise $HOME/.rnd.
1593                  * If $HOME is not set or buffer too small to hold the pathname,
1594                  * an error occurs.     - From RAND_file_name() man page.
1595                  * The fact is that when $HOME is NULL, .rnd is used.
1596                  */
1597                 randfile = RAND_file_name( buffer, sizeof( buffer ) );
1598
1599         } else if (RAND_egd(randfile) > 0) {
1600                 /* EGD socket */
1601                 return 0;
1602         }
1603
1604         if (randfile == NULL) {
1605 #ifdef NEW_LOGGING
1606                 LDAP_LOG ( TRANSPORT, DETAIL1,
1607                         "tls_seed_PRNG: TLS Use configuration file or "
1608                         "$RANDFILE to define seed PRNG\n", 0, 0, 0 );
1609 #else
1610                 Debug( LDAP_DEBUG_ANY,
1611                         "TLS: Use configuration file or $RANDFILE to define seed PRNG\n",
1612                         0, 0, 0);
1613 #endif
1614                 return -1;
1615         }
1616
1617         total = RAND_load_file(randfile, -1);
1618
1619         if (RAND_status() == 0) {
1620 #ifdef NEW_LOGGING
1621                 LDAP_LOG ( TRANSPORT, DETAIL1,
1622                         "tls_seed_PRNG: TLS PRNG not been seeded with enough data\n",
1623                         0, 0, 0 );
1624 #else
1625                 Debug( LDAP_DEBUG_ANY,
1626                         "TLS: PRNG not been seeded with enough data\n",
1627                         0, 0, 0);
1628 #endif
1629                 return -1;
1630         }
1631
1632         /* assume if there was enough bits to seed that it's okay
1633          * to write derived bits to the file
1634          */
1635         RAND_write_file(randfile);
1636
1637 #endif
1638
1639         return 0;
1640 }
1641
1642 #if 0
1643 static DH *
1644 tls_tmp_dh_cb( SSL *ssl, int is_export, int key_length )
1645 {
1646         return NULL;
1647 }
1648 #endif
1649 #endif
1650
1651 int
1652 ldap_start_tls_s ( LDAP *ld,
1653         LDAPControl **serverctrls,
1654         LDAPControl **clientctrls )
1655 {
1656         int rc;
1657
1658 #ifdef HAVE_TLS
1659         char *rspoid = NULL;
1660         struct berval *rspdata = NULL;
1661
1662         /* XXYYZ: this initiates operation only on default connection! */
1663
1664         if ( ld->ld_sb != NULL && ldap_pvt_tls_inplace( ld->ld_sb ) != 0 ) {
1665                 return LDAP_LOCAL_ERROR;
1666         }
1667
1668         rc = ldap_extended_operation_s( ld, LDAP_EXOP_START_TLS,
1669                 NULL, serverctrls, clientctrls, &rspoid, &rspdata );
1670         if ( rc != LDAP_SUCCESS ) {
1671                 return rc;
1672         }
1673
1674         if ( rspoid != NULL ) {
1675                 LDAP_FREE(rspoid);
1676         }
1677
1678         if ( rspdata != NULL ) {
1679                 ber_bvfree( rspdata );
1680         }
1681
1682         rc = ldap_int_tls_start( ld, ld->ld_defconn, NULL );
1683 #else
1684         rc = LDAP_NOT_SUPPORTED;
1685 #endif
1686         return rc;
1687 }
1688