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

   1 /*
   2  * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
   3  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   4  *
   5  * tls.c - Handle tls/ssl using SSLeay or OpenSSL.
   6  */
   7
   8 #include "portable.h"
   9
  10 #ifdef HAVE_TLS
  11
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14
  15 #include <ac/errno.h>
  16 #include <ac/socket.h>
  17 #include <ac/string.h>
  18 #include <ac/time.h>
  19 #include <ac/unistd.h>
  20
  21 #include "ldap-int.h"
  22
  23 #ifdef LDAP_R_COMPILE
  24 #include <ldap_pvt_thread.h>
  25 #endif
  26
  27 #ifdef HAVE_SSL_H
  28 #include <ssl.h>
  29 #endif
  30
  31 static char *tls_opt_certfile = NULL;
  32 static char *tls_opt_keyfile = NULL;
  33 static char *tls_opt_cacertfile = NULL;
  34 static char *tls_opt_cacertdir = NULL;
  35 static int  tls_opt_require_cert = 0;
  36
  37 #define HAS_TLS( sb ) ((sb)->sb_io==&tls_io)
  38
  39 static int tls_setup( Sockbuf *sb, void *arg );
  40 static int tls_remove( Sockbuf *sb );
  41 static ber_slen_t tls_read( Sockbuf *sb, void *buf, ber_len_t len );
  42 static ber_slen_t tls_write( Sockbuf *sb, void *buf, ber_len_t len );
  43 static int tls_close( Sockbuf *sb );
  44
  45 static Sockbuf_IO tls_io=
  46 {
  47    tls_setup,
  48    tls_remove,
  49    tls_read,
  50    tls_write,
  51    tls_close
  52 };
  53
  54 static int tls_verify_cb( int ok, X509_STORE_CTX *ctx );
  55
  56 static SSL_CTX *tls_def_ctx = NULL;
  57
  58 #ifdef LDAP_R_COMPILE
  59 /*
  60  * provide mutexes for the SSLeay library.
  61  */
  62 static ldap_pvt_thread_mutex_t  tls_mutexes[CRYPTO_NUM_LOCKS];
  63
  64 static void tls_locking_cb( int mode, int type, const char *file, int line )
  65 {
  66         if ( mode & CRYPTO_LOCK ) {
  67                 ldap_pvt_thread_mutex_lock( tls_mutexes+type );
  68         } else {
  69                 ldap_pvt_thread_mutex_unlock( tls_mutexes+type );
  70         }
  71 }
  72
  73 /*
  74  * an extra mutex for the default ctx.
  75  */
  76
  77 static ldap_pvt_thread_mutex_t tls_def_ctx_mutex;
  78
  79 static void tls_init_threads( void )
  80 {
  81         int i;
  82
  83         for( i=0; i< CRYPTO_NUM_LOCKS ; i++ ) {
  84                 ldap_pvt_thread_mutex_init( tls_mutexes+i );
  85         }
  86         CRYPTO_set_locking_callback( tls_locking_cb );
  87         /* FIXME: the thread id should be added somehow... */
  88
  89         ldap_pvt_thread_mutex_init( &tls_def_ctx_mutex );
  90 }
  91 #endif /* LDAP_R_COMPILE */
  92
  93 /*
  94  * Initialize tls system. Should be called only once.
  95  */
  96 int
  97 ldap_pvt_tls_init( void )
  98 {
  99         static int tls_initialized = 0;
 100
 101         if ( tls_initialized )
 102                 return -1;
 103 #ifdef LDAP_R_COMPILE
 104         tls_init_threads();
 105 #endif
 106         SSL_load_error_strings();
 107         SSLeay_add_ssl_algorithms();
 108         return 0;
 109 }
 110
 111 /*
 112  * initialize the default context
 113  */
 114 int
 115 ldap_pvt_tls_init_def_ctx( void )
 116 {
 117 #ifdef LDAP_R_COMPILE
 118         ldap_pvt_thread_mutex_lock( &tls_def_ctx_mutex );
 119 #endif
 120         if ( tls_def_ctx == NULL ) {
 121                 tls_def_ctx = SSL_CTX_new( TLSv1_method() );
 122                 if ( tls_def_ctx == NULL ) {
 123                         Debug( LDAP_DEBUG_ANY,
 124                                "TLS: could not allocate default ctx.\n",0,0,0);
 125                         goto error_exit;
 126                 }
 127                 if ( !SSL_CTX_load_verify_locations( tls_def_ctx,
 128                                                      tls_opt_cacertfile,
 129                                                      tls_opt_cacertdir ) ||
 130                      !SSL_CTX_set_default_verify_paths( tls_def_ctx ) ) {
 131                         Debug( LDAP_DEBUG_ANY,
 132                 "TLS: could not load verify locations (file:`%s',dir:`%s').\n",
 133                                tls_opt_cacertfile,tls_opt_cacertdir,0);
 134                         goto error_exit;
 135                 }
 136                 if ( tls_opt_keyfile &&
 137                      !SSL_CTX_use_PrivateKey_file( tls_def_ctx,
 138                                                    tls_opt_keyfile,
 139                                                    SSL_FILETYPE_PEM ) ) {
 140                         Debug( LDAP_DEBUG_ANY,
 141                                "TLS: could not use key file `%s'.\n",
 142                                tls_opt_keyfile,0,0);
 143                         goto error_exit;
 144                 }
 145                 if ( tls_opt_certfile &&
 146                      !SSL_CTX_use_certificate_file( tls_def_ctx,
 147                                                     tls_opt_certfile,
 148                                                     SSL_FILETYPE_PEM ) ) {
 149                         Debug( LDAP_DEBUG_ANY,
 150                                "TLS: could not use certificate `%s'.\n",
 151                                tls_opt_certfile,0,0);
 152                         goto error_exit;
 153                 }
 154                 SSL_CTX_set_verify( tls_def_ctx, (tls_opt_require_cert) ?
 155                         (SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT) :
 156                         SSL_VERIFY_PEER, tls_verify_cb );
 157         }
 158 #ifdef LDAP_R_COMPILE
 159         ldap_pvt_thread_mutex_unlock( &tls_def_ctx_mutex );
 160 #endif
 161         return 0;
 162 error_exit:
 163 #ifdef LDAP_R_COMPILE
 164         ldap_pvt_thread_mutex_unlock( &tls_def_ctx_mutex );
 165 #endif
 166         return -1;
 167 }
 168
 169 static SSL *
 170 alloc_handle( Sockbuf *sb, void *ctx_arg )
 171 {
 172         int     err;
 173         SSL_CTX *ctx;
 174         SSL     *ssl;
 175
 176         if ( ctx_arg ) {
 177                 ctx = (SSL_CTX *) ctx_arg;
 178         } else {
 179                 if ( ldap_pvt_tls_init_def_ctx() < 0 )
 180                         return NULL;
 181                 ctx=tls_def_ctx;
 182         }
 183
 184         ssl = SSL_new( ctx );
 185         if ( ssl == NULL ) {
 186                 Debug( LDAP_DEBUG_ANY,"TLS: can't create ssl handle.\n",0,0,0);
 187                 return NULL;
 188         }
 189
 190         SSL_set_fd( ssl, ber_pvt_sb_get_desc( sb ) );
 191         return ssl;
 192 }
 193
 194 static void
 195 update_flags( Sockbuf *sb, SSL * ssl )
 196 {
 197         sb->sb_trans_needs_read  = SSL_want_read(ssl) ? 1 : 0;
 198         sb->sb_trans_needs_write = SSL_want_write(ssl) ? 1 : 0;
 199 }
 200
 201 /*
 202  * Call this to do a TLS connect on a sockbuf. ctx_arg can be
 203  * a SSL_CTX * or NULL, in which case the default ctx is used.
 204  *
 205  * Return value:
 206  *
 207  *  0 - Success. Connection is ready for communication.
 208  * <0 - Error. Can't create a TLS stream.
 209  * >0 - Partial success.
 210  *        Do a select (using information from lber_pvt_sb_needs_{read,write}
 211  *              and call again.
 212  */
 213
 214 int
 215 ldap_pvt_tls_connect( Sockbuf *sb, void *ctx_arg )
 216 {
 217         int     err;
 218         SSL     *ssl;
 219
 220         if ( HAS_TLS( sb ) ) {
 221                 ssl = (SSL *) sb->sb_iodata;
 222         } else {
 223                 ssl = alloc_handle( sb, ctx_arg );
 224                 if ( ssl == NULL )
 225                         return -1;
 226                 ber_pvt_sb_clear_io( sb );
 227                 ber_pvt_sb_set_io( sb, &tls_io, (void *)ssl );
 228         }
 229
 230         err = SSL_connect( ssl );
 231
 232         if ( err <= 0 ) {
 233                 if (
 234 #ifdef EWOULDBLOCK
 235                     (errno==EWOULDBLOCK) ||
 236 #endif
 237 #ifdef EAGAIN
 238                     (errno==EAGAIN) ||
 239 #endif
 240                     (0)) {
 241                         update_flags( sb, ssl );
 242                         return 1;
 243                 }
 244                 Debug( LDAP_DEBUG_ANY,"TLS: can't connect.\n",0,0,0);
 245                 ber_pvt_sb_clear_io( sb );
 246                 ber_pvt_sb_set_io( sb, &ber_pvt_sb_io_tcp, NULL );
 247                 return -1;
 248         }
 249         return 0;
 250 }
 251
 252 /*
 253  * Call this to do a TLS accept on a sockbuf.
 254  * Everything else is the same as with tls_connect.
 255  */
 256 int
 257 ldap_pvt_tls_accept( Sockbuf *sb, void *ctx_arg )
 258 {
 259         int     err;
 260         SSL     *ssl;
 261
 262         if ( HAS_TLS( sb ) ) {
 263                 ssl = (SSL *) sb->sb_iodata;
 264         } else {
 265                 ssl = alloc_handle( sb, ctx_arg );
 266                 if ( ssl == NULL )
 267                         return -1;
 268                 ber_pvt_sb_clear_io( sb );
 269                 ber_pvt_sb_set_io( sb, &tls_io, (void *)ssl );
 270         }
 271
 272         err = SSL_accept( ssl );
 273
 274         if ( err <= 0 ) {
 275                 if (
 276 #ifdef EWOULDBLOCK
 277                     (errno==EWOULDBLOCK) ||
 278 #endif
 279 #ifdef EAGAIN
 280                     (errno==EAGAIN) ||
 281 #endif
 282                     (0)) {
 283                         update_flags( sb, ssl );
 284                         return 1;
 285                 }
 286                 Debug( LDAP_DEBUG_ANY,"TLS: can't accept.\n",0,0,0 );
 287                 ber_pvt_sb_clear_io( sb );
 288                 ber_pvt_sb_set_io( sb, &ber_pvt_sb_io_tcp, NULL );
 289                 return -1;
 290         }
 291         return 0;
 292 }
 293
 294 const char *
 295 ldap_pvt_tls_get_peer( LDAP *ld )
 296 {
 297 }
 298
 299 const char *
 300 ldap_pvt_tls_get_peer_issuer( LDAP *ld )
 301 {
 302 }
 303
 304 int
 305 ldap_pvt_tls_config( struct ldapoptions *lo, int option, const char *arg )
 306 {
 307         int i;
 308
 309         switch( option ) {
 310         case LDAP_OPT_X_TLS_CACERTFILE:
 311         case LDAP_OPT_X_TLS_CACERTDIR:
 312         case LDAP_OPT_X_TLS_CERTFILE:
 313         case LDAP_OPT_X_TLS_KEYFILE:
 314                 return ldap_pvt_tls_set_option( NULL, option, (void *) arg );
 315         case LDAP_OPT_X_TLS_REQUIRE_CERT:
 316                 i = ( ( strcasecmp( arg, "on" ) == 0 ) ||
 317                       ( strcasecmp( arg, "yes" ) == 0) ||
 318                       ( strcasecmp( arg, "true" ) == 0 ) );
 319                 return ldap_pvt_tls_set_option( NULL, option, (void *) &i );
 320         case LDAP_OPT_X_TLS:
 321                 if ( strcasecmp( arg, "never" ) == 0 )
 322                         return ldap_pvt_tls_set_option( lo, option,
 323                                 LDAP_OPT_X_TLS_NEVER );
 324                 if ( strcasecmp( arg, "demand" ) == 0 )
 325                         return ldap_pvt_tls_set_option( lo, option,
 326                                 LDAP_OPT_X_TLS_DEMAND );
 327                 if ( strcasecmp( arg, "allow" ) == 0 )
 328                         return ldap_pvt_tls_set_option( lo, option,
 329                                 LDAP_OPT_X_TLS_ALLOW );
 330                 if ( strcasecmp( arg, "try" ) == 0 )
 331                         return ldap_pvt_tls_set_option( lo, option,
 332                                 LDAP_OPT_X_TLS_TRY );
 333                 if ( strcasecmp( arg, "hard" ) == 0 )
 334                         return ldap_pvt_tls_set_option( lo, option,
 335                                 LDAP_OPT_X_TLS_HARD );
 336                 return -1;
 337         default:
 338                 return -1;
 339         }
 340 }
 341
 342 int
 343 ldap_pvt_tls_get_option( struct ldapoptions *lo, int option, void *arg )
 344 {
 345         switch( option ) {
 346         case LDAP_OPT_X_TLS:
 347                 *(int *)arg = lo->ldo_tls_mode;
 348                 break;
 349         case LDAP_OPT_X_TLS_CERT:
 350                 if ( lo == NULL )
 351                         arg = (void *) tls_def_ctx;
 352                 else
 353                         arg = lo->ldo_tls_ctx;
 354                 break;
 355         case LDAP_OPT_X_TLS_CACERTFILE:
 356                 *(char **)arg = tls_opt_cacertfile ?
 357                         strdup( tls_opt_cacertfile ) : NULL;
 358                 break;
 359         case LDAP_OPT_X_TLS_CACERTDIR:
 360                 *(char **)arg = tls_opt_cacertdir ?
 361                         strdup( tls_opt_cacertdir ) : NULL;
 362                 break;
 363         case LDAP_OPT_X_TLS_CERTFILE:
 364                 *(char **)arg = tls_opt_certfile ?
 365                         strdup( tls_opt_certfile ) : NULL;
 366                 break;
 367         case LDAP_OPT_X_TLS_KEYFILE:
 368                 *(char **)arg = tls_opt_keyfile ?
 369                         strdup( tls_opt_keyfile ) : NULL;
 370                 break;
 371         case LDAP_OPT_X_TLS_REQUIRE_CERT:
 372                 *(int *)arg = tls_opt_require_cert;
 373                 break;
 374         default:
 375                 return -1;
 376         }
 377         return 0;
 378 }
 379
 380 int
 381 ldap_pvt_tls_set_option( struct ldapoptions *lo, int option, void *arg )
 382 {
 383         switch( option ) {
 384         case LDAP_OPT_X_TLS:
 385                 switch( *(int *) arg ) {
 386                 case LDAP_OPT_X_TLS_NEVER:
 387                 case LDAP_OPT_X_TLS_DEMAND:
 388                 case LDAP_OPT_X_TLS_ALLOW:
 389                 case LDAP_OPT_X_TLS_TRY:
 390                 case LDAP_OPT_X_TLS_HARD:
 391                         lo->ldo_tls_mode = *(int *)arg;
 392                         break;
 393                 default:
 394                         return -1;
 395                 }
 396                 break;
 397         case LDAP_OPT_X_TLS_CERT:
 398                 if ( lo == NULL )
 399                         tls_def_ctx = (SSL_CTX *) arg;
 400                 else
 401                         lo->ldo_tls_ctx = arg;
 402                 break;
 403         }
 404         if ( lo != NULL )
 405                 return -1;
 406         switch( option ) {
 407         case LDAP_OPT_X_TLS_CACERTFILE:
 408                 if ( tls_opt_cacertfile ) free( tls_opt_cacertfile );
 409                 tls_opt_cacertfile = arg ? strdup( (char *) arg ) : NULL;
 410                 break;
 411         case LDAP_OPT_X_TLS_CACERTDIR:
 412                 if ( tls_opt_cacertdir ) free( tls_opt_cacertdir );
 413                 tls_opt_cacertdir = arg ? strdup( (char *) arg ) : NULL;
 414                 break;
 415         case LDAP_OPT_X_TLS_CERTFILE:
 416                 if ( tls_opt_certfile ) free( tls_opt_certfile );
 417                 tls_opt_certfile = arg ? strdup( (char *) arg ) : NULL;
 418                 break;
 419         case LDAP_OPT_X_TLS_KEYFILE:
 420                 if ( tls_opt_keyfile ) free( tls_opt_keyfile );
 421                 tls_opt_keyfile = arg ? strdup( (char *) arg ) : NULL;
 422                 break;
 423         case LDAP_OPT_X_TLS_REQUIRE_CERT:
 424                 tls_opt_require_cert = * (int *) arg;
 425         default:
 426                 return -1;
 427         }
 428 }
 429
 430 static int
 431 tls_setup( Sockbuf *sb, void *arg )
 432 {
 433         sb->sb_iodata = arg;
 434         return 0;
 435 }
 436
 437 static int
 438 tls_remove( Sockbuf *sb )
 439 {
 440         SSL_free( (SSL *) sb->sb_iodata );
 441         return 0;
 442 }
 443
 444 static ber_slen_t
 445 tls_write( Sockbuf *sb, void *buf, ber_len_t sz )
 446 {
 447         int ret = SSL_write( (SSL *)sb->sb_iodata, buf, sz );
 448
 449         update_flags(sb, (SSL *)sb->sb_iodata );
 450         return ret;
 451 }
 452
 453 static ber_slen_t
 454 tls_read( Sockbuf *sb, void *buf, ber_len_t sz )
 455 {
 456         int ret = SSL_read( (SSL *)sb->sb_iodata, buf, sz );
 457
 458         update_flags(sb, (SSL *)sb->sb_iodata );
 459         return ret;
 460 }
 461
 462 static int
 463 tls_close( Sockbuf *sb )
 464 {
 465         tcp_close( ber_pvt_sb_get_desc( sb ) );
 466         return 0;
 467 }
 468
 469 static int
 470 tls_verify_cb( int ok, X509_STORE_CTX *ctx )
 471 {
 472         return 1;
 473 }
 474
 475 #else
 476 static int dummy;
 477 #endif