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 char *
 736 ldap_pvt_tls_get_peer( void *s )
 737 {
 738     X509 *x;
 739     X509_NAME *xn;
 740     char buf[2048], *p;
 741
 742     /* If peer cert was bad, treat as if no cert was given */
 743     if (SSL_get_verify_result((SSL *)s))
 744         return NULL;
 745
 746     x = SSL_get_peer_certificate((SSL *)s);
 747
 748     if (!x)
 749         return NULL;
 750
 751     xn = X509_get_subject_name(x);
 752     p = LDAP_STRDUP(X509_NAME_oneline(xn, buf, sizeof(buf)));
 753     X509_free(x);
 754     return p;
 755 }
 756
 757 char *
 758 ldap_pvt_tls_get_peer_dn( void *s )
 759 {
 760         X509 *x;
 761         X509_NAME *xn;
 762         char buf[2048], *p, *dn;
 763
 764         if (SSL_get_verify_result((SSL *)s))
 765                 return NULL;
 766
 767         x = SSL_get_peer_certificate((SSL *)s);
 768
 769         if (!x) return NULL;
 770
 771         xn = X509_get_subject_name(x);
 772         p = X509_NAME_oneline(xn, buf, sizeof(buf));
 773
 774         dn = ldap_dcedn2dn( p );
 775
 776         X509_free(x);
 777         return dn;
 778 }
 779
 780 char *
 781 ldap_pvt_tls_get_peer_hostname( void *s )
 782 {
 783         X509 *x;
 784         X509_NAME *xn;
 785         char buf[2048], *p;
 786         int ret;
 787
 788         if (SSL_get_verify_result((SSL *)s))
 789                 return NULL;
 790
 791         x = SSL_get_peer_certificate((SSL *)s);
 792
 793         if (!x)
 794                 return NULL;
 795
 796         xn = X509_get_subject_name(x);
 797
 798         ret = X509_NAME_get_text_by_NID(xn, NID_commonName, buf, sizeof(buf));
 799         if( ret == -1 ) {
 800                 X509_free(x);
 801                 return NULL;
 802         }
 803
 804         p = LDAP_STRDUP(buf);
 805         X509_free(x);
 806         return p;
 807 }
 808
 809 int
 810 ldap_pvt_tls_check_hostname( void *s, const char *name_in )
 811 {
 812     int i, ret = LDAP_LOCAL_ERROR;
 813     X509 *x;
 814         const char *name;
 815
 816         if( ldap_int_hostname &&
 817                 ( !name_in || !strcasecmp( name_in, "localhost" ) ) )
 818         {
 819                 name = ldap_int_hostname;
 820         } else {
 821                 name = name_in;
 822         }
 823
 824         if (SSL_get_verify_result((SSL *)s))
 825                 return LDAP_CONNECT_ERROR;
 826
 827     x = SSL_get_peer_certificate((SSL *)s);
 828     if (!x)
 829     {
 830         Debug( LDAP_DEBUG_ANY,
 831                 "TLS: unable to get peer certificate.\n",
 832                 0, 0, 0 );
 833         return ret;
 834     }
 835
 836     i = X509_get_ext_by_NID(x, NID_subject_alt_name, -1);
 837     if (i >= 0)
 838     {
 839         X509_EXTENSION *ex;
 840         STACK_OF(GENERAL_NAME) *alt;
 841
 842         ex = X509_get_ext(x, i);
 843         alt = X509V3_EXT_d2i(ex);
 844         if (alt)
 845         {
 846             int n, len1, len2;
 847             char *domain;
 848             GENERAL_NAME *gn;
 849             X509V3_EXT_METHOD *method;
 850
 851             len1 = strlen(name);
 852             n = sk_GENERAL_NAME_num(alt);
 853             domain = strchr(name, '.');
 854             if (domain)
 855                 len2 = len1 - (domain-name);
 856             for (i=0; i<n; i++)
 857             {
 858                 gn = sk_GENERAL_NAME_value(alt, i);
 859                 if (gn->type == GEN_DNS)
 860                 {
 861                     char *sn = ASN1_STRING_data(gn->d.ia5);
 862                     int sl = ASN1_STRING_length(gn->d.ia5);
 863
 864                     /* Is this an exact match? */
 865                     if ((len1 == sl) && !strncasecmp(name, sn, len1))
 866                         break;
 867
 868                     /* Is this a wildcard match? */
 869                     if ((*sn == '*') && domain && (len2 == sl-1) &&
 870                         !strncasecmp(domain, sn+1, len2))
 871                         break;
 872                 }
 873             }
 874             method = X509V3_EXT_get(ex);
 875             method->ext_free(alt);
 876             if (i < n)  /* Found a match */
 877                 ret = LDAP_SUCCESS;
 878         }
 879     }
 880
 881     if (ret != LDAP_SUCCESS)
 882     {
 883         X509_NAME *xn;
 884         char buf[2048];
 885
 886         xn = X509_get_subject_name(x);
 887
 888         if (X509_NAME_get_text_by_NID(xn, NID_commonName, buf, sizeof(buf))
 889             == -1)
 890         {
 891             Debug( LDAP_DEBUG_ANY,
 892                     "TLS: unable to get common name from peer certificate.\n",
 893                     0, 0, 0 );
 894         } else if (strcasecmp(name, buf))
 895         {
 896             Debug( LDAP_DEBUG_ANY, "TLS: hostname (%s) does not match "
 897                     "common name in certificate (%s).\n",
 898                     name, buf, 0 );
 899             ret =  LDAP_CONNECT_ERROR;
 900         } else
 901         {
 902             ret = LDAP_SUCCESS;
 903         }
 904     }
 905     X509_free(x);
 906     return ret;
 907 }
 908
 909 const char *
 910 ldap_pvt_tls_get_peer_issuer( void *s )
 911 {
 912 #if 0   /* currently unused; see ldap_pvt_tls_get_peer() if needed */
 913     X509 *x;
 914     X509_NAME *xn;
 915     char buf[2048], *p;
 916
 917     x = SSL_get_peer_certificate((SSL *)s);
 918
 919     if (!x)
 920         return NULL;
 921
 922     xn = X509_get_issuer_name(x);
 923     p = LDAP_STRDUP(X509_NAME_oneline(xn, buf, sizeof(buf)));
 924     X509_free(x);
 925     return p;
 926 #else
 927     return NULL;
 928 #endif
 929 }
 930
 931 int
 932 ldap_int_tls_config( LDAP *ld, int option, const char *arg )
 933 {
 934         int i;
 935
 936         switch( option ) {
 937         case LDAP_OPT_X_TLS_CACERTFILE:
 938         case LDAP_OPT_X_TLS_CACERTDIR:
 939         case LDAP_OPT_X_TLS_CERTFILE:
 940         case LDAP_OPT_X_TLS_KEYFILE:
 941         case LDAP_OPT_X_TLS_RANDOM_FILE:
 942                 return ldap_pvt_tls_set_option( ld, option, (void *) arg );
 943
 944         case LDAP_OPT_X_TLS_REQUIRE_CERT:
 945         case LDAP_OPT_X_TLS:
 946                 i = -1;
 947                 if ( strcasecmp( arg, "never" ) == 0 )
 948                         i = LDAP_OPT_X_TLS_NEVER ;
 949                 if ( strcasecmp( arg, "demand" ) == 0 )
 950                         i = LDAP_OPT_X_TLS_DEMAND ;
 951                 if ( strcasecmp( arg, "allow" ) == 0 )
 952                         i = LDAP_OPT_X_TLS_ALLOW ;
 953                 if ( strcasecmp( arg, "try" ) == 0 )
 954                         i = LDAP_OPT_X_TLS_TRY ;
 955                 if ( ( strcasecmp( arg, "hard" ) == 0 ) ||
 956                       ( strcasecmp( arg, "on" ) == 0 ) ||
 957                       ( strcasecmp( arg, "yes" ) == 0) ||
 958                       ( strcasecmp( arg, "true" ) == 0 ) )
 959                         i = LDAP_OPT_X_TLS_HARD ;
 960
 961                 if (i >= 0) {
 962                         return ldap_pvt_tls_set_option( ld, option, &i );
 963                 }
 964                 return -1;
 965         }
 966
 967         return -1;
 968 }
 969
 970 int
 971 ldap_pvt_tls_get_option( LDAP *ld, int option, void *arg )
 972 {
 973         struct ldapoptions *lo;
 974
 975         if( ld != NULL ) {
 976                 assert( LDAP_VALID( ld ) );
 977
 978                 if( !LDAP_VALID( ld ) ) {
 979                         return LDAP_OPT_ERROR;
 980                 }
 981
 982                 lo = &ld->ld_options;
 983
 984         } else {
 985                 /* Get pointer to global option structure */
 986                 lo = LDAP_INT_GLOBAL_OPT();
 987                 if ( lo == NULL ) {
 988                         return LDAP_NO_MEMORY;
 989                 }
 990         }
 991
 992         switch( option ) {
 993         case LDAP_OPT_X_TLS:
 994                 *(int *)arg = lo->ldo_tls_mode;
 995                 break;
 996         case LDAP_OPT_X_TLS_CTX:
 997                 if ( ld == NULL )
 998                         *(void **)arg = (void *) tls_def_ctx;
 999                 else
1000                         *(void **)arg = ld->ld_defconn->lconn_tls_ctx;
1001                 break;
1002         case LDAP_OPT_X_TLS_CACERTFILE:
1003                 *(char **)arg = tls_opt_cacertfile ?
1004                         LDAP_STRDUP( tls_opt_cacertfile ) : NULL;
1005                 break;
1006         case LDAP_OPT_X_TLS_CACERTDIR:
1007                 *(char **)arg = tls_opt_cacertdir ?
1008                         LDAP_STRDUP( tls_opt_cacertdir ) : NULL;
1009                 break;
1010         case LDAP_OPT_X_TLS_CERTFILE:
1011                 *(char **)arg = tls_opt_certfile ?
1012                         LDAP_STRDUP( tls_opt_certfile ) : NULL;
1013                 break;
1014         case LDAP_OPT_X_TLS_KEYFILE:
1015                 *(char **)arg = tls_opt_keyfile ?
1016                         LDAP_STRDUP( tls_opt_keyfile ) : NULL;
1017                 break;
1018         case LDAP_OPT_X_TLS_REQUIRE_CERT:
1019                 *(int *)arg = tls_opt_require_cert;
1020                 break;
1021         case LDAP_OPT_X_TLS_RANDOM_FILE:
1022                 *(char **)arg = tls_opt_randfile ?
1023                         LDAP_STRDUP( tls_opt_randfile ) : NULL;
1024                 break;
1025         default:
1026                 return -1;
1027         }
1028         return 0;
1029 }
1030
1031 int
1032 ldap_pvt_tls_set_option( LDAP *ld, int option, void *arg )
1033 {
1034         struct ldapoptions *lo;
1035
1036         if( ld != NULL ) {
1037                 assert( LDAP_VALID( ld ) );
1038
1039                 if( !LDAP_VALID( ld ) ) {
1040                         return LDAP_OPT_ERROR;
1041                 }
1042
1043                 lo = &ld->ld_options;
1044
1045         } else {
1046                 /* Get pointer to global option structure */
1047                 lo = LDAP_INT_GLOBAL_OPT();
1048                 if ( lo == NULL ) {
1049                         return LDAP_NO_MEMORY;
1050                 }
1051         }
1052
1053         switch( option ) {
1054         case LDAP_OPT_X_TLS:
1055                 switch( *(int *) arg ) {
1056                 case LDAP_OPT_X_TLS_NEVER:
1057                 case LDAP_OPT_X_TLS_DEMAND:
1058                 case LDAP_OPT_X_TLS_ALLOW:
1059                 case LDAP_OPT_X_TLS_TRY:
1060                 case LDAP_OPT_X_TLS_HARD:
1061                         if (lo != NULL) {
1062                                 lo->ldo_tls_mode = *(int *)arg;
1063                         }
1064
1065                         return 0;
1066                 }
1067                 return -1;
1068
1069         case LDAP_OPT_X_TLS_CTX:
1070                 if ( ld == NULL ) {
1071                         tls_def_ctx = (SSL_CTX *) arg;
1072
1073                 } else {
1074                         ld->ld_defconn->lconn_tls_ctx = arg;
1075                 }
1076                 return 0;
1077         }
1078
1079         if ( ld != NULL ) {
1080                 return -1;
1081         }
1082
1083         switch( option ) {
1084         case LDAP_OPT_X_TLS_CACERTFILE:
1085                 if ( tls_opt_cacertfile ) LDAP_FREE( tls_opt_cacertfile );
1086                 tls_opt_cacertfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
1087                 break;
1088         case LDAP_OPT_X_TLS_CACERTDIR:
1089                 if ( tls_opt_cacertdir ) LDAP_FREE( tls_opt_cacertdir );
1090                 tls_opt_cacertdir = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
1091                 break;
1092         case LDAP_OPT_X_TLS_CERTFILE:
1093                 if ( tls_opt_certfile ) LDAP_FREE( tls_opt_certfile );
1094                 tls_opt_certfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
1095                 break;
1096         case LDAP_OPT_X_TLS_KEYFILE:
1097                 if ( tls_opt_keyfile ) LDAP_FREE( tls_opt_keyfile );
1098                 tls_opt_keyfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
1099                 break;
1100         case LDAP_OPT_X_TLS_REQUIRE_CERT:
1101                 switch( *(int *) arg ) {
1102                 case LDAP_OPT_X_TLS_NEVER:
1103                 case LDAP_OPT_X_TLS_DEMAND:
1104                 case LDAP_OPT_X_TLS_ALLOW:
1105                 case LDAP_OPT_X_TLS_TRY:
1106                 case LDAP_OPT_X_TLS_HARD:
1107                         tls_opt_require_cert = * (int *) arg;
1108                         return 0;
1109                 }
1110                 return -1;
1111         case LDAP_OPT_X_TLS_CIPHER_SUITE:
1112                 if ( tls_opt_ciphersuite ) LDAP_FREE( tls_opt_ciphersuite );
1113                 tls_opt_ciphersuite = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
1114                 break;
1115         case LDAP_OPT_X_TLS_RANDOM_FILE:
1116                 if (tls_opt_randfile ) LDAP_FREE (tls_opt_randfile );
1117                 tls_opt_randfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
1118                 break;
1119         default:
1120                 return -1;
1121         }
1122         return 0;
1123 }
1124
1125 int
1126 ldap_int_tls_start ( LDAP *ld, LDAPConn *conn, LDAPURLDesc *srv )
1127 {
1128         Sockbuf *sb = conn->lconn_sb;
1129         char *host;
1130         void *ssl;
1131
1132         if( srv ) {
1133                 host = srv->lud_host;
1134         } else {
1135                 host = conn->lconn_server->lud_host;
1136         }
1137
1138         /* avoid NULL host */
1139         if( host == NULL ) {
1140                 host = "localhost";
1141         }
1142
1143         (void) ldap_pvt_tls_init();
1144
1145         /*
1146          * Fortunately, the lib uses blocking io...
1147          */
1148         if ( ldap_int_tls_connect( ld, conn ) < 0 ) {
1149                 ld->ld_errno = LDAP_CONNECT_ERROR;
1150                 return (ld->ld_errno);
1151         }
1152
1153         ssl = (void *) ldap_pvt_tls_sb_ctx( sb );
1154         assert( ssl != NULL );
1155
1156         /*
1157          * compare host with name(s) in certificate
1158          */
1159         ld->ld_errno = ldap_pvt_tls_check_hostname( ssl, host );
1160         if (ld->ld_errno != LDAP_SUCCESS) {
1161                 return ld->ld_errno;
1162         }
1163
1164         /*
1165          * set SASL properties to TLS ssf and authid
1166          */
1167         {
1168                 const char *authid;
1169                 ber_len_t ssf;
1170
1171                 /* we need to let SASL know */
1172                 ssf = ldap_pvt_tls_get_strength( ssl );
1173                 authid = ldap_pvt_tls_get_peer( ssl );
1174
1175                 (void) ldap_int_sasl_external( ld, conn, authid, ssf );
1176         }
1177
1178         return LDAP_SUCCESS;
1179 }
1180
1181 /* Derived from openssl/apps/s_cb.c */
1182 static void
1183 tls_info_cb( SSL *ssl, int where, int ret )
1184 {
1185         int w;
1186         char *op;
1187
1188         w = where & ~SSL_ST_MASK;
1189         if ( w & SSL_ST_CONNECT ) {
1190                 op = "SSL_connect";
1191         } else if ( w & SSL_ST_ACCEPT ) {
1192                 op = "SSL_accept";
1193         } else {
1194                 op = "undefined";
1195         }
1196
1197         if ( where & SSL_CB_LOOP ) {
1198                 Debug( LDAP_DEBUG_TRACE,
1199                        "TLS trace: %s:%s\n",
1200                        op, SSL_state_string_long( ssl ), 0 );
1201         } else if ( where & SSL_CB_ALERT ) {
1202                 op = ( where & SSL_CB_READ ) ? "read" : "write";
1203                 Debug( LDAP_DEBUG_TRACE,
1204                        "TLS trace: SSL3 alert %s:%s:%s\n",
1205                        op,
1206                        SSL_alert_type_string_long( ret ),
1207                        SSL_alert_desc_string_long( ret) );
1208         } else if ( where & SSL_CB_EXIT ) {
1209                 if ( ret == 0 ) {
1210                         Debug( LDAP_DEBUG_TRACE,
1211                                "TLS trace: %s:failed in %s\n",
1212                                op, SSL_state_string_long( ssl ), 0 );
1213                 } else if ( ret < 0 ) {
1214                         Debug( LDAP_DEBUG_TRACE,
1215                                "TLS trace: %s:error in %s\n",
1216                                op, SSL_state_string_long( ssl ), 0 );
1217                 }
1218         }
1219 }
1220
1221 static int
1222 tls_verify_cb( int ok, X509_STORE_CTX *ctx )
1223 {
1224         X509 *cert;
1225         int errnum;
1226         int errdepth;
1227         X509_NAME *subject;
1228         X509_NAME *issuer;
1229         char *sname;
1230         char *iname;
1231
1232         cert = X509_STORE_CTX_get_current_cert( ctx );
1233         errnum = X509_STORE_CTX_get_error( ctx );
1234         errdepth = X509_STORE_CTX_get_error_depth( ctx );
1235
1236         /*
1237          * X509_get_*_name return pointers to the internal copies of
1238          * those things requested.  So do not free them.
1239          */
1240         subject = X509_get_subject_name( cert );
1241         issuer = X509_get_issuer_name( cert );
1242         /* X509_NAME_oneline, if passed a NULL buf, allocate memomry */
1243         sname = X509_NAME_oneline( subject, NULL, 0 );
1244         iname = X509_NAME_oneline( issuer, NULL, 0 );
1245         Debug( LDAP_DEBUG_TRACE,
1246                "TLS certificate verification: depth: %d, subject: %s, issuer: %s\n",
1247                errdepth,
1248                sname ? sname : "-unknown-",
1249                iname ? iname : "-unknown-" );
1250         if ( sname )
1251                 CRYPTO_free ( sname );
1252         if ( iname )
1253                 CRYPTO_free ( iname );
1254
1255         return ok;
1256 }
1257
1258 static int
1259 tls_verify_ok( int ok, X509_STORE_CTX *ctx )
1260 {
1261         (void) tls_verify_cb( ok, ctx );
1262         return 1;
1263 }
1264
1265 /* Inspired by ERR_print_errors in OpenSSL */
1266 static void
1267 tls_report_error( void )
1268 {
1269         unsigned long l;
1270         char buf[200];
1271         const char *file;
1272         int line;
1273
1274         while ( ( l = ERR_get_error_line( &file, &line ) ) != 0 ) {
1275                         Debug( LDAP_DEBUG_ANY, "TLS: %s %s:%d\n",
1276                                ERR_error_string( l, buf ), file, line );
1277         }
1278 }
1279
1280 static RSA *
1281 tls_tmp_rsa_cb( SSL *ssl, int is_export, int key_length )
1282 {
1283         RSA *tmp_rsa;
1284
1285         /* FIXME:  Pregenerate the key on startup */
1286         /* FIXME:  Who frees the key? */
1287         tmp_rsa = RSA_generate_key( key_length, RSA_F4, NULL, NULL );
1288
1289         if ( !tmp_rsa ) {
1290                 Debug( LDAP_DEBUG_ANY,
1291                         "TLS: Failed to generate temporary %d-bit %s RSA key\n",
1292                         key_length, is_export ? "export" : "domestic", 0 );
1293                 return NULL;
1294         }
1295         return tmp_rsa;
1296 }
1297
1298 static int
1299 tls_seed_PRNG( const char *randfile )
1300 {
1301 #ifndef URANDOM_DEVICE
1302         /* no /dev/urandom (or equiv) */
1303         long total=0;
1304         char buffer[MAXPATHLEN];
1305
1306         if (randfile == NULL) {
1307                 /* The seed file is $RANDFILE if defined, otherwise $HOME/.rnd.
1308                  * If $HOME is not set or buffer too small to hold the pathname,
1309                  * an error occurs.    - From RAND_file_name() man page.
1310                  * The fact is that when $HOME is NULL, .rnd is used.
1311                  */
1312                 randfile = RAND_file_name( buffer, sizeof( buffer ) );
1313
1314         } else if (RAND_egd(randfile) > 0) {
1315                 /* EGD socket */
1316                 return 0;
1317         }
1318
1319         if (randfile == NULL) {
1320                 Debug( LDAP_DEBUG_ANY,
1321                         "TLS: Use configuration file or $RANDFILE to define seed PRNG\n",
1322                         0, 0, 0);
1323                 return -1;
1324         }
1325
1326         total = RAND_load_file(randfile, -1);
1327
1328         if (RAND_status() == 0) {
1329                 Debug( LDAP_DEBUG_ANY,
1330                         "TLS: PRNG not been seeded with enough data\n",
1331                         0, 0, 0);
1332                 return -1;
1333         }
1334
1335         /* assume if there was enough bits to seed that it's okay
1336          * to write derived bits to the file
1337          */
1338         RAND_write_file(randfile);
1339
1340 #endif
1341
1342         return 0;
1343 }
1344
1345 #if 0
1346 static DH *
1347 tls_tmp_dh_cb( SSL *ssl, int is_export, int key_length )
1348 {
1349         return NULL;
1350 }
1351 #endif
1352 #endif
1353
1354 int
1355 ldap_start_tls_s ( LDAP *ld,
1356         LDAPControl **serverctrls,
1357         LDAPControl **clientctrls )
1358 {
1359         int rc;
1360
1361 #ifdef HAVE_TLS
1362         char *rspoid = NULL;
1363         struct berval *rspdata = NULL;
1364
1365         /* XXYYZ: this initiates operation only on default connection! */
1366
1367         if ( ld->ld_sb != NULL && ldap_pvt_tls_inplace( ld->ld_sb ) != 0 ) {
1368                 return LDAP_LOCAL_ERROR;
1369         }
1370
1371         rc = ldap_extended_operation_s( ld, LDAP_EXOP_START_TLS,
1372                 NULL, serverctrls, clientctrls, &rspoid, &rspdata );
1373         if ( rc != LDAP_SUCCESS ) {
1374                 return rc;
1375         }
1376
1377         if ( rspoid != NULL ) {
1378                 LDAP_FREE(rspoid);
1379         }
1380
1381         if ( rspdata != NULL ) {
1382                 ber_bvfree( rspdata );
1383         }
1384
1385         rc = ldap_int_tls_start( ld, ld->ld_defconn, NULL );
1386 #else
1387         rc = LDAP_NOT_SUPPORTED;
1388 #endif
1389         return rc;
1390 }
1391