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