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