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

   1 /* $OpenLDAP$ */
   2 /*
   3  * Copyright 1998-1999 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 #ifdef HAVE_TLS
  12
  13 #include <stdio.h>
  14
  15 #include <ac/stdlib.h>
  16 #include <ac/errno.h>
  17 #include <ac/socket.h>
  18 #include <ac/string.h>
  19 #include <ac/time.h>
  20 #include <ac/unistd.h>
  21
  22 #include "ldap-int.h"
  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 #elif defined( HAVE_SSL_H )
  31 #include <ssl.h>
  32 #endif
  33
  34 static int  tls_opt_trace = 1;
  35 static char *tls_opt_certfile = NULL;
  36 static char *tls_opt_keyfile = NULL;
  37 static char *tls_opt_cacertfile = NULL;
  38 static char *tls_opt_cacertdir = NULL;
  39 static int  tls_opt_require_cert = 0;
  40 static char *tls_opt_ciphersuite = NULL;
  41
  42 #define HAS_TLS( sb ) ((sb)->sb_io==&tls_io)
  43
  44 static int tls_setup( Sockbuf *sb, void *arg );
  45 static int tls_remove( Sockbuf *sb );
  46 static ber_slen_t tls_read( Sockbuf *sb, void *buf, ber_len_t len );
  47 static ber_slen_t tls_write( Sockbuf *sb, void *buf, ber_len_t len );
  48 static int tls_close( Sockbuf *sb );
  49 static int tls_report_error( void );
  50
  51 static Sockbuf_IO tls_io=
  52 {
  53    tls_setup,
  54    tls_remove,
  55    tls_read,
  56    tls_write,
  57    tls_close
  58 };
  59
  60 static void tls_info_cb( SSL *ssl, int where, int ret );
  61 static int tls_verify_cb( int ok, X509_STORE_CTX *ctx );
  62 static RSA * tls_tmp_rsa_cb( SSL *ssl, int is_export, int key_length );
  63 static DH * tls_tmp_dh_cb( SSL *ssl, int is_export, int key_length );
  64 static STACK_OF(X509_NAME) * get_ca_list( char * bundle, char * dir );
  65
  66 static SSL_CTX *tls_def_ctx = NULL;
  67
  68 #ifdef LDAP_R_COMPILE
  69 /*
  70  * provide mutexes for the SSLeay library.
  71  */
  72 static ldap_pvt_thread_mutex_t  tls_mutexes[CRYPTO_NUM_LOCKS];
  73
  74 static void tls_locking_cb( int mode, int type, const char *file, int line )
  75 {
  76         if ( mode & CRYPTO_LOCK ) {
  77                 ldap_pvt_thread_mutex_lock( tls_mutexes+type );
  78         } else {
  79                 ldap_pvt_thread_mutex_unlock( tls_mutexes+type );
  80         }
  81 }
  82
  83 /*
  84  * an extra mutex for the default ctx.
  85  */
  86
  87 static ldap_pvt_thread_mutex_t tls_def_ctx_mutex;
  88
  89 static void tls_init_threads( void )
  90 {
  91         int i;
  92
  93         for( i=0; i< CRYPTO_NUM_LOCKS ; i++ ) {
  94                 ldap_pvt_thread_mutex_init( tls_mutexes+i );
  95         }
  96         CRYPTO_set_locking_callback( tls_locking_cb );
  97         /* FIXME: the thread id should be added somehow... */
  98
  99         ldap_pvt_thread_mutex_init( &tls_def_ctx_mutex );
 100 }
 101 #endif /* LDAP_R_COMPILE */
 102
 103 /*
 104  * Initialize tls system. Should be called only once.
 105  */
 106 int
 107 ldap_pvt_tls_init( void )
 108 {
 109         static int tls_initialized = 0;
 110
 111         if ( tls_initialized )
 112                 return 0;
 113         tls_initialized = 1;
 114 #ifdef LDAP_R_COMPILE
 115         tls_init_threads();
 116 #endif
 117         SSL_load_error_strings();
 118         SSLeay_add_ssl_algorithms();
 119         /* FIXME: mod_ssl does this */
 120         X509V3_add_standard_extensions();
 121         return 0;
 122 }
 123
 124 /*
 125  * initialize the default context
 126  */
 127 int
 128 ldap_pvt_tls_init_def_ctx( void )
 129 {
 130         STACK_OF(X509_NAME) *calist;
 131
 132 #ifdef LDAP_R_COMPILE
 133         ldap_pvt_thread_mutex_lock( &tls_def_ctx_mutex );
 134 #endif
 135         if ( tls_def_ctx == NULL ) {
 136                 tls_def_ctx = SSL_CTX_new( SSLv23_method() );
 137                 if ( tls_def_ctx == NULL ) {
 138                         Debug( LDAP_DEBUG_ANY,
 139                                "TLS: could not allocate default ctx.\n",0,0,0);
 140                         goto error_exit;
 141                 }
 142                 if ( tls_opt_ciphersuite &&
 143                      !SSL_CTX_set_cipher_list( tls_def_ctx,
 144                         tls_opt_ciphersuite ) ) {
 145                         Debug( LDAP_DEBUG_ANY,
 146                                "TLS: could not set cipher list %s.\n",
 147                                tls_opt_ciphersuite, 0, 0 );
 148                         tls_report_error();
 149                         goto error_exit;
 150                 }
 151                 if (tls_opt_cacertfile != NULL || tls_opt_cacertdir != NULL) {
 152                         if ( !SSL_CTX_load_verify_locations( tls_def_ctx,
 153                                                              tls_opt_cacertfile,
 154                                                              tls_opt_cacertdir )
 155                              || !SSL_CTX_set_default_verify_paths( tls_def_ctx ) )
 156                         {
 157                                 Debug( LDAP_DEBUG_ANY,
 158                         "TLS: could not load verify locations (file:`%s',dir:`%s').\n",
 159                                        tls_opt_cacertfile,tls_opt_cacertdir,0);
 160                                 tls_report_error();
 161                                 goto error_exit;
 162                         }
 163                         calist = get_ca_list( tls_opt_cacertfile, tls_opt_cacertdir );
 164                         if ( !calist ) {
 165                                 Debug( LDAP_DEBUG_ANY,
 166                         "TLS: could not load client CA list (file:`%s',dir:`%s').\n",
 167                                        tls_opt_cacertfile,tls_opt_cacertdir,0);
 168                                 tls_report_error();
 169                                 goto error_exit;
 170                         }
 171                         SSL_CTX_set_client_CA_list( tls_def_ctx, calist );
 172                 }
 173                 if ( tls_opt_keyfile &&
 174                      !SSL_CTX_use_PrivateKey_file( tls_def_ctx,
 175                                                    tls_opt_keyfile,
 176                                                    SSL_FILETYPE_PEM ) ) {
 177                         Debug( LDAP_DEBUG_ANY,
 178                                "TLS: could not use key file `%s'.\n",
 179                                tls_opt_keyfile,0,0);
 180                         tls_report_error();
 181                         goto error_exit;
 182                 }
 183                 if ( tls_opt_certfile &&
 184                      !SSL_CTX_use_certificate_file( tls_def_ctx,
 185                                                     tls_opt_certfile,
 186                                                     SSL_FILETYPE_PEM ) ) {
 187                         Debug( LDAP_DEBUG_ANY,
 188                                "TLS: could not use certificate `%s'.\n",
 189                                tls_opt_certfile,0,0);
 190                         tls_report_error();
 191                         goto error_exit;
 192                 }
 193                 if ( ( tls_opt_certfile || tls_opt_keyfile ) &&
 194                      !SSL_CTX_check_private_key( tls_def_ctx ) ) {
 195                         Debug( LDAP_DEBUG_ANY,
 196                                "TLS: private key mismatch.\n",
 197                                0,0,0);
 198                         tls_report_error();
 199                         goto error_exit;
 200                 }
 201                 if ( tls_opt_trace ) {
 202                         SSL_CTX_set_info_callback( tls_def_ctx, tls_info_cb );
 203                 }
 204                 SSL_CTX_set_verify( tls_def_ctx, (tls_opt_require_cert) ?
 205                         (SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT) :
 206                         SSL_VERIFY_PEER, tls_verify_cb );
 207                 SSL_CTX_set_tmp_rsa_callback( tls_def_ctx, tls_tmp_rsa_cb );
 208                 /* SSL_CTX_set_tmp_dh_callback( tls_def_ctx, tls_tmp_dh_cb ); */
 209         }
 210 #ifdef LDAP_R_COMPILE
 211         ldap_pvt_thread_mutex_unlock( &tls_def_ctx_mutex );
 212 #endif
 213         return 0;
 214 error_exit:
 215         if ( tls_def_ctx != NULL ) {
 216                 SSL_CTX_free( tls_def_ctx );
 217                 tls_def_ctx = NULL;
 218         }
 219 #ifdef LDAP_R_COMPILE
 220         ldap_pvt_thread_mutex_unlock( &tls_def_ctx_mutex );
 221 #endif
 222         return -1;
 223 }
 224
 225 static STACK_OF(X509_NAME) *
 226 get_ca_list( char * bundle, char * dir )
 227 {
 228         STACK_OF(X509_NAME) *ca_list = NULL;
 229
 230         if ( bundle ) {
 231                 ca_list = SSL_load_client_CA_file( bundle );
 232         }
 233         /*
 234          * FIXME: We have now to go over all files in dir, load them
 235          * and add every certificate there to ca_list.
 236          */
 237         return ca_list;
 238 }
 239
 240 static SSL *
 241 alloc_handle( Sockbuf *sb, void *ctx_arg )
 242 {
 243         int     err;
 244         SSL_CTX *ctx;
 245         SSL     *ssl;
 246
 247         if ( ctx_arg ) {
 248                 ctx = (SSL_CTX *) ctx_arg;
 249         } else {
 250                 if ( ldap_pvt_tls_init_def_ctx() < 0 )
 251                         return NULL;
 252                 ctx = tls_def_ctx;
 253         }
 254
 255         ssl = SSL_new( ctx );
 256         if ( ssl == NULL ) {
 257                 Debug( LDAP_DEBUG_ANY,"TLS: can't create ssl handle.\n",0,0,0);
 258                 return NULL;
 259         }
 260
 261         if ( tls_opt_trace ) {
 262                 SSL_set_info_callback( ssl, tls_info_cb );
 263         }
 264         sb->sb_iodata = ssl;
 265         SSL_set_fd( ssl, ber_pvt_sb_get_desc( sb ) );
 266         return ssl;
 267 }
 268
 269 static int
 270 update_flags( Sockbuf *sb, SSL * ssl, int rc )
 271 {
 272         int err = SSL_get_error(ssl, rc);
 273
 274         sb->sb_trans_needs_read  = 0;
 275         sb->sb_trans_needs_write = 0;
 276         if (err == SSL_ERROR_WANT_READ)
 277         {
 278             sb->sb_trans_needs_read  = 1;
 279             return 1;
 280         } else if (err == SSL_ERROR_WANT_WRITE)
 281         {
 282             sb->sb_trans_needs_write = 1;
 283             return 1;
 284         } else if (err == SSL_ERROR_WANT_CONNECT)
 285         {
 286             return 1;
 287         }
 288         return 0;
 289 }
 290
 291 /*
 292  * Call this to do a TLS connect on a sockbuf. ctx_arg can be
 293  * a SSL_CTX * or NULL, in which case the default ctx is used.
 294  *
 295  * Return value:
 296  *
 297  *  0 - Success. Connection is ready for communication.
 298  * <0 - Error. Can't create a TLS stream.
 299  * >0 - Partial success.
 300  *        Do a select (using information from lber_pvt_sb_needs_{read,write}
 301  *              and call again.
 302  */
 303
 304 int
 305 ldap_pvt_tls_connect( Sockbuf *sb, void *ctx_arg )
 306 {
 307         int     err;
 308         SSL     *ssl;
 309
 310         if ( HAS_TLS( sb ) ) {
 311                 ssl = (SSL *) sb->sb_iodata;
 312         } else {
 313                 ssl = alloc_handle( sb, ctx_arg );
 314                 if ( ssl == NULL )
 315                         return -1;
 316                 ber_pvt_sb_clear_io( sb );
 317                 ber_pvt_sb_set_io( sb, &tls_io, (void *)ssl );
 318         }
 319
 320         err = SSL_connect( ssl );
 321
 322         if ( err <= 0 ) {
 323                 if ( update_flags( sb, ssl, err ))
 324                         return 1;
 325                 Debug( LDAP_DEBUG_ANY,"TLS: can't connect.\n",0,0,0);
 326                 ber_pvt_sb_clear_io( sb );
 327                 ber_pvt_sb_set_io( sb, &ber_pvt_sb_io_tcp, NULL );
 328                 return -1;
 329         }
 330         return 0;
 331 }
 332
 333 /*
 334  * Call this to do a TLS accept on a sockbuf.
 335  * Everything else is the same as with tls_connect.
 336  */
 337 int
 338 ldap_pvt_tls_accept( Sockbuf *sb, void *ctx_arg )
 339 {
 340         int     err;
 341         SSL     *ssl;
 342
 343         if ( HAS_TLS( sb ) ) {
 344                 ssl = (SSL *) sb->sb_iodata;
 345         } else {
 346                 ssl = alloc_handle( sb, ctx_arg );
 347                 if ( ssl == NULL )
 348                         return -1;
 349                 ber_pvt_sb_clear_io( sb );
 350                 ber_pvt_sb_set_io( sb, &tls_io, (void *)ssl );
 351         }
 352
 353         err = SSL_accept( ssl );
 354
 355         if ( err <= 0 ) {
 356                 if ( update_flags( sb, ssl, err ))
 357                         return 1;
 358                 Debug( LDAP_DEBUG_ANY,"TLS: can't accept.\n",0,0,0 );
 359                 tls_report_error();
 360                 ber_pvt_sb_clear_io( sb );
 361                 ber_pvt_sb_set_io( sb, &ber_pvt_sb_io_tcp, NULL );
 362                 return -1;
 363         }
 364         return 0;
 365 }
 366
 367 int
 368 ldap_pvt_tls_inplace ( Sockbuf *sb )
 369 {
 370         if ( HAS_TLS( sb ) )
 371                 return(1);
 372         return(0);
 373 }
 374
 375 const char *
 376 ldap_pvt_tls_get_peer( LDAP *ld )
 377 {
 378 }
 379
 380 const char *
 381 ldap_pvt_tls_get_peer_issuer( LDAP *ld )
 382 {
 383 }
 384
 385 int
 386 ldap_pvt_tls_config( struct ldapoptions *lo, int option, const char *arg )
 387 {
 388         int i;
 389
 390         switch( option ) {
 391         case LDAP_OPT_X_TLS_CACERTFILE:
 392         case LDAP_OPT_X_TLS_CACERTDIR:
 393         case LDAP_OPT_X_TLS_CERTFILE:
 394         case LDAP_OPT_X_TLS_KEYFILE:
 395                 return ldap_pvt_tls_set_option( NULL, option, (void *) arg );
 396         case LDAP_OPT_X_TLS_REQUIRE_CERT:
 397                 i = ( ( strcasecmp( arg, "on" ) == 0 ) ||
 398                       ( strcasecmp( arg, "yes" ) == 0) ||
 399                       ( strcasecmp( arg, "true" ) == 0 ) );
 400                 return ldap_pvt_tls_set_option( NULL, option, (void *) &i );
 401         case LDAP_OPT_X_TLS:
 402                 i = -1;
 403                 if ( strcasecmp( arg, "never" ) == 0 )
 404                         i = LDAP_OPT_X_TLS_NEVER ;
 405                 if ( strcasecmp( arg, "demand" ) == 0 )
 406                         i = LDAP_OPT_X_TLS_DEMAND ;
 407                 if ( strcasecmp( arg, "allow" ) == 0 )
 408                         i = LDAP_OPT_X_TLS_ALLOW ;
 409                 if ( strcasecmp( arg, "try" ) == 0 )
 410                         i = LDAP_OPT_X_TLS_TRY ;
 411                 if ( strcasecmp( arg, "hard" ) == 0 )
 412                         i = LDAP_OPT_X_TLS_HARD ;
 413                 if (i >= 0)
 414                         return ldap_pvt_tls_set_option( lo, option, &i );
 415                 return -1;
 416         default:
 417                 return -1;
 418         }
 419 }
 420
 421 int
 422 ldap_pvt_tls_get_option( struct ldapoptions *lo, int option, void *arg )
 423 {
 424         switch( option ) {
 425         case LDAP_OPT_X_TLS:
 426                 *(int *)arg = lo->ldo_tls_mode;
 427                 break;
 428         case LDAP_OPT_X_TLS_CERT:
 429                 if ( lo == NULL )
 430                         arg = (void *) tls_def_ctx;
 431                 else
 432                         arg = lo->ldo_tls_ctx;
 433                 break;
 434         case LDAP_OPT_X_TLS_CACERTFILE:
 435                 *(char **)arg = tls_opt_cacertfile ?
 436                         LDAP_STRDUP( tls_opt_cacertfile ) : NULL;
 437                 break;
 438         case LDAP_OPT_X_TLS_CACERTDIR:
 439                 *(char **)arg = tls_opt_cacertdir ?
 440                         LDAP_STRDUP( tls_opt_cacertdir ) : NULL;
 441                 break;
 442         case LDAP_OPT_X_TLS_CERTFILE:
 443                 *(char **)arg = tls_opt_certfile ?
 444                         LDAP_STRDUP( tls_opt_certfile ) : NULL;
 445                 break;
 446         case LDAP_OPT_X_TLS_KEYFILE:
 447                 *(char **)arg = tls_opt_keyfile ?
 448                         LDAP_STRDUP( tls_opt_keyfile ) : NULL;
 449                 break;
 450         case LDAP_OPT_X_TLS_REQUIRE_CERT:
 451                 *(int *)arg = tls_opt_require_cert;
 452                 break;
 453         default:
 454                 return -1;
 455         }
 456         return 0;
 457 }
 458
 459 int
 460 ldap_pvt_tls_set_option( struct ldapoptions *lo, int option, void *arg )
 461 {
 462         switch( option ) {
 463         case LDAP_OPT_X_TLS:
 464                 switch( *(int *) arg ) {
 465                 case LDAP_OPT_X_TLS_NEVER:
 466                 case LDAP_OPT_X_TLS_DEMAND:
 467                 case LDAP_OPT_X_TLS_ALLOW:
 468                 case LDAP_OPT_X_TLS_TRY:
 469                 case LDAP_OPT_X_TLS_HARD:
 470                         if (lo != NULL) {
 471                                 lo->ldo_tls_mode = *(int *)arg;
 472                         }
 473
 474                         return 0;
 475                 }
 476                 return -1;
 477
 478         case LDAP_OPT_X_TLS_CERT:
 479                 if ( lo == NULL ) {
 480                         tls_def_ctx = (SSL_CTX *) arg;
 481
 482                 } else {
 483                         lo->ldo_tls_ctx = arg;
 484                 }
 485                 return 0;
 486         }
 487
 488         if ( lo != NULL ) {
 489                 return -1;
 490         }
 491
 492         switch( option ) {
 493         case LDAP_OPT_X_TLS_CACERTFILE:
 494                 if ( tls_opt_cacertfile ) free( tls_opt_cacertfile );
 495                 tls_opt_cacertfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
 496                 break;
 497         case LDAP_OPT_X_TLS_CACERTDIR:
 498                 if ( tls_opt_cacertdir ) free( tls_opt_cacertdir );
 499                 tls_opt_cacertdir = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
 500                 break;
 501         case LDAP_OPT_X_TLS_CERTFILE:
 502                 if ( tls_opt_certfile ) free( tls_opt_certfile );
 503                 tls_opt_certfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
 504                 break;
 505         case LDAP_OPT_X_TLS_KEYFILE:
 506                 if ( tls_opt_keyfile ) free( tls_opt_keyfile );
 507                 tls_opt_keyfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
 508                 break;
 509         case LDAP_OPT_X_TLS_REQUIRE_CERT:
 510                 tls_opt_require_cert = * (int *) arg;
 511                 break;
 512         case LDAP_OPT_X_TLS_CIPHER_SUITE:
 513                 if ( tls_opt_ciphersuite ) free( tls_opt_ciphersuite );
 514                 tls_opt_ciphersuite = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
 515                 break;
 516         default:
 517                 return -1;
 518         }
 519         return 0;
 520 }
 521
 522 int
 523 ldap_pvt_tls_start ( Sockbuf *sb, void *ctx_arg )
 524 {
 525         /*
 526          * Fortunately, the lib uses blocking io...
 527          */
 528         if ( ldap_pvt_tls_connect( sb, ctx_arg ) < 0 ) {
 529                 return LDAP_CONNECT_ERROR;
 530         }
 531
 532         /* FIXME: hostname of server must be compared with name in
 533          * certificate....
 534          */
 535
 536         return LDAP_SUCCESS;
 537 }
 538
 539
 540 static int
 541 tls_setup( Sockbuf *sb, void *arg )
 542 {
 543         sb->sb_iodata = arg;
 544         return 0;
 545 }
 546
 547 static int
 548 tls_remove( Sockbuf *sb )
 549 {
 550         SSL_free( (SSL *) sb->sb_iodata );
 551         return 0;
 552 }
 553
 554 static ber_slen_t
 555 tls_write( Sockbuf *sb, void *buf, ber_len_t sz )
 556 {
 557         int ret = SSL_write( (SSL *)sb->sb_iodata, buf, sz );
 558
 559         update_flags(sb, (SSL *)sb->sb_iodata, ret );
 560 #ifdef WIN32
 561         if (sb->sb_trans_needs_write)
 562                 errno = EWOULDBLOCK;
 563 #endif
 564         return ret;
 565 }
 566
 567 static ber_slen_t
 568 tls_read( Sockbuf *sb, void *buf, ber_len_t sz )
 569 {
 570         int ret = SSL_read( (SSL *)sb->sb_iodata, buf, sz );
 571
 572         update_flags(sb, (SSL *)sb->sb_iodata, ret );
 573 #ifdef WIN32
 574         if (sb->sb_trans_needs_read)
 575                 errno = EWOULDBLOCK;
 576 #endif
 577         return ret;
 578 }
 579
 580 static int
 581 tls_close( Sockbuf *sb )
 582 {
 583         tcp_close( ber_pvt_sb_get_desc( sb ) );
 584         return 0;
 585 }
 586
 587 /* Derived from openssl/apps/s_cb.c */
 588 static void
 589 tls_info_cb( SSL *ssl, int where, int ret )
 590 {
 591         int w;
 592         char *op;
 593
 594         w = where & ~SSL_ST_MASK;
 595         if ( w & SSL_ST_CONNECT ) {
 596                 op = "SSL_connect";
 597         } else if ( w & SSL_ST_ACCEPT ) {
 598                 op = "SSL_accept";
 599         } else {
 600                 op = "undefined";
 601         }
 602
 603         if ( where & SSL_CB_LOOP ) {
 604                 Debug( LDAP_DEBUG_TRACE,
 605                        "TLS trace: %s:%s\n",
 606                        op, SSL_state_string_long( ssl ), 0 );
 607         } else if ( where & SSL_CB_ALERT ) {
 608                 op = ( where & SSL_CB_READ ) ? "read" : "write";
 609                 Debug( LDAP_DEBUG_TRACE,
 610                        "TLS trace: SSL3 alert %s:%s:%s\n",
 611                        op,
 612                        SSL_alert_type_string_long( ret ),
 613                        SSL_alert_desc_string_long( ret) );
 614         } else if ( where & SSL_CB_EXIT ) {
 615                 if ( ret == 0 ) {
 616                         Debug( LDAP_DEBUG_TRACE,
 617                                "TLS trace: %s:failed in %s\n",
 618                                op, SSL_state_string_long( ssl ), 0 );
 619                 } else if ( ret < 0 ) {
 620                         Debug( LDAP_DEBUG_TRACE,
 621                                "TLS trace: %s:error in %s\n",
 622                                op, SSL_state_string_long( ssl ), 0 );
 623                 }
 624         }
 625 }
 626
 627 static int
 628 tls_verify_cb( int ok, X509_STORE_CTX *ctx )
 629 {
 630         X509 *cert;
 631         int errnum;
 632         int errdepth;
 633         X509_NAME *subject;
 634         X509_NAME *issuer;
 635         char *sname;
 636         char *iname;
 637
 638         cert = X509_STORE_CTX_get_current_cert( ctx );
 639         errnum = X509_STORE_CTX_get_error( ctx );
 640         errdepth = X509_STORE_CTX_get_error_depth( ctx );
 641
 642         /*
 643          * X509_get_*_name return pointers to the internal copies of
 644          * those things requested.  So do not free them.
 645          */
 646         subject = X509_get_subject_name( cert );
 647         issuer = X509_get_issuer_name( cert );
 648         /* X509_NAME_oneline, if passed a NULL buf, allocate memomry */
 649         sname = X509_NAME_oneline( subject, NULL, 0 );
 650         iname = X509_NAME_oneline( issuer, NULL, 0 );
 651         Debug( LDAP_DEBUG_TRACE,
 652                "TLS certificate verification: depth: %d, subject: %s, issuer: %s\n",
 653                errdepth,
 654                sname ? sname : "-unknown-",
 655                iname ? iname : "-unknown-" );
 656         if ( sname )
 657                 CRYPTO_free ( sname );
 658         if ( iname )
 659                 CRYPTO_free ( iname );
 660
 661         return 1;
 662 }
 663
 664 /* Inspired by ERR_print_errors in OpenSSL */
 665 static int
 666 tls_report_error( void )
 667 {
 668         unsigned long l;
 669         char buf[200];
 670         const char *file;
 671         int line;
 672
 673         while ( ( l = ERR_get_error_line( &file, &line ) ) != 0 ) {
 674                         Debug( LDAP_DEBUG_ANY, "TLS: %s %s:%d\n",
 675                                ERR_error_string( l, buf ), file, line );
 676         }
 677 }
 678
 679 static RSA *
 680 tls_tmp_rsa_cb( SSL *ssl, int is_export, int key_length )
 681 {
 682         RSA *tmp_rsa;
 683
 684         /* FIXME:  Pregenerate the key on startup */
 685         /* FIXME:  Who frees the key? */
 686         tmp_rsa = RSA_generate_key( key_length, RSA_F4, NULL, NULL );
 687
 688         if ( !tmp_rsa ) {
 689                 Debug( LDAP_DEBUG_ANY, "TLS: Failed to generate temporary %d-bit %s RSA key\n",
 690                        key_length, is_export ? "export" : "domestic", 0 );
 691                 return NULL;
 692         }
 693         return tmp_rsa;
 694 }
 695
 696 static DH *
 697 tls_tmp_dh_cb( SSL *ssl, int is_export, int key_length )
 698 {
 699         return NULL;
 700 }
 701
 702 #else
 703 static int dummy;
 704 #endif