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

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