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

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