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

   1 /* tls.c - Handle tls/ssl using SSLeay, OpenSSL or GNUTLS. */
   2 /* $OpenLDAP$ */
   3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   4  *
   5  * Copyright 1998-2007 The OpenLDAP Foundation.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted only as authorized by the OpenLDAP
  10  * Public License.
  11  *
  12  * A copy of this license is available in the file LICENSE in the
  13  * top-level directory of the distribution or, alternatively, at
  14  * <http://www.OpenLDAP.org/license.html>.
  15  */
  16 /* ACKNOWLEDGEMENTS: GNUTLS support by Howard Chu
  17  */
  18
  19 #include "portable.h"
  20 #include "ldap_config.h"
  21
  22 #include <stdio.h>
  23
  24 #include <ac/stdlib.h>
  25 #include <ac/errno.h>
  26 #include <ac/socket.h>
  27 #include <ac/string.h>
  28 #include <ac/ctype.h>
  29 #include <ac/time.h>
  30 #include <ac/unistd.h>
  31 #include <ac/param.h>
  32 #include <ac/dirent.h>
  33
  34 #define HAVE_GNUTLS     1
  35 #undef HAVE_OPENSSL
  36
  37 #include "ldap-int.h"
  38
  39 #ifdef HAVE_TLS
  40
  41 #ifdef LDAP_R_COMPILE
  42 #include <ldap_pvt_thread.h>
  43 #endif
  44
  45 #ifdef HAVE_GNUTLS
  46 #include <gnutls/gnutls.h>
  47 #include <gnutls/x509.h>
  48 #include <gcrypt.h>
  49
  50 #define DH_BITS (1024)
  51
  52 #else
  53 #ifdef HAVE_OPENSSL_SSL_H
  54 #include <openssl/ssl.h>
  55 #include <openssl/x509v3.h>
  56 #include <openssl/err.h>
  57 #include <openssl/rand.h>
  58 #include <openssl/safestack.h>
  59 #elif defined( HAVE_SSL_H )
  60 #include <ssl.h>
  61 #endif
  62 #endif
  63
  64 #define HAS_TLS( sb )   ber_sockbuf_ctrl( sb, LBER_SB_OPT_HAS_IO, \
  65                                 (void *)&sb_tls_sbio )
  66
  67 /* RFC2459 minimum required set of supported attribute types
  68  * in a certificate DN
  69  */
  70 typedef struct oid_name {
  71         struct berval oid;
  72         struct berval name;
  73 } oid_name;
  74
  75 #define CN_OID  oids[0].oid.bv_val
  76
  77 static oid_name oids[] = {
  78         { BER_BVC("2.5.4.3"), BER_BVC("cn") },
  79         { BER_BVC("2.5.4.4"), BER_BVC("sn") },
  80         { BER_BVC("2.5.4.6"), BER_BVC("c") },
  81         { BER_BVC("2.5.4.7"), BER_BVC("l") },
  82         { BER_BVC("2.5.4.8"), BER_BVC("st") },
  83         { BER_BVC("2.5.4.10"), BER_BVC("o") },
  84         { BER_BVC("2.5.4.11"), BER_BVC("ou") },
  85         { BER_BVC("2.5.4.12"), BER_BVC("title") },
  86         { BER_BVC("2.5.4.41"), BER_BVC("name") },
  87         { BER_BVC("2.5.4.42"), BER_BVC("givenName") },
  88         { BER_BVC("2.5.4.43"), BER_BVC("initials") },
  89         { BER_BVC("2.5.4.44"), BER_BVC("generationQualifier") },
  90         { BER_BVC("2.5.4.46"), BER_BVC("dnQualifier") },
  91         { BER_BVC("1.2.840.113549.1.9.1"), BER_BVC("email") },
  92         { BER_BVC("0.9.2342.19200300.100.1.25"), BER_BVC("dc") },
  93         { BER_BVNULL, BER_BVNULL }
  94 };
  95
  96 #ifdef HAVE_GNUTLS
  97
  98 typedef struct tls_cipher_suite {
  99         const char *name;
 100         gnutls_kx_algorithm_t kx;
 101         gnutls_cipher_algorithm_t cipher;
 102         gnutls_mac_algorithm_t mac;
 103         gnutls_protocol_t version;
 104 } tls_cipher_suite;
 105
 106 static tls_cipher_suite *ciphers;
 107 static int n_ciphers;
 108
 109 /* sorta replacing SSL_CTX */
 110 typedef struct tls_ctx {
 111         struct ldapoptions *lo;
 112         gnutls_certificate_credentials_t cred;
 113         gnutls_dh_params_t dh_params;
 114         unsigned long verify_depth;
 115         int refcount;
 116         int *kx_list;
 117         int *cipher_list;
 118         int *mac_list;
 119 #ifdef LDAP_R_COMPILE
 120         ldap_pvt_thread_mutex_t ref_mutex;
 121 #endif
 122 } tls_ctx;
 123
 124 /* sorta replacing SSL */
 125 typedef struct tls_session {
 126         tls_ctx *ctx;
 127         gnutls_session_t session;
 128         struct berval peer_der_dn;
 129 } tls_session;
 130
 131 #ifdef LDAP_R_COMPILE
 132
 133 static int
 134 ldap_pvt_gcry_mutex_init( void **priv )
 135 {
 136         int err = 0;
 137         ldap_pvt_thread_mutex_t *lock = LDAP_MALLOC( sizeof( ldap_pvt_thread_mutex_t ));
 138
 139         if ( !lock )
 140                 err = ENOMEM;
 141         if ( !err ) {
 142                 err = ldap_pvt_thread_mutex_init( lock );
 143                 if ( err )
 144                         LDAP_FREE( lock );
 145                 else
 146                         *priv = lock;
 147         }
 148         return err;
 149 }
 150 static int
 151 ldap_pvt_gcry_mutex_destroy( void **lock )
 152 {
 153         int err = ldap_pvt_thread_mutex_destroy( *lock );
 154         LDAP_FREE( *lock );
 155         return err;
 156 }
 157 static int
 158 ldap_pvt_gcry_mutex_lock( void **lock )
 159 {
 160         return ldap_pvt_thread_mutex_lock( *lock );
 161 }
 162 static int
 163 ldap_pvt_gcry_mutex_unlock( void **lock )
 164 {
 165         return ldap_pvt_thread_mutex_unlock( *lock );
 166 }
 167
 168 static struct gcry_thread_cbs ldap_generic_thread_cbs = {
 169         GCRY_THREAD_OPTION_USER,
 170         NULL,
 171         ldap_pvt_gcry_mutex_init,
 172         ldap_pvt_gcry_mutex_destroy,
 173         ldap_pvt_gcry_mutex_lock,
 174         ldap_pvt_gcry_mutex_unlock,
 175         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
 176 };
 177
 178 static void
 179 tls_init_threads( void )
 180 {
 181         gcry_control (GCRYCTL_SET_THREAD_CBS, &ldap_generic_thread_cbs);
 182 }
 183 #endif /* LDAP_R_COMPILE */
 184
 185 void
 186 ldap_pvt_tls_ctx_free ( void *c )
 187 {
 188         int refcount;
 189         tls_ctx *ctx = c;
 190
 191 #ifdef LDAP_R_COMPILE
 192         ldap_pvt_thread_mutex_lock( &ctx->ref_mutex );
 193 #endif
 194         refcount = --ctx->refcount;
 195 #ifdef LDAP_R_COMPILE
 196         ldap_pvt_thread_mutex_unlock( &ctx->ref_mutex );
 197 #endif
 198         if ( refcount )
 199                 return;
 200         LDAP_FREE( ctx->kx_list );
 201         gnutls_certificate_free_credentials( ctx->cred );
 202         ber_memfree ( ctx );
 203 }
 204
 205 static void *
 206 tls_ctx_new ( struct ldapoptions *lo )
 207 {
 208         tls_ctx *ctx;
 209
 210         ctx = ber_memcalloc ( 1, sizeof (*ctx) );
 211         if ( ctx ) {
 212                 ctx->lo = lo;
 213                 if ( gnutls_certificate_allocate_credentials( &ctx->cred )) {
 214                         ber_memfree( ctx );
 215                         return NULL;
 216                 }
 217                 ctx->refcount = 1;
 218 #ifdef LDAP_R_COMPILE
 219                 ldap_pvt_thread_mutex_init( &ctx->ref_mutex );
 220 #endif
 221         }
 222         return ctx;
 223 }
 224
 225 static void
 226 tls_ctx_ref( tls_ctx *ctx )
 227 {
 228 #ifdef LDAP_R_COMPILE
 229         ldap_pvt_thread_mutex_lock( &ctx->ref_mutex );
 230 #endif
 231         ctx->refcount++;
 232 #ifdef LDAP_R_COMPILE
 233         ldap_pvt_thread_mutex_unlock( &ctx->ref_mutex );
 234 #endif
 235 }
 236
 237 tls_session *
 238 tls_session_new ( tls_ctx * ctx, int is_server )
 239 {
 240         tls_session *session;
 241
 242         session = ber_memcalloc ( 1, sizeof (*session) );
 243         if ( !session )
 244                 return NULL;
 245
 246         session->ctx = ctx;
 247         gnutls_init( &session->session, is_server ? GNUTLS_SERVER : GNUTLS_CLIENT );
 248         gnutls_set_default_priority( session->session );
 249         if ( ctx->kx_list ) {
 250                 gnutls_kx_set_priority( session->session, ctx->kx_list );
 251                 gnutls_cipher_set_priority( session->session, ctx->cipher_list );
 252                 gnutls_mac_set_priority( session->session, ctx->mac_list );
 253         }
 254         if ( ctx->cred )
 255                 gnutls_credentials_set( session->session, GNUTLS_CRD_CERTIFICATE, ctx->cred );
 256
 257         if ( is_server ) {
 258                 int flag = 0;
 259                 if ( ctx->lo->ldo_tls_require_cert ) {
 260                         flag = GNUTLS_CERT_REQUEST;
 261                         if ( ctx->lo->ldo_tls_require_cert == LDAP_OPT_X_TLS_DEMAND ||
 262                                 ctx->lo->ldo_tls_require_cert == LDAP_OPT_X_TLS_HARD )
 263                                 flag = GNUTLS_CERT_REQUIRE;
 264                         gnutls_certificate_server_set_request( session->session, flag );
 265                 }
 266         }
 267         return session;
 268 }
 269
 270 void
 271 tls_session_free ( tls_session * session )
 272 {
 273         ber_memfree ( session );
 274 }
 275
 276 #define tls_session_connect( ssl )      gnutls_handshake( ssl->session )
 277 #define tls_session_accept( ssl )       gnutls_handshake( ssl->session )
 278
 279 /* suites is a string of colon-separated cipher suite names. */
 280 static int
 281 tls_parse_ciphers( tls_ctx *ctx, char *suites )
 282 {
 283         char *ptr, *end;
 284         int i, j, len, num;
 285         int *list, nkx = 0, ncipher = 0, nmac = 0;
 286         int *kx, *cipher, *mac;
 287
 288         num = 0;
 289         ptr = suites;
 290         do {
 291                 end = strchr(ptr, ':');
 292                 if ( end )
 293                         len = end - ptr;
 294                 else
 295                         len = strlen(ptr);
 296                 for (i=0; i<n_ciphers; i++) {
 297                         if ( !strncasecmp( ciphers[i].name, ptr, len )) {
 298                                 num++;
 299                                 break;
 300                         }
 301                 }
 302                 if ( i == n_ciphers ) {
 303                         /* unrecognized cipher suite */
 304                         return -1;
 305                 }
 306         } while (end);
 307
 308         /* Space for all 3 lists */
 309         list = LDAP_MALLOC( (num+1) * sizeof(int) * 3 );
 310         if ( !list )
 311                 return -1;
 312         kx = list;
 313         cipher = kx+num+1;
 314         mac = cipher+num+1;
 315
 316         ptr = suites;
 317         do {
 318                 end = strchr(ptr, ':');
 319                 if ( end )
 320                         len = end - ptr;
 321                 else
 322                         len = strlen(ptr);
 323                 for (i=0; i<n_ciphers; i++) {
 324                         /* For each cipher suite, insert its algorithms into
 325                          * their respective priority lists. Make sure they
 326                          * only appear once in each list.
 327                          */
 328                         if ( !strncasecmp( ciphers[i].name, ptr, len )) {
 329                                 for (j=0; j<nkx; j++)
 330                                         if ( kx[j] == ciphers[i].kx )
 331                                                 break;
 332                                 if ( j == nkx )
 333                                         kx[nkx++] = ciphers[i].kx;
 334                                 for (j=0; j<ncipher; j++)
 335                                         if ( cipher[j] == ciphers[i].cipher )
 336                                                 break;
 337                                 if ( j == ncipher )
 338                                         cipher[ncipher++] = ciphers[i].cipher;
 339                                 for (j=0; j<nmac; j++)
 340                                         if ( mac[j] == ciphers[i].mac )
 341                                                 break;
 342                                 if ( j == nmac )
 343                                         mac[nmac++] = ciphers[i].mac;
 344                                 break;
 345                         }
 346                 }
 347         } while (end);
 348         kx[nkx] = 0;
 349         cipher[ncipher] = 0;
 350         mac[nmac] = 0;
 351         ctx->kx_list = kx;
 352         ctx->cipher_list = cipher;
 353         ctx->mac_list = mac;
 354         return 0;
 355 }
 356
 357 #else /* OpenSSL */
 358
 359 typedef SSL_CTX tls_ctx;
 360 typedef SSL tls_session;
 361
 362 static int  tls_opt_trace = 1;
 363 static char *tls_opt_randfile = NULL;
 364
 365 static void tls_report_error( void );
 366
 367 static void tls_info_cb( const SSL *ssl, int where, int ret );
 368 static int tls_verify_cb( int ok, X509_STORE_CTX *ctx );
 369 static int tls_verify_ok( int ok, X509_STORE_CTX *ctx );
 370 static RSA * tls_tmp_rsa_cb( SSL *ssl, int is_export, int key_length );
 371
 372 static DH * tls_tmp_dh_cb( SSL *ssl, int is_export, int key_length );
 373
 374 typedef struct dhplist {
 375         struct dhplist *next;
 376         int keylength;
 377         DH *param;
 378 } dhplist;
 379
 380 static dhplist *dhparams;
 381
 382 static int tls_seed_PRNG( const char *randfile );
 383
 384 #ifdef LDAP_R_COMPILE
 385 /*
 386  * provide mutexes for the SSLeay library.
 387  */
 388 static ldap_pvt_thread_mutex_t  tls_mutexes[CRYPTO_NUM_LOCKS];
 389
 390 static void tls_locking_cb( int mode, int type, const char *file, int line )
 391 {
 392         if ( mode & CRYPTO_LOCK ) {
 393                 ldap_pvt_thread_mutex_lock( &tls_mutexes[type] );
 394         } else {
 395                 ldap_pvt_thread_mutex_unlock( &tls_mutexes[type] );
 396         }
 397 }
 398
 399 static void tls_init_threads( void )
 400 {
 401         int i;
 402
 403         for( i=0; i< CRYPTO_NUM_LOCKS ; i++ ) {
 404                 ldap_pvt_thread_mutex_init( &tls_mutexes[i] );
 405         }
 406         CRYPTO_set_locking_callback( tls_locking_cb );
 407         CRYPTO_set_id_callback( ldap_pvt_thread_self );
 408         /* FIXME: CRYPTO_set_id_callback only works when ldap_pvt_thread_t
 409          * is an integral type that fits in an unsigned long
 410          */
 411 }
 412 #endif /* LDAP_R_COMPILE */
 413
 414 void
 415 ldap_pvt_tls_ctx_free ( void *c )
 416 {
 417
 418         SSL_CTX_free( c );
 419 }
 420
 421 static void *
 422 tls_ctx_new( struct ldapoptions *lo )
 423 {
 424         return SSL_CTX_new( SSLv23_method() );
 425 }
 426
 427 static void
 428 tls_ctx_ref( void *c )
 429 {
 430         SSL_CTX *ctx = c;
 431         CRYPTO_add( &ctx->references, 1, CRYPTO_LOCK_SSL_CTX );
 432 }
 433
 434 static tls_session *
 435 tls_session_new( tls_ctx *ctx, int is_server )
 436 {
 437         return SSL_new( ctx );
 438 }
 439
 440 #define tls_session_connect( ssl )      SSL_connect( ssl )
 441 #define tls_session_accept( ssl )       SSL_accept( ssl )
 442
 443 static STACK_OF(X509_NAME) *
 444 get_ca_list( char * bundle, char * dir )
 445 {
 446         STACK_OF(X509_NAME) *ca_list = NULL;
 447
 448         if ( bundle ) {
 449                 ca_list = SSL_load_client_CA_file( bundle );
 450         }
 451 #if defined(HAVE_DIRENT_H) || defined(dirent)
 452         if ( dir ) {
 453                 int freeit = 0;
 454
 455                 if ( !ca_list ) {
 456                         ca_list = sk_X509_NAME_new_null();
 457                         freeit = 1;
 458                 }
 459                 if ( !SSL_add_dir_cert_subjects_to_stack( ca_list, dir ) &&
 460                         freeit ) {
 461                         sk_X509_NAME_free( ca_list );
 462                         ca_list = NULL;
 463                 }
 464         }
 465 #endif
 466         return ca_list;
 467 }
 468
 469 #endif /* HAVE_GNUTLS */
 470
 471 #ifdef LDAP_R_COMPILE
 472 /*
 473  * an extra mutex for the default ctx.
 474  */
 475 static ldap_pvt_thread_mutex_t tls_def_ctx_mutex;
 476 #endif
 477
 478 void
 479 ldap_int_tls_destroy( struct ldapoptions *lo )
 480 {
 481         if ( lo->ldo_tls_ctx ) {
 482                 ldap_pvt_tls_ctx_free( lo->ldo_tls_ctx );
 483                 lo->ldo_tls_ctx = NULL;
 484         }
 485
 486         if ( lo->ldo_tls_certfile ) {
 487                 LDAP_FREE( lo->ldo_tls_certfile );
 488                 lo->ldo_tls_certfile = NULL;
 489         }
 490         if ( lo->ldo_tls_keyfile ) {
 491                 LDAP_FREE( lo->ldo_tls_keyfile );
 492                 lo->ldo_tls_keyfile = NULL;
 493         }
 494         if ( lo->ldo_tls_dhfile ) {
 495                 LDAP_FREE( lo->ldo_tls_dhfile );
 496                 lo->ldo_tls_dhfile = NULL;
 497         }
 498         if ( lo->ldo_tls_cacertfile ) {
 499                 LDAP_FREE( lo->ldo_tls_cacertfile );
 500                 lo->ldo_tls_cacertfile = NULL;
 501         }
 502         if ( lo->ldo_tls_cacertdir ) {
 503                 LDAP_FREE( lo->ldo_tls_cacertdir );
 504                 lo->ldo_tls_cacertdir = NULL;
 505         }
 506         if ( lo->ldo_tls_ciphersuite ) {
 507                 LDAP_FREE( lo->ldo_tls_ciphersuite );
 508                 lo->ldo_tls_ciphersuite = NULL;
 509         }
 510 #ifdef HAVE_GNUTLS
 511         if ( lo->ldo_tls_crlfile ) {
 512                 LDAP_FREE( lo->ldo_tls_crlfile );
 513                 lo->ldo_tls_crlfile = NULL;
 514         }
 515 #endif
 516 }
 517
 518 /*
 519  * Tear down the TLS subsystem. Should only be called once.
 520  */
 521 void
 522 ldap_pvt_tls_destroy( void )
 523 {
 524         struct ldapoptions *lo = LDAP_INT_GLOBAL_OPT();
 525
 526         ldap_int_tls_destroy( lo );
 527
 528 #ifdef HAVE_GNUTLS
 529         LDAP_FREE( ciphers );
 530         ciphers = NULL;
 531
 532         gnutls_global_deinit();
 533 #else
 534         EVP_cleanup();
 535         ERR_remove_state(0);
 536         ERR_free_strings();
 537
 538         if ( tls_opt_randfile ) {
 539                 LDAP_FREE( tls_opt_randfile );
 540                 tls_opt_randfile = NULL;
 541         }
 542 #endif
 543 }
 544
 545 /*
 546  * Initialize TLS subsystem. Should be called only once.
 547  */
 548 int
 549 ldap_pvt_tls_init( void )
 550 {
 551         static int tls_initialized = 0;
 552
 553         if ( tls_initialized++ ) return 0;
 554
 555 #ifdef LDAP_R_COMPILE
 556         tls_init_threads();
 557         ldap_pvt_thread_mutex_init( &tls_def_ctx_mutex );
 558 #endif
 559
 560 #ifdef HAVE_GNUTLS
 561         gnutls_global_init ();
 562
 563         /* GNUtls cipher suite handling: The library ought to parse suite
 564          * names for us, but it doesn't. It will return a list of suite names
 565          * that it supports, so we can do parsing ourselves. It ought to tell
 566          * us how long the list is, but it doesn't do that either, so we just
 567          * have to count it manually...
 568          */
 569         {
 570                 int i = 0;
 571                 tls_cipher_suite *ptr, tmp;
 572                 char cs_id[2];
 573
 574                 while ( gnutls_cipher_suite_info( i, cs_id, &tmp.kx, &tmp.cipher,
 575                         &tmp.mac, &tmp.version ))
 576                         i++;
 577                 n_ciphers = i;
 578
 579                 /* Store a copy */
 580                 ciphers = LDAP_MALLOC(n_ciphers * sizeof(tls_cipher_suite));
 581                 if ( !ciphers )
 582                         return -1;
 583                 for ( i=0; i<n_ciphers; i++ ) {
 584                         ciphers[i].name = gnutls_cipher_suite_info( i, cs_id,
 585                                 &ciphers[i].kx, &ciphers[i].cipher, &ciphers[i].mac,
 586                                 &ciphers[i].version );
 587                 }
 588         }
 589
 590 #else /* !HAVE_GNUTLS */
 591
 592 #ifdef HAVE_EBCDIC
 593         {
 594                 char *file = LDAP_STRDUP( tls_opt_randfile );
 595                 if ( file ) __atoe( file );
 596                 (void) tls_seed_PRNG( file );
 597                 LDAP_FREE( file );
 598         }
 599 #else
 600         (void) tls_seed_PRNG( tls_opt_randfile );
 601 #endif
 602
 603         SSL_load_error_strings();
 604         SSLeay_add_ssl_algorithms();
 605
 606         /* FIXME: mod_ssl does this */
 607         X509V3_add_standard_extensions();
 608
 609 #endif /* HAVE_GNUTLS */
 610         return 0;
 611 }
 612
 613 /*
 614  * initialize a new TLS context
 615  */
 616 static int
 617 ldap_int_tls_init_ctx( struct ldapoptions *lo, int is_server )
 618 {
 619         int i, rc = 0;
 620         char *ciphersuite = lo->ldo_tls_ciphersuite;
 621         char *cacertfile = lo->ldo_tls_cacertfile;
 622         char *cacertdir = lo->ldo_tls_cacertdir;
 623         char *certfile = lo->ldo_tls_certfile;
 624         char *keyfile = lo->ldo_tls_keyfile;
 625 #ifdef HAVE_GNUTLS
 626         char *crlfile = lo->ldo_tls_crlfile;
 627 #else
 628         char *dhfile = lo->ldo_tls_dhfile;
 629 #endif
 630
 631         if ( lo->ldo_tls_ctx )
 632                 return 0;
 633
 634         ldap_pvt_tls_init();
 635
 636         if ( is_server && !certfile && !keyfile && !cacertfile && !cacertdir ) {
 637                 /* minimum configuration not provided */
 638                 return LDAP_NOT_SUPPORTED;
 639         }
 640
 641 #ifdef HAVE_EBCDIC
 642         /* This ASCII/EBCDIC handling is a real pain! */
 643         if ( ciphersuite ) {
 644                 ciphersuite = LDAP_STRDUP( ciphersuite );
 645                 __atoe( ciphersuite );
 646         }
 647         if ( cacertfile ) {
 648                 cacertfile = LDAP_STRDUP( cacertfile );
 649                 __atoe( cacertfile );
 650         }
 651         if ( certfile ) {
 652                 certfile = LDAP_STRDUP( certfile );
 653                 __atoe( certfile );
 654         }
 655         if ( keyfile ) {
 656                 keyfile = LDAP_STRDUP( keyfile );
 657                 __atoe( keyfile );
 658         }
 659 #ifdef HAVE_GNUTLS
 660         if ( crlfile ) {
 661                 crlfile = LDAP_STRDUP( crlfile );
 662                 __atoe( crlfile );
 663         }
 664 #else
 665         if ( cacertdir ) {
 666                 cacertdir = LDAP_STRDUP( cacertdir );
 667                 __atoe( cacertdir );
 668         }
 669         if ( dhfile ) {
 670                 dhfile = LDAP_STRDUP( dhfile );
 671                 __atoe( dhfile );
 672         }
 673 #endif
 674 #endif
 675         lo->ldo_tls_ctx = tls_ctx_new( lo );
 676         if ( lo->ldo_tls_ctx == NULL ) {
 677 #ifdef HAVE_GNUTLS
 678                 Debug( LDAP_DEBUG_ANY,
 679                    "TLS: could not allocate default ctx.\n",
 680                         0,0,0);
 681 #else
 682                 Debug( LDAP_DEBUG_ANY,
 683                    "TLS: could not allocate default ctx (%lu).\n",
 684                         ERR_peek_error(),0,0);
 685 #endif
 686                 rc = -1;
 687                 goto error_exit;
 688         }
 689
 690 #ifdef HAVE_GNUTLS
 691         if ( lo->ldo_tls_ciphersuite &&
 692                 tls_parse_ciphers( lo->ldo_tls_ctx,
 693                         ciphersuite )) {
 694                 Debug( LDAP_DEBUG_ANY,
 695                            "TLS: could not set cipher list %s.\n",
 696                            lo->ldo_tls_ciphersuite, 0, 0 );
 697                 rc = -1;
 698                 goto error_exit;
 699         }
 700
 701         if (lo->ldo_tls_cacertdir != NULL) {
 702                 Debug( LDAP_DEBUG_ANY,
 703                        "TLS: warning: cacertdir not implemented for gnutls\n",
 704                        NULL, NULL, NULL );
 705         }
 706
 707         if (lo->ldo_tls_cacertfile != NULL) {
 708                 rc = gnutls_certificate_set_x509_trust_file(
 709                         ((tls_ctx*) lo->ldo_tls_ctx)->cred,
 710                         cacertfile,
 711                         GNUTLS_X509_FMT_PEM );
 712                 if ( rc < 0 ) goto error_exit;
 713         }
 714
 715         if ( lo->ldo_tls_certfile && lo->ldo_tls_keyfile ) {
 716                 rc = gnutls_certificate_set_x509_key_file(
 717                         ((tls_ctx*) lo->ldo_tls_ctx)->cred,
 718                         certfile,
 719                         keyfile,
 720                         GNUTLS_X509_FMT_PEM );
 721                 if ( rc ) goto error_exit;
 722         } else if ( lo->ldo_tls_certfile || lo->ldo_tls_keyfile ) {
 723                 Debug( LDAP_DEBUG_ANY,
 724                        "TLS: only one of certfile and keyfile specified\n",
 725                        NULL, NULL, NULL );
 726                 rc = 1;
 727                 goto error_exit;
 728         }
 729
 730         if ( lo->ldo_tls_dhfile ) {
 731                 Debug( LDAP_DEBUG_ANY,
 732                        "TLS: warning: ignoring dhfile\n",
 733                        NULL, NULL, NULL );
 734         }
 735
 736         if ( lo->ldo_tls_crlfile ) {
 737                 rc = gnutls_certificate_set_x509_crl_file(
 738                         ((tls_ctx*) lo->ldo_tls_ctx)->cred,
 739                         crlfile,
 740                         GNUTLS_X509_FMT_PEM );
 741                 if ( rc < 0 ) goto error_exit;
 742         }
 743         if ( is_server ) {
 744                 gnutls_dh_params_init (&((tls_ctx*)
 745                                         lo->ldo_tls_ctx)->dh_params);
 746                 gnutls_dh_params_generate2 (((tls_ctx*)
 747                                                  lo->ldo_tls_ctx)->dh_params,
 748                                                 DH_BITS);
 749         }
 750
 751 #else /* !HAVE_GNUTLS */
 752
 753         if ( is_server ) {
 754                 SSL_CTX_set_session_id_context( lo->ldo_tls_ctx,
 755                         (const unsigned char *) "OpenLDAP", sizeof("OpenLDAP")-1 );
 756         }
 757
 758         if ( lo->ldo_tls_ciphersuite &&
 759                 !SSL_CTX_set_cipher_list( lo->ldo_tls_ctx, ciphersuite ) )
 760         {
 761                 Debug( LDAP_DEBUG_ANY,
 762                            "TLS: could not set cipher list %s.\n",
 763                            lo->ldo_tls_ciphersuite, 0, 0 );
 764                 tls_report_error();
 765                 rc = -1;
 766                 goto error_exit;
 767         }
 768
 769         if (lo->ldo_tls_cacertfile != NULL || lo->ldo_tls_cacertdir != NULL) {
 770                 if ( !SSL_CTX_load_verify_locations( lo->ldo_tls_ctx,
 771                                 cacertfile, cacertdir ) ||
 772                         !SSL_CTX_set_default_verify_paths( lo->ldo_tls_ctx ) )
 773                 {
 774                         Debug( LDAP_DEBUG_ANY, "TLS: "
 775                                 "could not load verify locations (file:`%s',dir:`%s').\n",
 776                                 lo->ldo_tls_cacertfile ? lo->ldo_tls_cacertfile : "",
 777                                 lo->ldo_tls_cacertdir ? lo->ldo_tls_cacertdir : "",
 778                                 0 );
 779                         tls_report_error();
 780                         rc = -1;
 781                         goto error_exit;
 782                 }
 783
 784                 if ( is_server ) {
 785                         STACK_OF(X509_NAME) *calist;
 786                         /* List of CA names to send to a client */
 787                         calist = get_ca_list( cacertfile, cacertdir );
 788                         if ( !calist ) {
 789                                 Debug( LDAP_DEBUG_ANY, "TLS: "
 790                                         "could not load client CA list (file:`%s',dir:`%s').\n",
 791                                         lo->ldo_tls_cacertfile ? lo->ldo_tls_cacertfile : "",
 792                                         lo->ldo_tls_cacertdir ? lo->ldo_tls_cacertdir : "",
 793                                         0 );
 794                                 tls_report_error();
 795                                 rc = -1;
 796                                 goto error_exit;
 797                         }
 798
 799                         SSL_CTX_set_client_CA_list( lo->ldo_tls_ctx, calist );
 800                 }
 801         }
 802
 803         if ( lo->ldo_tls_certfile &&
 804                 !SSL_CTX_use_certificate_file( lo->ldo_tls_ctx,
 805                         certfile, SSL_FILETYPE_PEM ) )
 806         {
 807                 Debug( LDAP_DEBUG_ANY,
 808                         "TLS: could not use certificate `%s'.\n",
 809                         lo->ldo_tls_certfile,0,0);
 810                 tls_report_error();
 811                 rc = -1;
 812                 goto error_exit;
 813         }
 814
 815         /* Key validity is checked automatically if cert has already been set */
 816         if ( lo->ldo_tls_keyfile &&
 817                 !SSL_CTX_use_PrivateKey_file( lo->ldo_tls_ctx,
 818                         keyfile, SSL_FILETYPE_PEM ) )
 819         {
 820                 Debug( LDAP_DEBUG_ANY,
 821                         "TLS: could not use key file `%s'.\n",
 822                         lo->ldo_tls_keyfile,0,0);
 823                 tls_report_error();
 824                 rc = -1;
 825                 goto error_exit;
 826         }
 827
 828         if ( lo->ldo_tls_dhfile ) {
 829                 DH *dh = NULL;
 830                 BIO *bio;
 831                 dhplist *p;
 832
 833                 if (( bio=BIO_new_file( dhfile,"r" )) == NULL ) {
 834                         Debug( LDAP_DEBUG_ANY,
 835                                 "TLS: could not use DH parameters file `%s'.\n",
 836                                 lo->ldo_tls_dhfile,0,0);
 837                         tls_report_error();
 838                         rc = -1;
 839                         goto error_exit;
 840                 }
 841                 while (( dh=PEM_read_bio_DHparams( bio, NULL, NULL, NULL ))) {
 842                         p = LDAP_MALLOC( sizeof(dhplist) );
 843                         if ( p != NULL ) {
 844                                 p->keylength = DH_size( dh ) * 8;
 845                                 p->param = dh;
 846                                 p->next = dhparams;
 847                                 dhparams = p;
 848                         }
 849                 }
 850                 BIO_free( bio );
 851         }
 852
 853         if ( tls_opt_trace ) {
 854                 SSL_CTX_set_info_callback( (SSL_CTX *)lo->ldo_tls_ctx, tls_info_cb );
 855         }
 856
 857         i = SSL_VERIFY_NONE;
 858         if ( lo->ldo_tls_require_cert ) {
 859                 i = SSL_VERIFY_PEER;
 860                 if ( lo->ldo_tls_require_cert == LDAP_OPT_X_TLS_DEMAND ||
 861                          lo->ldo_tls_require_cert == LDAP_OPT_X_TLS_HARD ) {
 862                         i |= SSL_VERIFY_FAIL_IF_NO_PEER_CERT;
 863                 }
 864         }
 865
 866         SSL_CTX_set_verify( lo->ldo_tls_ctx, i,
 867                 lo->ldo_tls_require_cert == LDAP_OPT_X_TLS_ALLOW ?
 868                 tls_verify_ok : tls_verify_cb );
 869         SSL_CTX_set_tmp_rsa_callback( lo->ldo_tls_ctx, tls_tmp_rsa_cb );
 870         if ( lo->ldo_tls_dhfile ) {
 871                 SSL_CTX_set_tmp_dh_callback( lo->ldo_tls_ctx, tls_tmp_dh_cb );
 872         }
 873 #ifdef HAVE_OPENSSL_CRL
 874         if ( lo->ldo_tls_crlcheck ) {
 875                 X509_STORE *x509_s = SSL_CTX_get_cert_store( lo->ldo_tls_ctx );
 876                 if ( lo->ldo_tls_crlcheck == LDAP_OPT_X_TLS_CRL_PEER ) {
 877                         X509_STORE_set_flags( x509_s, X509_V_FLAG_CRL_CHECK );
 878                 } else if ( lo->ldo_tls_crlcheck == LDAP_OPT_X_TLS_CRL_ALL ) {
 879                         X509_STORE_set_flags( x509_s,
 880                                         X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL  );
 881                 }
 882         }
 883 #endif
 884
 885 #endif /* HAVE_GNUTLS */
 886
 887 error_exit:
 888         if ( rc == -1 && lo->ldo_tls_ctx != NULL ) {
 889                 ldap_pvt_tls_ctx_free( lo->ldo_tls_ctx );
 890                 lo->ldo_tls_ctx = NULL;
 891         }
 892 #ifdef HAVE_EBCDIC
 893         LDAP_FREE( ciphersuite );
 894         LDAP_FREE( cacertfile );
 895         LDAP_FREE( certfile );
 896         LDAP_FREE( keyfile );
 897 #ifdef HAVE_GNUTLS
 898         LDAP_FREE( crlfile );
 899 #else
 900         LDAP_FREE( cacertdir );
 901         LDAP_FREE( dhfile );
 902 #endif
 903 #endif
 904         return rc;
 905 }
 906
 907 /*
 908  * initialize the default context
 909  */
 910 int
 911 ldap_pvt_tls_init_def_ctx( int is_server )
 912 {
 913         struct ldapoptions *lo = LDAP_INT_GLOBAL_OPT();
 914         int rc;
 915 #ifdef LDAP_R_COMPILE
 916         ldap_pvt_thread_mutex_lock( &tls_def_ctx_mutex );
 917 #endif
 918         rc = ldap_int_tls_init_ctx( lo, is_server );
 919 #ifdef LDAP_R_COMPILE
 920         ldap_pvt_thread_mutex_unlock( &tls_def_ctx_mutex );
 921 #endif
 922         return rc;
 923 }
 924
 925 static tls_session *
 926 alloc_handle( void *ctx_arg, int is_server )
 927 {
 928         tls_ctx *ctx;
 929         tls_session     *ssl;
 930
 931         if ( ctx_arg ) {
 932                 ctx = ctx_arg;
 933         } else {
 934                 struct ldapoptions *lo = LDAP_INT_GLOBAL_OPT();
 935                 if ( ldap_pvt_tls_init_def_ctx( is_server ) < 0 ) return NULL;
 936                 ctx = lo->ldo_tls_ctx;
 937         }
 938
 939         ssl = tls_session_new( ctx, is_server );
 940         if ( ssl == NULL ) {
 941                 Debug( LDAP_DEBUG_ANY,"TLS: can't create ssl handle.\n",0,0,0);
 942                 return NULL;
 943         }
 944         return ssl;
 945 }
 946
 947 static int
 948 update_flags( Sockbuf *sb, tls_session * ssl, int rc )
 949 {
 950         sb->sb_trans_needs_read  = 0;
 951         sb->sb_trans_needs_write = 0;
 952
 953 #ifdef HAVE_GNUTLS
 954         if ( rc != GNUTLS_E_INTERRUPTED && rc != GNUTLS_E_AGAIN )
 955                 return 0;
 956
 957         switch (gnutls_record_get_direction (ssl->session)) {
 958         case 0:
 959                 sb->sb_trans_needs_read = 1;
 960                 return 1;
 961         case 1:
 962                 sb->sb_trans_needs_write = 1;
 963                 return 1;
 964         }
 965 #else /* !HAVE_GNUTLS */
 966         rc = SSL_get_error(ssl, rc);
 967         if (rc == SSL_ERROR_WANT_READ) {
 968                 sb->sb_trans_needs_read  = 1;
 969                 return 1;
 970
 971         } else if (rc == SSL_ERROR_WANT_WRITE) {
 972                 sb->sb_trans_needs_write = 1;
 973                 return 1;
 974
 975         } else if (rc == SSL_ERROR_WANT_CONNECT) {
 976                 return 1;
 977         }
 978 #endif /* HAVE_GNUTLS */
 979         return 0;
 980 }
 981
 982 /*
 983  * TLS support for LBER Sockbufs
 984  */
 985
 986 struct tls_data {
 987         tls_session                     *ssl;
 988         Sockbuf_IO_Desc         *sbiod;
 989 };
 990
 991 #ifdef HAVE_GNUTLS
 992
 993 static ssize_t
 994 sb_gtls_recv( gnutls_transport_ptr_t ptr, void *buf, size_t len )
 995 {
 996         struct tls_data         *p;
 997
 998         if ( buf == NULL || len <= 0 ) return 0;
 999
1000         p = (struct tls_data *)ptr;
1001
1002         if ( p == NULL || p->sbiod == NULL ) {
1003                 return 0;
1004         }
1005
1006         return LBER_SBIOD_READ_NEXT( p->sbiod, buf, len );
1007 }
1008
1009 static ssize_t
1010 sb_gtls_send( gnutls_transport_ptr_t ptr, const void *buf, size_t len )
1011 {
1012         struct tls_data         *p;
1013
1014         if ( buf == NULL || len <= 0 ) return 0;
1015
1016         p = (struct tls_data *)ptr;
1017
1018         if ( p == NULL || p->sbiod == NULL ) {
1019                 return 0;
1020         }
1021
1022         return LBER_SBIOD_WRITE_NEXT( p->sbiod, (char *)buf, len );
1023 }
1024
1025 static int
1026 sb_tls_setup( Sockbuf_IO_Desc *sbiod, void *arg )
1027 {
1028         struct tls_data         *p;
1029         tls_session     *session = arg;
1030
1031         assert( sbiod != NULL );
1032
1033         p = LBER_MALLOC( sizeof( *p ) );
1034         if ( p == NULL ) {
1035                 return -1;
1036         }
1037
1038         gnutls_transport_set_ptr( session->session, (gnutls_transport_ptr)p );
1039         gnutls_transport_set_pull_function( session->session, sb_gtls_recv );
1040         gnutls_transport_set_push_function( session->session, sb_gtls_send );
1041         p->ssl = arg;
1042         p->sbiod = sbiod;
1043         sbiod->sbiod_pvt = p;
1044         return 0;
1045 }
1046
1047 static int
1048 sb_tls_remove( Sockbuf_IO_Desc *sbiod )
1049 {
1050         struct tls_data         *p;
1051
1052         assert( sbiod != NULL );
1053         assert( sbiod->sbiod_pvt != NULL );
1054
1055         p = (struct tls_data *)sbiod->sbiod_pvt;
1056         gnutls_deinit ( p->ssl->session );
1057         LBER_FREE( p->ssl );
1058         LBER_FREE( sbiod->sbiod_pvt );
1059         sbiod->sbiod_pvt = NULL;
1060         return 0;
1061 }
1062
1063 static int
1064 sb_tls_close( Sockbuf_IO_Desc *sbiod )
1065 {
1066         struct tls_data         *p;
1067
1068         assert( sbiod != NULL );
1069         assert( sbiod->sbiod_pvt != NULL );
1070
1071         p = (struct tls_data *)sbiod->sbiod_pvt;
1072         gnutls_bye ( p->ssl->session, GNUTLS_SHUT_RDWR );
1073         return 0;
1074 }
1075
1076 static int
1077 sb_tls_ctrl( Sockbuf_IO_Desc *sbiod, int opt, void *arg )
1078 {
1079         struct tls_data         *p;
1080
1081         assert( sbiod != NULL );
1082         assert( sbiod->sbiod_pvt != NULL );
1083
1084         p = (struct tls_data *)sbiod->sbiod_pvt;
1085
1086         if ( opt == LBER_SB_OPT_GET_SSL ) {
1087                 *((tls_session **)arg) = p->ssl;
1088                 return 1;
1089
1090         } else if ( opt == LBER_SB_OPT_DATA_READY ) {
1091                 if( gnutls_record_check_pending( p->ssl->session ) > 0 ) {
1092                         return 1;
1093                 }
1094         }
1095
1096         return LBER_SBIOD_CTRL_NEXT( sbiod, opt, arg );
1097 }
1098
1099 static ber_slen_t
1100 sb_tls_read( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len)
1101 {
1102         struct tls_data         *p;
1103         ber_slen_t              ret;
1104         int                     err;
1105
1106         assert( sbiod != NULL );
1107         assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
1108
1109         p = (struct tls_data *)sbiod->sbiod_pvt;
1110
1111         ret = gnutls_record_recv ( p->ssl->session, buf, len );
1112         switch (ret) {
1113         case GNUTLS_E_INTERRUPTED:
1114         case GNUTLS_E_AGAIN:
1115                 sbiod->sbiod_sb->sb_trans_needs_read = 1;
1116                 sock_errset(EWOULDBLOCK);
1117                 ret = 0;
1118                 break;
1119         case GNUTLS_E_REHANDSHAKE:
1120                 for ( ret = gnutls_handshake ( p->ssl->session );
1121                       ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN;
1122                       ret = gnutls_handshake ( p->ssl->session ) );
1123                 sbiod->sbiod_sb->sb_trans_needs_read = 1;
1124                 ret = 0;
1125                 break;
1126         default:
1127                 sbiod->sbiod_sb->sb_trans_needs_read = 0;
1128         }
1129         return ret;
1130 }
1131
1132 static ber_slen_t
1133 sb_tls_write( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len)
1134 {
1135         struct tls_data         *p;
1136         ber_slen_t              ret;
1137         int                     err;
1138
1139         assert( sbiod != NULL );
1140         assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
1141
1142         p = (struct tls_data *)sbiod->sbiod_pvt;
1143
1144         ret = gnutls_record_send ( p->ssl->session, (char *)buf, len );
1145
1146         if ( ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN ) {
1147                 sbiod->sbiod_sb->sb_trans_needs_write = 1;
1148                 sock_errset(EWOULDBLOCK);
1149                 ret = 0;
1150         } else {
1151                 sbiod->sbiod_sb->sb_trans_needs_write = 0;
1152         }
1153         return ret;
1154 }
1155
1156 #else /* !HAVE_GNUTLS */
1157
1158 static int
1159 sb_tls_bio_create( BIO *b ) {
1160         b->init = 1;
1161         b->num = 0;
1162         b->ptr = NULL;
1163         b->flags = 0;
1164         return 1;
1165 }
1166
1167 static int
1168 sb_tls_bio_destroy( BIO *b )
1169 {
1170         if ( b == NULL ) return 0;
1171
1172         b->ptr = NULL;          /* sb_tls_remove() will free it */
1173         b->init = 0;
1174         b->flags = 0;
1175         return 1;
1176 }
1177
1178 static int
1179 sb_tls_bio_read( BIO *b, char *buf, int len )
1180 {
1181         struct tls_data         *p;
1182         int                     ret;
1183
1184         if ( buf == NULL || len <= 0 ) return 0;
1185
1186         p = (struct tls_data *)b->ptr;
1187
1188         if ( p == NULL || p->sbiod == NULL ) {
1189                 return 0;
1190         }
1191
1192         ret = LBER_SBIOD_READ_NEXT( p->sbiod, buf, len );
1193
1194         BIO_clear_retry_flags( b );
1195         if ( ret < 0 ) {
1196                 int err = sock_errno();
1197                 if ( err == EAGAIN || err == EWOULDBLOCK ) {
1198                         BIO_set_retry_read( b );
1199                 }
1200         }
1201
1202         return ret;
1203 }
1204
1205 static int
1206 sb_tls_bio_write( BIO *b, const char *buf, int len )
1207 {
1208         struct tls_data         *p;
1209         int                     ret;
1210
1211         if ( buf == NULL || len <= 0 ) return 0;
1212
1213         p = (struct tls_data *)b->ptr;
1214
1215         if ( p == NULL || p->sbiod == NULL ) {
1216                 return 0;
1217         }
1218
1219         ret = LBER_SBIOD_WRITE_NEXT( p->sbiod, (char *)buf, len );
1220
1221         BIO_clear_retry_flags( b );
1222         if ( ret < 0 ) {
1223                 int err = sock_errno();
1224                 if ( err == EAGAIN || err == EWOULDBLOCK ) {
1225                         BIO_set_retry_write( b );
1226                 }
1227         }
1228
1229         return ret;
1230 }
1231
1232 static long
1233 sb_tls_bio_ctrl( BIO *b, int cmd, long num, void *ptr )
1234 {
1235         if ( cmd == BIO_CTRL_FLUSH ) {
1236                 /* The OpenSSL library needs this */
1237                 return 1;
1238         }
1239         return 0;
1240 }
1241
1242 static int
1243 sb_tls_bio_gets( BIO *b, char *buf, int len )
1244 {
1245         return -1;
1246 }
1247
1248 static int
1249 sb_tls_bio_puts( BIO *b, const char *str )
1250 {
1251         return sb_tls_bio_write( b, str, strlen( str ) );
1252 }
1253
1254 static BIO_METHOD sb_tls_bio_method =
1255 {
1256         ( 100 | 0x400 ),                /* it's a source/sink BIO */
1257         "sockbuf glue",
1258         sb_tls_bio_write,
1259         sb_tls_bio_read,
1260         sb_tls_bio_puts,
1261         sb_tls_bio_gets,
1262         sb_tls_bio_ctrl,
1263         sb_tls_bio_create,
1264         sb_tls_bio_destroy
1265 };
1266
1267 static int
1268 sb_tls_setup( Sockbuf_IO_Desc *sbiod, void *arg )
1269 {
1270         struct tls_data         *p;
1271         BIO                     *bio;
1272
1273         assert( sbiod != NULL );
1274
1275         p = LBER_MALLOC( sizeof( *p ) );
1276         if ( p == NULL ) {
1277                 return -1;
1278         }
1279
1280         p->ssl = (SSL *)arg;
1281         p->sbiod = sbiod;
1282         bio = BIO_new( &sb_tls_bio_method );
1283         bio->ptr = (void *)p;
1284         SSL_set_bio( p->ssl, bio, bio );
1285         sbiod->sbiod_pvt = p;
1286         return 0;
1287 }
1288
1289 static int
1290 sb_tls_remove( Sockbuf_IO_Desc *sbiod )
1291 {
1292         struct tls_data         *p;
1293
1294         assert( sbiod != NULL );
1295         assert( sbiod->sbiod_pvt != NULL );
1296
1297         p = (struct tls_data *)sbiod->sbiod_pvt;
1298         SSL_free( p->ssl );
1299         LBER_FREE( sbiod->sbiod_pvt );
1300         sbiod->sbiod_pvt = NULL;
1301         return 0;
1302 }
1303
1304 static int
1305 sb_tls_close( Sockbuf_IO_Desc *sbiod )
1306 {
1307         struct tls_data         *p;
1308
1309         assert( sbiod != NULL );
1310         assert( sbiod->sbiod_pvt != NULL );
1311
1312         p = (struct tls_data *)sbiod->sbiod_pvt;
1313         SSL_shutdown( p->ssl );
1314         return 0;
1315 }
1316
1317 static int
1318 sb_tls_ctrl( Sockbuf_IO_Desc *sbiod, int opt, void *arg )
1319 {
1320         struct tls_data         *p;
1321
1322         assert( sbiod != NULL );
1323         assert( sbiod->sbiod_pvt != NULL );
1324
1325         p = (struct tls_data *)sbiod->sbiod_pvt;
1326
1327         if ( opt == LBER_SB_OPT_GET_SSL ) {
1328                 *((SSL **)arg) = p->ssl;
1329                 return 1;
1330
1331         } else if ( opt == LBER_SB_OPT_DATA_READY ) {
1332                 if( SSL_pending( p->ssl ) > 0 ) {
1333                         return 1;
1334                 }
1335         }
1336
1337         return LBER_SBIOD_CTRL_NEXT( sbiod, opt, arg );
1338 }
1339
1340 static ber_slen_t
1341 sb_tls_read( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len)
1342 {
1343         struct tls_data         *p;
1344         ber_slen_t              ret;
1345         int                     err;
1346
1347         assert( sbiod != NULL );
1348         assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
1349
1350         p = (struct tls_data *)sbiod->sbiod_pvt;
1351
1352         ret = SSL_read( p->ssl, (char *)buf, len );
1353 #ifdef HAVE_WINSOCK
1354         errno = WSAGetLastError();
1355 #endif
1356         err = SSL_get_error( p->ssl, ret );
1357         if (err == SSL_ERROR_WANT_READ ) {
1358                 sbiod->sbiod_sb->sb_trans_needs_read = 1;
1359                 sock_errset(EWOULDBLOCK);
1360         }
1361         else
1362                 sbiod->sbiod_sb->sb_trans_needs_read = 0;
1363         return ret;
1364 }
1365
1366 static ber_slen_t
1367 sb_tls_write( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len)
1368 {
1369         struct tls_data         *p;
1370         ber_slen_t              ret;
1371         int                     err;
1372
1373         assert( sbiod != NULL );
1374         assert( SOCKBUF_VALID( sbiod->sbiod_sb ) );
1375
1376         p = (struct tls_data *)sbiod->sbiod_pvt;
1377
1378         ret = SSL_write( p->ssl, (char *)buf, len );
1379 #ifdef HAVE_WINSOCK
1380         errno = WSAGetLastError();
1381 #endif
1382         err = SSL_get_error( p->ssl, ret );
1383         if (err == SSL_ERROR_WANT_WRITE ) {
1384                 sbiod->sbiod_sb->sb_trans_needs_write = 1;
1385                 sock_errset(EWOULDBLOCK);
1386
1387         } else {
1388                 sbiod->sbiod_sb->sb_trans_needs_write = 0;
1389         }
1390         return ret;
1391 }
1392
1393 #endif
1394
1395 static Sockbuf_IO sb_tls_sbio =
1396 {
1397         sb_tls_setup,           /* sbi_setup */
1398         sb_tls_remove,          /* sbi_remove */
1399         sb_tls_ctrl,            /* sbi_ctrl */
1400         sb_tls_read,            /* sbi_read */
1401         sb_tls_write,           /* sbi_write */
1402         sb_tls_close            /* sbi_close */
1403 };
1404
1405 #ifdef HAVE_GNUTLS
1406 /* Certs are not automatically varified during the handshake */
1407 static int
1408 tls_cert_verify( tls_session *ssl )
1409 {
1410         unsigned int status = 0;
1411         int err;
1412         time_t now = time(0);
1413
1414         err = gnutls_certificate_verify_peers2( ssl->session, &status );
1415         if ( err < 0 ) {
1416                 Debug( LDAP_DEBUG_ANY,"TLS: gnutls_certificate_verify_peers2 failed %d\n",
1417                         err,0,0 );
1418                 return -1;
1419         }
1420         if ( status ) {
1421                 Debug( LDAP_DEBUG_TRACE,"TLS: peer cert untrusted or revoked (0x%x)\n",
1422                         status, 0,0 );
1423                 return -1;
1424         }
1425         if ( gnutls_certificate_expiration_time_peers( ssl->session ) < now ) {
1426                 Debug( LDAP_DEBUG_ANY, "TLS: peer certificate is expired\n",
1427                         0, 0, 0 );
1428                 return -1;
1429         }
1430         if ( gnutls_certificate_activation_time_peers( ssl->session ) > now ) {
1431                 Debug( LDAP_DEBUG_ANY, "TLS: peer certificate not yet active\n",
1432                         0, 0, 0 );
1433                 return -1;
1434         }
1435         return 0;
1436 }
1437 #endif /* HAVE_GNUTLS */
1438
1439 /*
1440  * Call this to do a TLS connect on a sockbuf. ctx_arg can be
1441  * a SSL_CTX * or NULL, in which case the default ctx is used.
1442  *
1443  * Return value:
1444  *
1445  *  0 - Success. Connection is ready for communication.
1446  * <0 - Error. Can't create a TLS stream.
1447  * >0 - Partial success.
1448  *        Do a select (using information from lber_pvt_sb_needs_{read,write}
1449  *              and call again.
1450  */
1451
1452 static int
1453 ldap_int_tls_connect( LDAP *ld, LDAPConn *conn )
1454 {
1455         Sockbuf *sb = conn->lconn_sb;
1456         int     err;
1457         tls_session     *ssl;
1458
1459         if ( HAS_TLS( sb ) ) {
1460                 ber_sockbuf_ctrl( sb, LBER_SB_OPT_GET_SSL, (void *)&ssl );
1461
1462         } else {
1463                 struct ldapoptions *lo;
1464                 tls_ctx *ctx;
1465
1466                 ctx = ld->ld_options.ldo_tls_ctx;
1467
1468                 ssl = alloc_handle( ctx, 0 );
1469
1470                 if ( ssl == NULL ) return -1;
1471
1472 #ifdef LDAP_DEBUG
1473                 ber_sockbuf_add_io( sb, &ber_sockbuf_io_debug,
1474                         LBER_SBIOD_LEVEL_TRANSPORT, (void *)"tls_" );
1475 #endif
1476                 ber_sockbuf_add_io( sb, &sb_tls_sbio,
1477                         LBER_SBIOD_LEVEL_TRANSPORT, (void *)ssl );
1478
1479                 lo = LDAP_INT_GLOBAL_OPT();
1480                 if( ctx == NULL ) {
1481                         ctx = lo->ldo_tls_ctx;
1482                         ld->ld_options.ldo_tls_ctx = ctx;
1483                         tls_ctx_ref( ctx );
1484                 }
1485                 if ( ld->ld_options.ldo_tls_connect_cb )
1486                         ld->ld_options.ldo_tls_connect_cb( ld, ssl, ctx,
1487                         ld->ld_options.ldo_tls_connect_arg );
1488                 if ( lo && lo->ldo_tls_connect_cb && lo->ldo_tls_connect_cb !=
1489                         ld->ld_options.ldo_tls_connect_cb )
1490                         lo->ldo_tls_connect_cb( ld, ssl, ctx, lo->ldo_tls_connect_arg );
1491         }
1492
1493         err = tls_session_connect( ssl );
1494
1495 #ifdef HAVE_WINSOCK
1496         errno = WSAGetLastError();
1497 #endif
1498
1499 #ifdef HAVE_GNUTLS
1500         if ( err < 0 )
1501 #else
1502         if ( err <= 0 )
1503 #endif
1504         {
1505                 if ( update_flags( sb, ssl, err )) {
1506                         return 1;
1507                 }
1508
1509 #ifndef HAVE_GNUTLS
1510                 if ((err = ERR_peek_error()))
1511 #endif
1512                 {
1513                         if ( ld->ld_error ) {
1514                                 LDAP_FREE( ld->ld_error );
1515                         }
1516 #ifdef HAVE_GNUTLS
1517                         ld->ld_error = LDAP_STRDUP(gnutls_strerror( err ));
1518 #else
1519                         {
1520                                 char buf[256];
1521                                 ld->ld_error = LDAP_STRDUP(ERR_error_string(err, buf));
1522                         }
1523 #endif
1524 #ifdef HAVE_EBCDIC
1525                         if ( ld->ld_error ) __etoa(ld->ld_error);
1526 #endif
1527                 }
1528
1529                 Debug( LDAP_DEBUG_ANY,"TLS: can't connect: %s.\n",
1530                         ld->ld_error ? ld->ld_error : "" ,0,0);
1531
1532                 ber_sockbuf_remove_io( sb, &sb_tls_sbio,
1533                         LBER_SBIOD_LEVEL_TRANSPORT );
1534 #ifdef LDAP_DEBUG
1535                 ber_sockbuf_remove_io( sb, &ber_sockbuf_io_debug,
1536                         LBER_SBIOD_LEVEL_TRANSPORT );
1537 #endif
1538                 return -1;
1539         }
1540
1541 #ifdef HAVE_GNUTLS
1542         if ( ld->ld_options.ldo_tls_require_cert != LDAP_OPT_X_TLS_NEVER ) {
1543                 err = tls_cert_verify( ssl );
1544                 if ( err && ld->ld_options.ldo_tls_require_cert != LDAP_OPT_X_TLS_ALLOW )
1545                         return err;
1546         }
1547 #endif
1548
1549         return 0;
1550 }
1551
1552 /*
1553  * Call this to do a TLS accept on a sockbuf.
1554  * Everything else is the same as with tls_connect.
1555  */
1556 int
1557 ldap_pvt_tls_accept( Sockbuf *sb, void *ctx_arg )
1558 {
1559         int     err;
1560         tls_session     *ssl;
1561
1562         if ( HAS_TLS( sb ) ) {
1563                 ber_sockbuf_ctrl( sb, LBER_SB_OPT_GET_SSL, (void *)&ssl );
1564
1565         } else {
1566                 ssl = alloc_handle( ctx_arg, 1 );
1567                 if ( ssl == NULL ) return -1;
1568
1569 #ifdef LDAP_DEBUG
1570                 ber_sockbuf_add_io( sb, &ber_sockbuf_io_debug,
1571                         LBER_SBIOD_LEVEL_TRANSPORT, (void *)"tls_" );
1572 #endif
1573                 ber_sockbuf_add_io( sb, &sb_tls_sbio,
1574                         LBER_SBIOD_LEVEL_TRANSPORT, (void *)ssl );
1575         }
1576
1577         err = tls_session_accept( ssl );
1578
1579 #ifdef HAVE_WINSOCK
1580         errno = WSAGetLastError();
1581 #endif
1582
1583 #ifdef HAVE_GNUTLS
1584         if ( err < 0 )
1585 #else
1586         if ( err <= 0 )
1587 #endif
1588         {
1589                 if ( update_flags( sb, ssl, err )) return 1;
1590
1591 #ifdef HAVE_GNUTLS
1592                 Debug( LDAP_DEBUG_ANY,"TLS: can't accept: %s.\n",
1593                         gnutls_strerror( err ),0,0 );
1594 #else
1595                 Debug( LDAP_DEBUG_ANY,"TLS: can't accept.\n",0,0,0 );
1596                 tls_report_error();
1597 #endif
1598                 ber_sockbuf_remove_io( sb, &sb_tls_sbio,
1599                         LBER_SBIOD_LEVEL_TRANSPORT );
1600 #ifdef LDAP_DEBUG
1601                 ber_sockbuf_remove_io( sb, &ber_sockbuf_io_debug,
1602                         LBER_SBIOD_LEVEL_TRANSPORT );
1603 #endif
1604                 return -1;
1605         }
1606
1607 #ifdef HAVE_GNUTLS
1608         if ( ssl->ctx->lo->ldo_tls_require_cert != LDAP_OPT_X_TLS_NEVER ) {
1609                 err = tls_cert_verify( ssl );
1610                 if ( err && ssl->ctx->lo->ldo_tls_require_cert != LDAP_OPT_X_TLS_ALLOW )
1611                         return err;
1612         }
1613 #endif
1614         return 0;
1615 }
1616
1617 int
1618 ldap_pvt_tls_inplace ( Sockbuf *sb )
1619 {
1620         return HAS_TLS( sb ) ? 1 : 0;
1621 }
1622
1623 int
1624 ldap_tls_inplace( LDAP *ld )
1625 {
1626         Sockbuf         *sb = NULL;
1627
1628         if ( ld->ld_defconn && ld->ld_defconn->lconn_sb ) {
1629                 sb = ld->ld_defconn->lconn_sb;
1630
1631         } else if ( ld->ld_sb ) {
1632                 sb = ld->ld_sb;
1633
1634         } else {
1635                 return 0;
1636         }
1637
1638         return ldap_pvt_tls_inplace( sb );
1639 }
1640
1641 static void
1642 x509_cert_get_dn( struct berval *cert, struct berval *dn, int get_subject )
1643 {
1644         BerElementBuffer berbuf;
1645         BerElement *ber = (BerElement *)&berbuf;
1646         ber_tag_t tag;
1647         ber_len_t len;
1648         ber_int_t i;
1649
1650         ber_init2( ber, cert, LBER_USE_DER );
1651         tag = ber_skip_tag( ber, &len );        /* Sequence */
1652         tag = ber_skip_tag( ber, &len );        /* Sequence */
1653         tag = ber_skip_tag( ber, &len );        /* Context + Constructed (version) */
1654         if ( tag == 0xa0 )      /* Version is optional */
1655                 tag = ber_get_int( ber, &i );   /* Int: Version */
1656         tag = ber_get_int( ber, &i );   /* Int: Serial */
1657         tag = ber_skip_tag( ber, &len );        /* Sequence: Signature */
1658         ber_skip_data( ber, len );
1659         if ( !get_subject ) {
1660                 tag = ber_peek_tag( ber, &len );        /* Sequence: Issuer DN */
1661         } else {
1662                 tag = ber_skip_tag( ber, &len );
1663                 ber_skip_data( ber, len );
1664                 tag = ber_skip_tag( ber, &len );        /* Sequence: Validity */
1665                 ber_skip_data( ber, len );
1666                 tag = ber_peek_tag( ber, &len );        /* Sequence: Subject DN */
1667         }
1668         len = ber_ptrlen( ber );
1669         dn->bv_val = cert->bv_val + len;
1670         dn->bv_len = cert->bv_len - len;
1671 }
1672
1673 #ifdef HAVE_GNUTLS
1674 static int
1675 tls_get_cert_dn( tls_session *session, struct berval *dnbv )
1676 {
1677         if ( !session->peer_der_dn.bv_val ) {
1678                 const gnutls_datum_t *peer_cert_list;
1679                 int list_size;
1680                 struct berval bv;
1681
1682                 peer_cert_list = gnutls_certificate_get_peers( session->session,
1683                                                         &list_size );
1684                 if ( !peer_cert_list ) return LDAP_INVALID_CREDENTIALS;
1685
1686                 bv.bv_len = peer_cert_list->size;
1687                 bv.bv_val = peer_cert_list->data;
1688
1689                 x509_cert_get_dn( &bv, &session->peer_der_dn, 1 );
1690                 *dnbv = session->peer_der_dn;
1691         }
1692         return 0;
1693 }
1694 #else
1695 static X509 *
1696 tls_get_cert( SSL *s )
1697 {
1698         /* If peer cert was bad, treat as if no cert was given */
1699         if (SSL_get_verify_result(s)) {
1700                 /* If we can send an alert, do so */
1701                 if (SSL_version(s) != SSL2_VERSION) {
1702                         ssl3_send_alert(s,SSL3_AL_WARNING,SSL3_AD_BAD_CERTIFICATE);
1703                 }
1704                 return NULL;
1705         }
1706         return SSL_get_peer_certificate(s);
1707 }
1708
1709 static int
1710 tls_get_cert_dn( tls_session *session, struct berval *dnbv )
1711 {
1712         X509_NAME *xn;
1713         X509 *x = tls_get_cert( session );
1714         int len;
1715
1716         if ( !x )
1717                 return LDAP_INVALID_CREDENTIALS;
1718
1719         xn = X509_get_subject_name(x);
1720         dnbv->bv_len = i2d_X509_NAME( xn, NULL );
1721         dnbv->bv_val = xn->bytes->data;
1722         return 0;
1723 }
1724 #endif /* HAVE_GNUTLS */
1725
1726 int
1727 ldap_pvt_tls_get_peer_dn( void *s, struct berval *dn,
1728         LDAPDN_rewrite_dummy *func, unsigned flags )
1729 {
1730         tls_session *session = s;
1731         struct berval bvdn;
1732         int rc;
1733
1734         rc = tls_get_cert_dn( session, &bvdn );
1735         if ( rc ) return rc;
1736
1737         rc = ldap_X509dn2bv( &bvdn, dn,
1738                             (LDAPDN_rewrite_func *)func, flags);
1739         return rc;
1740 }
1741
1742 /* what kind of hostname were we given? */
1743 #define IS_DNS  0
1744 #define IS_IP4  1
1745 #define IS_IP6  2
1746
1747 #ifdef HAVE_GNUTLS
1748
1749 int
1750 ldap_pvt_tls_check_hostname( LDAP *ld, void *s, const char *name_in )
1751 {
1752         tls_session *session = s;
1753         int i, ret;
1754         const gnutls_datum_t *peer_cert_list;
1755         int list_size;
1756         struct berval bv;
1757         char altname[NI_MAXHOST];
1758         size_t altnamesize;
1759
1760         gnutls_x509_crt_t cert;
1761         gnutls_datum_t *x;
1762         const char *name;
1763         char *ptr;
1764         char *domain = NULL;
1765 #ifdef LDAP_PF_INET6
1766         struct in6_addr addr;
1767 #else
1768         struct in_addr addr;
1769 #endif
1770         int n, len1 = 0, len2 = 0;
1771         int ntype = IS_DNS;
1772         time_t now = time(0);
1773
1774         if( ldap_int_hostname &&
1775                 ( !name_in || !strcasecmp( name_in, "localhost" ) ) )
1776         {
1777                 name = ldap_int_hostname;
1778         } else {
1779                 name = name_in;
1780         }
1781
1782         peer_cert_list = gnutls_certificate_get_peers( session->session,
1783                                                 &list_size );
1784         if ( !peer_cert_list ) {
1785                 Debug( LDAP_DEBUG_ANY,
1786                         "TLS: unable to get peer certificate.\n",
1787                         0, 0, 0 );
1788                 /* If this was a fatal condition, things would have
1789                  * aborted long before now.
1790                  */
1791                 return LDAP_SUCCESS;
1792         }
1793         ret = gnutls_x509_crt_init( &cert );
1794         if ( ret < 0 )
1795                 return LDAP_LOCAL_ERROR;
1796         ret = gnutls_x509_crt_import( cert, peer_cert_list, GNUTLS_X509_FMT_DER );
1797         if ( ret ) {
1798                 gnutls_x509_crt_deinit( cert );
1799                 return LDAP_LOCAL_ERROR;
1800         }
1801
1802 #ifdef LDAP_PF_INET6
1803         if (name[0] == '[' && strchr(name, ']')) {
1804                 char *n2 = ldap_strdup(name+1);
1805                 *strchr(n2, ']') = 2;
1806                 if (inet_pton(AF_INET6, n2, &addr))
1807                         ntype = IS_IP6;
1808                 LDAP_FREE(n2);
1809         } else
1810 #endif
1811         if ((ptr = strrchr(name, '.')) && isdigit((unsigned char)ptr[1])) {
1812                 if (inet_aton(name, (struct in_addr *)&addr)) ntype = IS_IP4;
1813         }
1814
1815         if (ntype == IS_DNS) {
1816                 len1 = strlen(name);
1817                 domain = strchr(name, '.');
1818                 if (domain) {
1819                         len2 = len1 - (domain-name);
1820                 }
1821         }
1822
1823         for ( i=0, ret=0; ret >= 0; i++ ) {
1824                 altnamesize = sizeof(altname);
1825                 ret = gnutls_x509_crt_get_subject_alt_name( cert, i,
1826                         altname, &altnamesize, NULL );
1827                 if ( ret < 0 ) break;
1828
1829                 /* ignore empty */
1830                 if ( altnamesize == 0 ) continue;
1831
1832                 if ( ret == GNUTLS_SAN_DNSNAME ) {
1833                         if (ntype != IS_DNS) continue;
1834
1835                         /* Is this an exact match? */
1836                         if ((len1 == altnamesize) && !strncasecmp(name, altname, len1)) {
1837                                 break;
1838                         }
1839
1840                         /* Is this a wildcard match? */
1841                         if (domain && (altname[0] == '*') && (altname[1] == '.') &&
1842                                 (len2 == altnamesize-1) && !strncasecmp(domain, &altname[1], len2))
1843                         {
1844                                 break;
1845                         }
1846                 } else if ( ret == GNUTLS_SAN_IPADDRESS ) {
1847                         if (ntype == IS_DNS) continue;
1848
1849 #ifdef LDAP_PF_INET6
1850                         if (ntype == IS_IP6 && altnamesize != sizeof(struct in6_addr)) {
1851                                 continue;
1852                         } else
1853 #endif
1854                         if (ntype == IS_IP4 && altnamesize != sizeof(struct in_addr)) {
1855                                 continue;
1856                         }
1857                         if (!memcmp(altname, &addr, altnamesize)) {
1858                                 break;
1859                         }
1860                 }
1861         }
1862         if ( ret >= 0 ) {
1863                 ret = LDAP_SUCCESS;
1864         } else {
1865                 altnamesize = sizeof(altname);
1866                 ret = gnutls_x509_crt_get_dn_by_oid( cert, CN_OID,
1867                         0, 0, altname, &altnamesize );
1868                 if ( ret < 0 ) {
1869                         Debug( LDAP_DEBUG_ANY,
1870                                 "TLS: unable to get common name from peer certificate.\n",
1871                                 0, 0, 0 );
1872                         ret = LDAP_CONNECT_ERROR;
1873                         if ( ld->ld_error ) {
1874                                 LDAP_FREE( ld->ld_error );
1875                         }
1876                         ld->ld_error = LDAP_STRDUP(
1877                                 _("TLS: unable to get CN from peer certificate"));
1878
1879                 } else {
1880                         ret = LDAP_LOCAL_ERROR;
1881                         if ( len1 == altnamesize && strncasecmp(name, altname, altnamesize) == 0 ) {
1882                                 ret = LDAP_SUCCESS;
1883
1884                         } else if (( altname[0] == '*' ) && ( altname[1] == '.' )) {
1885                                         /* Is this a wildcard match? */
1886                                 if( domain &&
1887                                         (len2 == altnamesize-1) && !strncasecmp(domain, &altname[1], len2)) {
1888                                         ret = LDAP_SUCCESS;
1889                                 }
1890                         }
1891                 }
1892
1893                 if( ret == LDAP_LOCAL_ERROR ) {
1894                         altname[altnamesize] = '\0';
1895                         Debug( LDAP_DEBUG_ANY, "TLS: hostname (%s) does not match "
1896                                 "common name in certificate (%s).\n",
1897                                 name, altname, 0 );
1898                         ret = LDAP_CONNECT_ERROR;
1899                         if ( ld->ld_error ) {
1900                                 LDAP_FREE( ld->ld_error );
1901                         }
1902                         ld->ld_error = LDAP_STRDUP(
1903                                 _("TLS: hostname does not match CN in peer certificate"));
1904                 }
1905         }
1906         gnutls_x509_crt_deinit( cert );
1907         return ret;
1908 }
1909
1910 #else /* !HAVE_GNUTLS */
1911
1912 int
1913 ldap_pvt_tls_check_hostname( LDAP *ld, void *s, const char *name_in )
1914 {
1915         int i, ret = LDAP_LOCAL_ERROR;
1916         X509 *x;
1917         const char *name;
1918         char *ptr;
1919         int ntype = IS_DNS;
1920 #ifdef LDAP_PF_INET6
1921         struct in6_addr addr;
1922 #else
1923         struct in_addr addr;
1924 #endif
1925
1926         if( ldap_int_hostname &&
1927                 ( !name_in || !strcasecmp( name_in, "localhost" ) ) )
1928         {
1929                 name = ldap_int_hostname;
1930         } else {
1931                 name = name_in;
1932         }
1933
1934         x = tls_get_cert((SSL *)s);
1935         if (!x) {
1936                 Debug( LDAP_DEBUG_ANY,
1937                         "TLS: unable to get peer certificate.\n",
1938                         0, 0, 0 );
1939                 /* If this was a fatal condition, things would have
1940                  * aborted long before now.
1941                  */
1942                 return LDAP_SUCCESS;
1943         }
1944
1945 #ifdef LDAP_PF_INET6
1946         if (name[0] == '[' && strchr(name, ']')) {
1947                 char *n2 = ldap_strdup(name+1);
1948                 *strchr(n2, ']') = 2;
1949                 if (inet_pton(AF_INET6, n2, &addr))
1950                         ntype = IS_IP6;
1951                 LDAP_FREE(n2);
1952         } else
1953 #endif
1954         if ((ptr = strrchr(name, '.')) && isdigit((unsigned char)ptr[1])) {
1955                 if (inet_aton(name, (struct in_addr *)&addr)) ntype = IS_IP4;
1956         }
1957
1958         i = X509_get_ext_by_NID(x, NID_subject_alt_name, -1);
1959         if (i >= 0) {
1960                 X509_EXTENSION *ex;
1961                 STACK_OF(GENERAL_NAME) *alt;
1962
1963                 ex = X509_get_ext(x, i);
1964                 alt = X509V3_EXT_d2i(ex);
1965                 if (alt) {
1966                         int n, len1 = 0, len2 = 0;
1967                         char *domain = NULL;
1968                         GENERAL_NAME *gn;
1969
1970                         if (ntype == IS_DNS) {
1971                                 len1 = strlen(name);
1972                                 domain = strchr(name, '.');
1973                                 if (domain) {
1974                                         len2 = len1 - (domain-name);
1975                                 }
1976                         }
1977                         n = sk_GENERAL_NAME_num(alt);
1978                         for (i=0; i<n; i++) {
1979                                 char *sn;
1980                                 int sl;
1981                                 gn = sk_GENERAL_NAME_value(alt, i);
1982                                 if (gn->type == GEN_DNS) {
1983                                         if (ntype != IS_DNS) continue;
1984
1985                                         sn = (char *) ASN1_STRING_data(gn->d.ia5);
1986                                         sl = ASN1_STRING_length(gn->d.ia5);
1987
1988                                         /* ignore empty */
1989                                         if (sl == 0) continue;
1990
1991                                         /* Is this an exact match? */
1992                                         if ((len1 == sl) && !strncasecmp(name, sn, len1)) {
1993                                                 break;
1994                                         }
1995
1996                                         /* Is this a wildcard match? */
1997                                         if (domain && (sn[0] == '*') && (sn[1] == '.') &&
1998                                                 (len2 == sl-1) && !strncasecmp(domain, &sn[1], len2))
1999                                         {
2000                                                 break;
2001                                         }
2002
2003                                 } else if (gn->type == GEN_IPADD) {
2004                                         if (ntype == IS_DNS) continue;
2005
2006                                         sn = (char *) ASN1_STRING_data(gn->d.ia5);
2007                                         sl = ASN1_STRING_length(gn->d.ia5);
2008
2009 #ifdef LDAP_PF_INET6
2010                                         if (ntype == IS_IP6 && sl != sizeof(struct in6_addr)) {
2011                                                 continue;
2012                                         } else
2013 #endif
2014                                         if (ntype == IS_IP4 && sl != sizeof(struct in_addr)) {
2015                                                 continue;
2016                                         }
2017                                         if (!memcmp(sn, &addr, sl)) {
2018                                                 break;
2019                                         }
2020                                 }
2021                         }
2022
2023                         GENERAL_NAMES_free(alt);
2024                         if (i < n) {    /* Found a match */
2025                                 ret = LDAP_SUCCESS;
2026                         }
2027                 }
2028         }
2029
2030         if (ret != LDAP_SUCCESS) {
2031                 X509_NAME *xn;
2032                 char buf[2048];
2033                 buf[0] = '\0';
2034
2035                 xn = X509_get_subject_name(x);
2036                 if( X509_NAME_get_text_by_NID( xn, NID_commonName,
2037                         buf, sizeof(buf)) == -1)
2038                 {
2039                         Debug( LDAP_DEBUG_ANY,
2040                                 "TLS: unable to get common name from peer certificate.\n",
2041                                 0, 0, 0 );
2042                         ret = LDAP_CONNECT_ERROR;
2043                         if ( ld->ld_error ) {
2044                                 LDAP_FREE( ld->ld_error );
2045                         }
2046                         ld->ld_error = LDAP_STRDUP(
2047                                 _("TLS: unable to get CN from peer certificate"));
2048
2049                 } else if (strcasecmp(name, buf) == 0 ) {
2050                         ret = LDAP_SUCCESS;
2051
2052                 } else if (( buf[0] == '*' ) && ( buf[1] == '.' )) {
2053                         char *domain = strchr(name, '.');
2054                         if( domain ) {
2055                                 size_t dlen = 0;
2056                                 size_t sl;
2057
2058                                 sl = strlen(name);
2059                                 dlen = sl - (domain-name);
2060                                 sl = strlen(buf);
2061
2062                                 /* Is this a wildcard match? */
2063                                 if ((dlen == sl-1) && !strncasecmp(domain, &buf[1], dlen)) {
2064                                         ret = LDAP_SUCCESS;
2065                                 }
2066                         }
2067                 }
2068
2069                 if( ret == LDAP_LOCAL_ERROR ) {
2070                         Debug( LDAP_DEBUG_ANY, "TLS: hostname (%s) does not match "
2071                                 "common name in certificate (%s).\n",
2072                                 name, buf, 0 );
2073                         ret = LDAP_CONNECT_ERROR;
2074                         if ( ld->ld_error ) {
2075                                 LDAP_FREE( ld->ld_error );
2076                         }
2077                         ld->ld_error = LDAP_STRDUP(
2078                                 _("TLS: hostname does not match CN in peer certificate"));
2079                 }
2080         }
2081         X509_free(x);
2082         return ret;
2083 }
2084 #endif
2085
2086 int
2087 ldap_int_tls_config( LDAP *ld, int option, const char *arg )
2088 {
2089         int i;
2090
2091         switch( option ) {
2092         case LDAP_OPT_X_TLS_CACERTFILE:
2093         case LDAP_OPT_X_TLS_CACERTDIR:
2094         case LDAP_OPT_X_TLS_CERTFILE:
2095         case LDAP_OPT_X_TLS_KEYFILE:
2096         case LDAP_OPT_X_TLS_RANDOM_FILE:
2097         case LDAP_OPT_X_TLS_CIPHER_SUITE:
2098         case LDAP_OPT_X_TLS_DHFILE:
2099 #ifdef HAVE_GNUTLS
2100         case LDAP_OPT_X_TLS_CRLFILE:
2101 #endif
2102                 return ldap_pvt_tls_set_option( ld, option, (void *) arg );
2103
2104         case LDAP_OPT_X_TLS_REQUIRE_CERT:
2105         case LDAP_OPT_X_TLS:
2106                 i = -1;
2107                 if ( strcasecmp( arg, "never" ) == 0 ) {
2108                         i = LDAP_OPT_X_TLS_NEVER ;
2109
2110                 } else if ( strcasecmp( arg, "demand" ) == 0 ) {
2111                         i = LDAP_OPT_X_TLS_DEMAND ;
2112
2113                 } else if ( strcasecmp( arg, "allow" ) == 0 ) {
2114                         i = LDAP_OPT_X_TLS_ALLOW ;
2115
2116                 } else if ( strcasecmp( arg, "try" ) == 0 ) {
2117                         i = LDAP_OPT_X_TLS_TRY ;
2118
2119                 } else if ( ( strcasecmp( arg, "hard" ) == 0 ) ||
2120                         ( strcasecmp( arg, "on" ) == 0 ) ||
2121                         ( strcasecmp( arg, "yes" ) == 0) ||
2122                         ( strcasecmp( arg, "true" ) == 0 ) )
2123                 {
2124                         i = LDAP_OPT_X_TLS_HARD ;
2125                 }
2126
2127                 if (i >= 0) {
2128                         return ldap_pvt_tls_set_option( ld, option, &i );
2129                 }
2130                 return -1;
2131 #ifdef HAVE_OPENSSL_CRL
2132         case LDAP_OPT_X_TLS_CRLCHECK:
2133                 i = -1;
2134                 if ( strcasecmp( arg, "none" ) == 0 ) {
2135                         i = LDAP_OPT_X_TLS_CRL_NONE ;
2136                 } else if ( strcasecmp( arg, "peer" ) == 0 ) {
2137                         i = LDAP_OPT_X_TLS_CRL_PEER ;
2138                 } else if ( strcasecmp( arg, "all" ) == 0 ) {
2139                         i = LDAP_OPT_X_TLS_CRL_ALL ;
2140                 }
2141                 if (i >= 0) {
2142                         return ldap_pvt_tls_set_option( ld, option, &i );
2143                 }
2144                 return -1;
2145 #endif
2146         }
2147         return -1;
2148 }
2149
2150 int
2151 ldap_pvt_tls_get_option( LDAP *ld, int option, void *arg )
2152 {
2153         struct ldapoptions *lo;
2154
2155         if( ld != NULL ) {
2156                 assert( LDAP_VALID( ld ) );
2157
2158                 if( !LDAP_VALID( ld ) ) {
2159                         return LDAP_OPT_ERROR;
2160                 }
2161
2162                 lo = &ld->ld_options;
2163
2164         } else {
2165                 /* Get pointer to global option structure */
2166                 lo = LDAP_INT_GLOBAL_OPT();
2167                 if ( lo == NULL ) {
2168                         return LDAP_NO_MEMORY;
2169                 }
2170         }
2171
2172         switch( option ) {
2173         case LDAP_OPT_X_TLS:
2174                 *(int *)arg = lo->ldo_tls_mode;
2175                 break;
2176         case LDAP_OPT_X_TLS_CTX:
2177                 *(void **)arg = lo->ldo_tls_ctx;
2178                 if ( lo->ldo_tls_ctx ) {
2179                         tls_ctx_ref( lo->ldo_tls_ctx );
2180                 }
2181                 break;
2182         case LDAP_OPT_X_TLS_CACERTFILE:
2183                 *(char **)arg = lo->ldo_tls_cacertfile ?
2184                         LDAP_STRDUP( lo->ldo_tls_cacertfile ) : NULL;
2185                 break;
2186         case LDAP_OPT_X_TLS_CACERTDIR:
2187                 *(char **)arg = lo->ldo_tls_cacertdir ?
2188                         LDAP_STRDUP( lo->ldo_tls_cacertdir ) : NULL;
2189                 break;
2190         case LDAP_OPT_X_TLS_CERTFILE:
2191                 *(char **)arg = lo->ldo_tls_certfile ?
2192                         LDAP_STRDUP( lo->ldo_tls_certfile ) : NULL;
2193                 break;
2194         case LDAP_OPT_X_TLS_KEYFILE:
2195                 *(char **)arg = lo->ldo_tls_keyfile ?
2196                         LDAP_STRDUP( lo->ldo_tls_keyfile ) : NULL;
2197                 break;
2198         case LDAP_OPT_X_TLS_DHFILE:
2199                 *(char **)arg = lo->ldo_tls_dhfile ?
2200                         LDAP_STRDUP( lo->ldo_tls_dhfile ) : NULL;
2201                 break;
2202 #ifdef HAVE_GNUTLS
2203         case LDAP_OPT_X_TLS_CRLFILE:
2204                 *(char **)arg = lo->ldo_tls_crlfile ?
2205                         LDAP_STRDUP( lo->ldo_tls_crlfile ) : NULL;
2206                 break;
2207 #endif
2208         case LDAP_OPT_X_TLS_REQUIRE_CERT:
2209                 *(int *)arg = lo->ldo_tls_require_cert;
2210                 break;
2211 #ifdef HAVE_OPENSSL_CRL
2212         case LDAP_OPT_X_TLS_CRLCHECK:
2213                 *(int *)arg = lo->ldo_tls_crlcheck;
2214                 break;
2215 #endif
2216         case LDAP_OPT_X_TLS_CIPHER_SUITE:
2217                 *(char **)arg = lo->ldo_tls_ciphersuite ?
2218                         LDAP_STRDUP( lo->ldo_tls_ciphersuite ) : NULL;
2219                 break;
2220         case LDAP_OPT_X_TLS_RANDOM_FILE:
2221 #ifdef HAVE_OPENSSL
2222                 *(char **)arg = tls_opt_randfile ?
2223                         LDAP_STRDUP( tls_opt_randfile ) : NULL;
2224 #else
2225                 *(char **)arg = NULL;
2226 #endif
2227                 break;
2228         case LDAP_OPT_X_TLS_SSL_CTX: {
2229                 void *retval = 0;
2230                 if ( ld != NULL ) {
2231                         LDAPConn *conn = ld->ld_defconn;
2232                         if ( conn != NULL ) {
2233                                 Sockbuf *sb = conn->lconn_sb;
2234                                 retval = ldap_pvt_tls_sb_ctx( sb );
2235                         }
2236                 }
2237                 *(void **)arg = retval;
2238                 break;
2239         }
2240         case LDAP_OPT_X_TLS_CONNECT_CB:
2241                 *(LDAP_TLS_CONNECT_CB **)arg = lo->ldo_tls_connect_cb;
2242                 break;
2243         case LDAP_OPT_X_TLS_CONNECT_ARG:
2244                 *(void **)arg = lo->ldo_tls_connect_arg;
2245                 break;
2246         default:
2247                 return -1;
2248         }
2249         return 0;
2250 }
2251
2252 int
2253 ldap_pvt_tls_set_option( LDAP *ld, int option, void *arg )
2254 {
2255         struct ldapoptions *lo;
2256
2257         if( ld != NULL ) {
2258                 assert( LDAP_VALID( ld ) );
2259
2260                 if( !LDAP_VALID( ld ) ) {
2261                         return LDAP_OPT_ERROR;
2262                 }
2263
2264                 lo = &ld->ld_options;
2265
2266         } else {
2267                 /* Get pointer to global option structure */
2268                 lo = LDAP_INT_GLOBAL_OPT();
2269                 if ( lo == NULL ) {
2270                         return LDAP_NO_MEMORY;
2271                 }
2272         }
2273
2274         switch( option ) {
2275         case LDAP_OPT_X_TLS:
2276                 if ( !arg ) return -1;
2277
2278                 switch( *(int *) arg ) {
2279                 case LDAP_OPT_X_TLS_NEVER:
2280                 case LDAP_OPT_X_TLS_DEMAND:
2281                 case LDAP_OPT_X_TLS_ALLOW:
2282                 case LDAP_OPT_X_TLS_TRY:
2283                 case LDAP_OPT_X_TLS_HARD:
2284                         if (lo != NULL) {
2285                                 lo->ldo_tls_mode = *(int *)arg;
2286                         }
2287
2288                         return 0;
2289                 }
2290                 return -1;
2291
2292         case LDAP_OPT_X_TLS_CTX:
2293                 if ( lo->ldo_tls_ctx )
2294                         ldap_pvt_tls_ctx_free( lo->ldo_tls_ctx );
2295                 lo->ldo_tls_ctx = arg;
2296                 tls_ctx_ref( lo->ldo_tls_ctx );
2297                 return 0;
2298         case LDAP_OPT_X_TLS_CONNECT_CB:
2299                 lo->ldo_tls_connect_cb = (LDAP_TLS_CONNECT_CB *)arg;
2300                 return 0;
2301         case LDAP_OPT_X_TLS_CONNECT_ARG:
2302                 lo->ldo_tls_connect_arg = arg;
2303                 return 0;
2304         case LDAP_OPT_X_TLS_CACERTFILE:
2305                 if ( lo->ldo_tls_cacertfile ) LDAP_FREE( lo->ldo_tls_cacertfile );
2306                 lo->ldo_tls_cacertfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
2307                 return 0;
2308         case LDAP_OPT_X_TLS_CACERTDIR:
2309                 if ( lo->ldo_tls_cacertdir ) LDAP_FREE( lo->ldo_tls_cacertdir );
2310                 lo->ldo_tls_cacertdir = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
2311                 return 0;
2312         case LDAP_OPT_X_TLS_CERTFILE:
2313                 if ( lo->ldo_tls_certfile ) LDAP_FREE( lo->ldo_tls_certfile );
2314                 lo->ldo_tls_certfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
2315                 return 0;
2316         case LDAP_OPT_X_TLS_KEYFILE:
2317                 if ( lo->ldo_tls_keyfile ) LDAP_FREE( lo->ldo_tls_keyfile );
2318                 lo->ldo_tls_keyfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
2319                 return 0;
2320         case LDAP_OPT_X_TLS_DHFILE:
2321                 if ( lo->ldo_tls_dhfile ) LDAP_FREE( lo->ldo_tls_dhfile );
2322                 lo->ldo_tls_dhfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
2323                 return 0;
2324 #ifdef HAVE_GNUTLS
2325         case LDAP_OPT_X_TLS_CRLFILE:
2326                 if ( lo->ldo_tls_crlfile ) LDAP_FREE( lo->ldo_tls_crlfile );
2327                 lo->ldo_tls_crlfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
2328                 return 0;
2329 #endif
2330         case LDAP_OPT_X_TLS_REQUIRE_CERT:
2331                 if ( !arg ) return -1;
2332                 switch( *(int *) arg ) {
2333                 case LDAP_OPT_X_TLS_NEVER:
2334                 case LDAP_OPT_X_TLS_DEMAND:
2335                 case LDAP_OPT_X_TLS_ALLOW:
2336                 case LDAP_OPT_X_TLS_TRY:
2337                 case LDAP_OPT_X_TLS_HARD:
2338                         lo->ldo_tls_require_cert = * (int *) arg;
2339                         return 0;
2340                 }
2341                 return -1;
2342 #ifdef HAVE_OPENSSL_CRL
2343         case LDAP_OPT_X_TLS_CRLCHECK:
2344                 if ( !arg ) return -1;
2345                 switch( *(int *) arg ) {
2346                 case LDAP_OPT_X_TLS_CRL_NONE:
2347                 case LDAP_OPT_X_TLS_CRL_PEER:
2348                 case LDAP_OPT_X_TLS_CRL_ALL:
2349                         lo->ldo_tls_crlcheck = * (int *) arg;
2350                         return 0;
2351                 }
2352                 return -1;
2353 #endif
2354         case LDAP_OPT_X_TLS_CIPHER_SUITE:
2355                 if ( lo->ldo_tls_ciphersuite ) LDAP_FREE( lo->ldo_tls_ciphersuite );
2356                 lo->ldo_tls_ciphersuite = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
2357                 return 0;
2358
2359         case LDAP_OPT_X_TLS_RANDOM_FILE:
2360                 if ( ld != NULL )
2361                         return -1;
2362 #ifdef HAVE_OPENSSL
2363                 if (tls_opt_randfile ) LDAP_FREE (tls_opt_randfile );
2364                 tls_opt_randfile = arg ? LDAP_STRDUP( (char *) arg ) : NULL;
2365 #endif
2366                 break;
2367
2368         case LDAP_OPT_X_TLS_NEWCTX:
2369                 if ( !arg ) return -1;
2370                 if ( lo->ldo_tls_ctx )
2371                         ldap_pvt_tls_ctx_free( lo->ldo_tls_ctx );
2372                 lo->ldo_tls_ctx = NULL;
2373                 return ldap_int_tls_init_ctx( lo, *(int *)arg );
2374         default:
2375                 return -1;
2376         }
2377         return 0;
2378 }
2379
2380 int
2381 ldap_int_tls_start ( LDAP *ld, LDAPConn *conn, LDAPURLDesc *srv )
2382 {
2383         Sockbuf *sb = conn->lconn_sb;
2384         char *host;
2385         void *ssl;
2386
2387         if( srv ) {
2388                 host = srv->lud_host;
2389         } else {
2390                 host = conn->lconn_server->lud_host;
2391         }
2392
2393         /* avoid NULL host */
2394         if( host == NULL ) {
2395                 host = "localhost";
2396         }
2397
2398         (void) ldap_pvt_tls_init();
2399
2400         /*
2401          * Fortunately, the lib uses blocking io...
2402          */
2403         if ( ldap_int_tls_connect( ld, conn ) < 0 ) {
2404                 ld->ld_errno = LDAP_CONNECT_ERROR;
2405                 return (ld->ld_errno);
2406         }
2407
2408         ssl = ldap_pvt_tls_sb_ctx( sb );
2409         assert( ssl != NULL );
2410
2411         /*
2412          * compare host with name(s) in certificate
2413          */
2414         if (ld->ld_options.ldo_tls_require_cert != LDAP_OPT_X_TLS_NEVER) {
2415                 ld->ld_errno = ldap_pvt_tls_check_hostname( ld, ssl, host );
2416                 if (ld->ld_errno != LDAP_SUCCESS) {
2417                         return ld->ld_errno;
2418                 }
2419         }
2420
2421         return LDAP_SUCCESS;
2422 }
2423
2424 #ifdef HAVE_OPENSSL
2425 /* Derived from openssl/apps/s_cb.c */
2426 static void
2427 tls_info_cb( const SSL *ssl, int where, int ret )
2428 {
2429         int w;
2430         char *op;
2431         char *state = (char *) SSL_state_string_long( (SSL *)ssl );
2432
2433         w = where & ~SSL_ST_MASK;
2434         if ( w & SSL_ST_CONNECT ) {
2435                 op = "SSL_connect";
2436         } else if ( w & SSL_ST_ACCEPT ) {
2437                 op = "SSL_accept";
2438         } else {
2439                 op = "undefined";
2440         }
2441
2442 #ifdef HAVE_EBCDIC
2443         if ( state ) {
2444                 state = LDAP_STRDUP( state );
2445                 __etoa( state );
2446         }
2447 #endif
2448         if ( where & SSL_CB_LOOP ) {
2449                 Debug( LDAP_DEBUG_TRACE,
2450                            "TLS trace: %s:%s\n",
2451                            op, state, 0 );
2452
2453         } else if ( where & SSL_CB_ALERT ) {
2454                 char *atype = (char *) SSL_alert_type_string_long( ret );
2455                 char *adesc = (char *) SSL_alert_desc_string_long( ret );
2456                 op = ( where & SSL_CB_READ ) ? "read" : "write";
2457 #ifdef HAVE_EBCDIC
2458                 if ( atype ) {
2459                         atype = LDAP_STRDUP( atype );
2460                         __etoa( atype );
2461                 }
2462                 if ( adesc ) {
2463                         adesc = LDAP_STRDUP( adesc );
2464                         __etoa( adesc );
2465                 }
2466 #endif
2467                 Debug( LDAP_DEBUG_TRACE,
2468                            "TLS trace: SSL3 alert %s:%s:%s\n",
2469                            op, atype, adesc );
2470 #ifdef HAVE_EBCDIC
2471                 if ( atype ) LDAP_FREE( atype );
2472                 if ( adesc ) LDAP_FREE( adesc );
2473 #endif
2474         } else if ( where & SSL_CB_EXIT ) {
2475                 if ( ret == 0 ) {
2476                         Debug( LDAP_DEBUG_TRACE,
2477                                    "TLS trace: %s:failed in %s\n",
2478                                    op, state, 0 );
2479                 } else if ( ret < 0 ) {
2480                         Debug( LDAP_DEBUG_TRACE,
2481                                    "TLS trace: %s:error in %s\n",
2482                                    op, state, 0 );
2483                 }
2484         }
2485 #ifdef HAVE_EBCDIC
2486         if ( state ) LDAP_FREE( state );
2487 #endif
2488 }
2489
2490 static int
2491 tls_verify_cb( int ok, X509_STORE_CTX *ctx )
2492 {
2493         X509 *cert;
2494         int errnum;
2495         int errdepth;
2496         X509_NAME *subject;
2497         X509_NAME *issuer;
2498         char *sname;
2499         char *iname;
2500         char *certerr = NULL;
2501
2502         cert = X509_STORE_CTX_get_current_cert( ctx );
2503         errnum = X509_STORE_CTX_get_error( ctx );
2504         errdepth = X509_STORE_CTX_get_error_depth( ctx );
2505
2506         /*
2507          * X509_get_*_name return pointers to the internal copies of
2508          * those things requested.  So do not free them.
2509          */
2510         subject = X509_get_subject_name( cert );
2511         issuer = X509_get_issuer_name( cert );
2512         /* X509_NAME_oneline, if passed a NULL buf, allocate memomry */
2513         sname = X509_NAME_oneline( subject, NULL, 0 );
2514         iname = X509_NAME_oneline( issuer, NULL, 0 );
2515         if ( !ok ) certerr = (char *)X509_verify_cert_error_string( errnum );
2516 #ifdef HAVE_EBCDIC
2517         if ( sname ) __etoa( sname );
2518         if ( iname ) __etoa( iname );
2519         if ( certerr ) {
2520                 certerr = LDAP_STRDUP( certerr );
2521                 __etoa( certerr );
2522         }
2523 #endif
2524         Debug( LDAP_DEBUG_TRACE,
2525                    "TLS certificate verification: depth: %d, err: %d, subject: %s,",
2526                    errdepth, errnum,
2527                    sname ? sname : "-unknown-" );
2528         Debug( LDAP_DEBUG_TRACE, " issuer: %s\n", iname ? iname : "-unknown-", 0, 0 );
2529         if ( !ok ) {
2530                 Debug( LDAP_DEBUG_ANY,
2531                         "TLS certificate verification: Error, %s\n",
2532                         certerr, 0, 0 );
2533         }
2534         if ( sname )
2535                 CRYPTO_free ( sname );
2536         if ( iname )
2537                 CRYPTO_free ( iname );
2538 #ifdef HAVE_EBCDIC
2539         if ( certerr ) LDAP_FREE( certerr );
2540 #endif
2541         return ok;
2542 }
2543
2544 static int
2545 tls_verify_ok( int ok, X509_STORE_CTX *ctx )
2546 {
2547         (void) tls_verify_cb( ok, ctx );
2548         return 1;
2549 }
2550
2551 /* Inspired by ERR_print_errors in OpenSSL */
2552 static void
2553 tls_report_error( void )
2554 {
2555         unsigned long l;
2556         char buf[200];
2557         const char *file;
2558         int line;
2559
2560         while ( ( l = ERR_get_error_line( &file, &line ) ) != 0 ) {
2561                 ERR_error_string_n( l, buf, sizeof( buf ) );
2562 #ifdef HAVE_EBCDIC
2563                 if ( file ) {
2564                         file = LDAP_STRDUP( file );
2565                         __etoa( (char *)file );
2566                 }
2567                 __etoa( buf );
2568 #endif
2569                 Debug( LDAP_DEBUG_ANY, "TLS: %s %s:%d\n",
2570                         buf, file, line );
2571 #ifdef HAVE_EBCDIC
2572                 if ( file ) LDAP_FREE( (void *)file );
2573 #endif
2574         }
2575 }
2576
2577 static RSA *
2578 tls_tmp_rsa_cb( SSL *ssl, int is_export, int key_length )
2579 {
2580         RSA *tmp_rsa;
2581
2582         /* FIXME:  Pregenerate the key on startup */
2583         /* FIXME:  Who frees the key? */
2584         tmp_rsa = RSA_generate_key( key_length, RSA_F4, NULL, NULL );
2585
2586         if ( !tmp_rsa ) {
2587                 Debug( LDAP_DEBUG_ANY,
2588                         "TLS: Failed to generate temporary %d-bit %s RSA key\n",
2589                         key_length, is_export ? "export" : "domestic", 0 );
2590                 return NULL;
2591         }
2592         return tmp_rsa;
2593 }
2594
2595 static int
2596 tls_seed_PRNG( const char *randfile )
2597 {
2598 #ifndef URANDOM_DEVICE
2599         /* no /dev/urandom (or equiv) */
2600         long total=0;
2601         char buffer[MAXPATHLEN];
2602
2603         if (randfile == NULL) {
2604                 /* The seed file is $RANDFILE if defined, otherwise $HOME/.rnd.
2605                  * If $HOME is not set or buffer too small to hold the pathname,
2606                  * an error occurs.     - From RAND_file_name() man page.
2607                  * The fact is that when $HOME is NULL, .rnd is used.
2608                  */
2609                 randfile = RAND_file_name( buffer, sizeof( buffer ) );
2610
2611         } else if (RAND_egd(randfile) > 0) {
2612                 /* EGD socket */
2613                 return 0;
2614         }
2615
2616         if (randfile == NULL) {
2617                 Debug( LDAP_DEBUG_ANY,
2618                         "TLS: Use configuration file or $RANDFILE to define seed PRNG\n",
2619                         0, 0, 0);
2620                 return -1;
2621         }
2622
2623         total = RAND_load_file(randfile, -1);
2624
2625         if (RAND_status() == 0) {
2626                 Debug( LDAP_DEBUG_ANY,
2627                         "TLS: PRNG not been seeded with enough data\n",
2628                         0, 0, 0);
2629                 return -1;
2630         }
2631
2632         /* assume if there was enough bits to seed that it's okay
2633          * to write derived bits to the file
2634          */
2635         RAND_write_file(randfile);
2636
2637 #endif
2638
2639         return 0;
2640 }
2641
2642 struct dhinfo {
2643         int keylength;
2644         const char *pem;
2645         size_t size;
2646 };
2647
2648
2649 /* From the OpenSSL 0.9.7 distro */
2650 static const char dhpem512[] =
2651 "-----BEGIN DH PARAMETERS-----\n\
2652 MEYCQQDaWDwW2YUiidDkr3VvTMqS3UvlM7gE+w/tlO+cikQD7VdGUNNpmdsp13Yn\n\
2653 a6LT1BLiGPTdHghM9tgAPnxHdOgzAgEC\n\
2654 -----END DH PARAMETERS-----\n";
2655
2656 static const char dhpem1024[] =
2657 "-----BEGIN DH PARAMETERS-----\n\
2658 MIGHAoGBAJf2QmHKtQXdKCjhPx1ottPb0PMTBH9A6FbaWMsTuKG/K3g6TG1Z1fkq\n\
2659 /Gz/PWk/eLI9TzFgqVAuPvr3q14a1aZeVUMTgo2oO5/y2UHe6VaJ+trqCTat3xlx\n\
2660 /mNbIK9HA2RgPC3gWfVLZQrY+gz3ASHHR5nXWHEyvpuZm7m3h+irAgEC\n\
2661 -----END DH PARAMETERS-----\n";
2662
2663 static const char dhpem2048[] =
2664 "-----BEGIN DH PARAMETERS-----\n\
2665 MIIBCAKCAQEA7ZKJNYJFVcs7+6J2WmkEYb8h86tT0s0h2v94GRFS8Q7B4lW9aG9o\n\
2666 AFO5Imov5Jo0H2XMWTKKvbHbSe3fpxJmw/0hBHAY8H/W91hRGXKCeyKpNBgdL8sh\n\
2667 z22SrkO2qCnHJ6PLAMXy5fsKpFmFor2tRfCzrfnggTXu2YOzzK7q62bmqVdmufEo\n\
2668 pT8igNcLpvZxk5uBDvhakObMym9mX3rAEBoe8PwttggMYiiw7NuJKO4MqD1llGkW\n\
2669 aVM8U2ATsCun1IKHrRxynkE1/MJ86VHeYYX8GZt2YA8z+GuzylIOKcMH6JAWzMwA\n\
2670 Gbatw6QwizOhr9iMjZ0B26TE3X8LvW84wwIBAg==\n\
2671 -----END DH PARAMETERS-----\n";
2672
2673 static const char dhpem4096[] =
2674 "-----BEGIN DH PARAMETERS-----\n\
2675 MIICCAKCAgEA/urRnb6vkPYc/KEGXWnbCIOaKitq7ySIq9dTH7s+Ri59zs77zty7\n\
2676 vfVlSe6VFTBWgYjD2XKUFmtqq6CqXMhVX5ElUDoYDpAyTH85xqNFLzFC7nKrff/H\n\
2677 TFKNttp22cZE9V0IPpzedPfnQkE7aUdmF9JnDyv21Z/818O93u1B4r0szdnmEvEF\n\
2678 bKuIxEHX+bp0ZR7RqE1AeifXGJX3d6tsd2PMAObxwwsv55RGkn50vHO4QxtTARr1\n\
2679 rRUV5j3B3oPMgC7Offxx+98Xn45B1/G0Prp11anDsR1PGwtaCYipqsvMwQUSJtyE\n\
2680 EOQWk+yFkeMe4vWv367eEi0Sd/wnC+TSXBE3pYvpYerJ8n1MceI5GQTdarJ77OW9\n\
2681 bGTHmxRsLSCM1jpLdPja5jjb4siAa6EHc4qN9c/iFKS3PQPJEnX7pXKBRs5f7AF3\n\
2682 W3RIGt+G9IVNZfXaS7Z/iCpgzgvKCs0VeqN38QsJGtC1aIkwOeyjPNy2G6jJ4yqH\n\
2683 ovXYt/0mc00vCWeSNS1wren0pR2EiLxX0ypjjgsU1mk/Z3b/+zVf7fZSIB+nDLjb\n\
2684 NPtUlJCVGnAeBK1J1nG3TQicqowOXoM6ISkdaXj5GPJdXHab2+S7cqhKGv5qC7rR\n\
2685 jT6sx7RUr0CNTxzLI7muV2/a4tGmj0PSdXQdsZ7tw7gbXlaWT1+MM2MCAQI=\n\
2686 -----END DH PARAMETERS-----\n";
2687
2688 static const struct dhinfo dhpem[] = {
2689         { 512, dhpem512, sizeof(dhpem512) },
2690         { 1024, dhpem1024, sizeof(dhpem1024) },
2691         { 2048, dhpem2048, sizeof(dhpem2048) },
2692         { 4096, dhpem4096, sizeof(dhpem4096) },
2693         { 0, NULL, 0 }
2694 };
2695
2696 static DH *
2697 tls_tmp_dh_cb( SSL *ssl, int is_export, int key_length )
2698 {
2699         struct dhplist *p = NULL;
2700         BIO *b = NULL;
2701         DH *dh = NULL;
2702         int i;
2703
2704         /* Do we have params of this length already? */
2705 #ifdef LDAP_R_COMPILE
2706         ldap_pvt_thread_mutex_lock( &tls_def_ctx_mutex );
2707 #endif
2708         for ( p = dhparams; p; p=p->next ) {
2709                 if ( p->keylength == key_length ) {
2710 #ifdef LDAP_R_COMPILE
2711                         ldap_pvt_thread_mutex_unlock( &tls_def_ctx_mutex );
2712 #endif
2713                         return p->param;
2714                 }
2715         }
2716
2717         /* No - check for hardcoded params */
2718
2719         for (i=0; dhpem[i].keylength; i++) {
2720                 if ( dhpem[i].keylength == key_length ) {
2721                         b = BIO_new_mem_buf( (char *)dhpem[i].pem, dhpem[i].size );
2722                         break;
2723                 }
2724         }
2725
2726         if ( b ) {
2727                 dh = PEM_read_bio_DHparams( b, NULL, NULL, NULL );
2728                 BIO_free( b );
2729         }
2730
2731         /* Generating on the fly is expensive/slow... */
2732         if ( !dh ) {
2733                 dh = DH_generate_parameters( key_length, DH_GENERATOR_2, NULL, NULL );
2734         }
2735         if ( dh ) {
2736                 p = LDAP_MALLOC( sizeof(struct dhplist) );
2737                 if ( p != NULL ) {
2738                         p->keylength = key_length;
2739                         p->param = dh;
2740                         p->next = dhparams;
2741                         dhparams = p;
2742                 }
2743         }
2744
2745 #ifdef LDAP_R_COMPILE
2746         ldap_pvt_thread_mutex_unlock( &tls_def_ctx_mutex );
2747 #endif
2748         return dh;
2749 }
2750 #endif
2751
2752 #endif /* HAVE_OPENSSL */
2753
2754 void *
2755 ldap_pvt_tls_sb_ctx( Sockbuf *sb )
2756 {
2757 #ifdef HAVE_TLS
2758         void                    *p;
2759
2760         if (HAS_TLS( sb )) {
2761                 ber_sockbuf_ctrl( sb, LBER_SB_OPT_GET_SSL, (void *)&p );
2762                 return p;
2763         }
2764 #endif
2765
2766         return NULL;
2767 }
2768
2769 int
2770 ldap_pvt_tls_get_strength( void *s )
2771 {
2772 #ifdef HAVE_OPENSSL
2773         SSL_CIPHER *c;
2774
2775         c = SSL_get_current_cipher((SSL *)s);
2776         return SSL_CIPHER_get_bits(c, NULL);
2777 #elif defined(HAVE_GNUTLS)
2778         tls_session *session = s;
2779         gnutls_cipher_algorithm_t c;
2780
2781         c = gnutls_cipher_get( session->session );
2782         return gnutls_cipher_get_key_size( c );
2783 #else
2784         return 0;
2785 #endif
2786 }
2787
2788
2789 int
2790 ldap_pvt_tls_get_my_dn( void *s, struct berval *dn, LDAPDN_rewrite_dummy *func, unsigned flags )
2791 {
2792 #ifdef HAVE_TLS
2793         struct berval der_dn;
2794         int rc;
2795 #ifdef HAVE_OPENSSL
2796         X509 *x;
2797         X509_NAME *xn;
2798
2799         x = SSL_get_certificate((SSL *)s);
2800
2801         if (!x) return LDAP_INVALID_CREDENTIALS;
2802
2803         xn = X509_get_subject_name(x);
2804         der_dn.bv_len = i2d_X509_NAME( xn, NULL );
2805         der_dn.bv_val = xn->bytes->data;
2806 #elif defined(HAVE_GNUTLS)
2807         tls_session *session = s;
2808         const gnutls_datum_t *x;
2809         struct berval bv;
2810
2811         x = gnutls_certificate_get_ours( session->session );
2812
2813         if (!x) return LDAP_INVALID_CREDENTIALS;
2814
2815         bv.bv_val = x->data;
2816         bv.bv_len = x->size;
2817
2818         x509_cert_get_dn( &bv, &der_dn, 1 );
2819 #endif
2820         rc = ldap_X509dn2bv(&der_dn, dn, (LDAPDN_rewrite_func *)func, flags );
2821         return rc;
2822 #else /* !HAVE_TLS */
2823         return LDAP_NOT_SUPPORTED;
2824 #endif
2825 }
2826
2827 int
2828 ldap_start_tls( LDAP *ld,
2829         LDAPControl **serverctrls,
2830         LDAPControl **clientctrls,
2831         int *msgidp )
2832 {
2833         return ldap_extended_operation( ld, LDAP_EXOP_START_TLS,
2834                 NULL, serverctrls, clientctrls, msgidp );
2835 }
2836
2837 int
2838 ldap_install_tls( LDAP *ld )
2839 {
2840 #ifndef HAVE_TLS
2841         return LDAP_NOT_SUPPORTED;
2842 #else
2843         if ( ldap_tls_inplace( ld ) ) {
2844                 return LDAP_LOCAL_ERROR;
2845         }
2846
2847         return ldap_int_tls_start( ld, ld->ld_defconn, NULL );
2848 #endif
2849 }
2850
2851 int
2852 ldap_start_tls_s ( LDAP *ld,
2853         LDAPControl **serverctrls,
2854         LDAPControl **clientctrls )
2855 {
2856 #ifndef HAVE_TLS
2857         return LDAP_NOT_SUPPORTED;
2858 #else
2859         int rc;
2860         char *rspoid = NULL;
2861         struct berval *rspdata = NULL;
2862
2863         /* XXYYZ: this initiates operation only on default connection! */
2864
2865         if ( ldap_tls_inplace( ld ) ) {
2866                 return LDAP_LOCAL_ERROR;
2867         }
2868
2869         rc = ldap_extended_operation_s( ld, LDAP_EXOP_START_TLS,
2870                 NULL, serverctrls, clientctrls, &rspoid, &rspdata );
2871
2872         if ( rspoid != NULL ) {
2873                 LDAP_FREE(rspoid);
2874         }
2875
2876         if ( rspdata != NULL ) {
2877                 ber_bvfree( rspdata );
2878         }
2879
2880         if ( rc == LDAP_SUCCESS ) {
2881                 rc = ldap_int_tls_start( ld, ld->ld_defconn, NULL );
2882         }
2883
2884         return rc;
2885 #endif
2886 }
2887
2888 /* These tags probably all belong in lber.h, but they're
2889  * not normally encountered when processing LDAP, so maybe
2890  * they belong somewhere else instead.
2891  */
2892
2893 #define LBER_TAG_OID            ((ber_tag_t) 0x06UL)
2894
2895 /* Tags for string types used in a DirectoryString.
2896  *
2897  * Note that IA5string is not one of the defined choices for
2898  * DirectoryString in X.520, but it gets used for email AVAs.
2899  */
2900 #define LBER_TAG_UTF8           ((ber_tag_t) 0x0cUL)
2901 #define LBER_TAG_PRINTABLE      ((ber_tag_t) 0x13UL)
2902 #define LBER_TAG_TELETEX        ((ber_tag_t) 0x14UL)
2903 #define LBER_TAG_IA5            ((ber_tag_t) 0x16UL)
2904 #define LBER_TAG_UNIVERSAL      ((ber_tag_t) 0x1cUL)
2905 #define LBER_TAG_BMP            ((ber_tag_t) 0x1eUL)
2906
2907 static oid_name *
2908 find_oid( struct berval *oid )
2909 {
2910         int i;
2911
2912         for ( i=0; !BER_BVISNULL( &oids[i].oid ); i++ ) {
2913                 if ( oids[i].oid.bv_len != oid->bv_len ) continue;
2914                 if ( !strcmp( oids[i].oid.bv_val, oid->bv_val ))
2915                         return &oids[i];
2916         }
2917         return NULL;
2918 }
2919
2920 /* Convert a structured DN from an X.509 certificate into an LDAPV3 DN.
2921  * x509_name must be raw DER. If func is non-NULL, the
2922  * constructed DN will use numeric OIDs to identify attributeTypes,
2923  * and the func() will be invoked to rewrite the DN with the given
2924  * flags.
2925  *
2926  * Otherwise the DN will use shortNames from a hardcoded table.
2927  */
2928 int
2929 ldap_X509dn2bv( void *x509_name, struct berval *bv, LDAPDN_rewrite_func *func,
2930         unsigned flags )
2931 {
2932         LDAPDN  newDN;
2933         LDAPRDN newRDN;
2934         LDAPAVA *newAVA, *baseAVA;
2935         BerElementBuffer berbuf;
2936         BerElement *ber = (BerElement *)&berbuf;
2937         char oids[8192], *oidptr = oids, *oidbuf = NULL;
2938         void *ptrs[2048];
2939         char *dn_end, *rdn_end;
2940         int i, navas, nrdns, rc = LDAP_SUCCESS;
2941         size_t dnsize, oidrem = sizeof(oids), oidsize = 0;
2942         int csize;
2943         ber_tag_t tag;
2944         ber_len_t len;
2945         oid_name *oidname;
2946
2947         struct berval   Oid, Val, oid2, *in = x509_name;
2948
2949         assert( bv != NULL );
2950
2951         bv->bv_len = 0;
2952         bv->bv_val = NULL;
2953
2954         navas = 0;
2955         nrdns = 0;
2956
2957         /* A DN is a SEQUENCE of RDNs. An RDN is a SET of AVAs.
2958          * An AVA is a SEQUENCE of attr and value.
2959          * Count the number of AVAs and RDNs
2960          */
2961         ber_init2( ber, in, LBER_USE_DER );
2962         tag = ber_peek_tag( ber, &len );
2963         if ( tag != LBER_SEQUENCE )
2964                 return LDAP_DECODING_ERROR;
2965
2966         for ( tag = ber_first_element( ber, &len, &dn_end );
2967                 tag == LBER_SET;
2968                 tag = ber_next_element( ber, &len, dn_end )) {
2969                 nrdns++;
2970                 for ( tag = ber_first_element( ber, &len, &rdn_end );
2971                         tag == LBER_SEQUENCE;
2972                         tag = ber_next_element( ber, &len, rdn_end )) {
2973                         tag = ber_skip_tag( ber, &len );
2974                         ber_skip_data( ber, len );
2975                         navas++;
2976                 }
2977         }
2978
2979         /* Allocate the DN/RDN/AVA stuff as a single block */
2980         dnsize = sizeof(LDAPRDN) * (nrdns+1);
2981         dnsize += sizeof(LDAPAVA *) * (navas+nrdns);
2982         dnsize += sizeof(LDAPAVA) * navas;
2983         if (dnsize > sizeof(ptrs)) {
2984                 newDN = (LDAPDN)LDAP_MALLOC( dnsize );
2985                 if ( newDN == NULL )
2986                         return LDAP_NO_MEMORY;
2987         } else {
2988                 newDN = (LDAPDN)(char *)ptrs;
2989         }
2990
2991         newDN[nrdns] = NULL;
2992         newRDN = (LDAPRDN)(newDN + nrdns+1);
2993         newAVA = (LDAPAVA *)(newRDN + navas + nrdns);
2994         baseAVA = newAVA;
2995
2996         /* Rewind and start extracting */
2997         ber_rewind( ber );
2998
2999         tag = ber_first_element( ber, &len, &dn_end );
3000         for ( i = nrdns - 1; i >= 0; i-- ) {
3001                 newDN[i] = newRDN;
3002
3003                 for ( tag = ber_first_element( ber, &len, &rdn_end );
3004                         tag == LBER_SEQUENCE;
3005                         tag = ber_next_element( ber, &len, rdn_end )) {
3006
3007                         *newRDN++ = newAVA;
3008                         tag = ber_skip_tag( ber, &len );
3009                         tag = ber_get_stringbv( ber, &Oid, LBER_BV_NOTERM );
3010                         if ( tag != LBER_TAG_OID ) {
3011                                 rc = LDAP_DECODING_ERROR;
3012                                 goto nomem;
3013                         }
3014
3015                         oid2.bv_val = oidptr;
3016                         oid2.bv_len = oidrem;
3017                         ber_decode_oid( &Oid, &oid2 );
3018                         oidname = find_oid( &oid2 );
3019                         if ( !oidname ) {
3020                                 newAVA->la_attr = oid2;
3021                                 oidptr += oid2.bv_len + 1;
3022                                 oidrem -= oid2.bv_len + 1;
3023
3024                                 /* Running out of OID buffer space? */
3025                                 if (oidrem < 128) {
3026                                         if ( oidsize == 0 ) {
3027                                                 oidsize = sizeof(oids) * 2;
3028                                                 oidrem = oidsize;
3029                                                 oidbuf = LDAP_MALLOC( oidsize );
3030                                                 if ( oidbuf == NULL ) goto nomem;
3031                                                 oidptr = oidbuf;
3032                                         } else {
3033                                                 char *old = oidbuf;
3034                                                 oidbuf = LDAP_REALLOC( oidbuf, oidsize*2 );
3035                                                 if ( oidbuf == NULL ) goto nomem;
3036                                                 /* Buffer moved! Fix AVA pointers */
3037                                                 if ( old != oidbuf ) {
3038                                                         LDAPAVA *a;
3039                                                         long dif = oidbuf - old;
3040
3041                                                         for (a=baseAVA; a<=newAVA; a++){
3042                                                                 if (a->la_attr.bv_val >= old &&
3043                                                                         a->la_attr.bv_val <= (old + oidsize))
3044                                                                         a->la_attr.bv_val += dif;
3045                                                         }
3046                                                 }
3047                                                 oidptr = oidbuf + oidsize - oidrem;
3048                                                 oidrem += oidsize;
3049                                                 oidsize *= 2;
3050                                         }
3051                                 }
3052                         } else {
3053                                 if ( func ) {
3054                                         newAVA->la_attr = oidname->oid;
3055                                 } else {
3056                                         newAVA->la_attr = oidname->name;
3057                                 }
3058                         }
3059                         tag = ber_get_stringbv( ber, &Val, LBER_BV_NOTERM );
3060                         switch(tag) {
3061                         case LBER_TAG_UNIVERSAL:
3062                                 /* This uses 32-bit ISO 10646-1 */
3063                                 csize = 4; goto to_utf8;
3064                         case LBER_TAG_BMP:
3065                                 /* This uses 16-bit ISO 10646-1 */
3066                                 csize = 2; goto to_utf8;
3067                         case LBER_TAG_TELETEX:
3068                                 /* This uses 8-bit, assume ISO 8859-1 */
3069                                 csize = 1;
3070 to_utf8:                rc = ldap_ucs_to_utf8s( &Val, csize, &newAVA->la_value );
3071                                 newAVA->la_flags |= LDAP_AVA_FREE_VALUE;
3072                                 if (rc != LDAP_SUCCESS) goto nomem;
3073                                 newAVA->la_flags = LDAP_AVA_NONPRINTABLE;
3074                                 break;
3075                         case LBER_TAG_UTF8:
3076                                 newAVA->la_flags = LDAP_AVA_NONPRINTABLE;
3077                                 /* This is already in UTF-8 encoding */
3078                         case LBER_TAG_IA5:
3079                         case LBER_TAG_PRINTABLE:
3080                                 /* These are always 7-bit strings */
3081                                 newAVA->la_value = Val;
3082                         default:
3083                                 ;
3084                         }
3085                         newAVA->la_private = NULL;
3086                         newAVA->la_flags = LDAP_AVA_STRING;
3087                         newAVA++;
3088                 }
3089                 *newRDN++ = NULL;
3090                 tag = ber_next_element( ber, &len, dn_end );
3091         }
3092
3093         if ( func ) {
3094                 rc = func( newDN, flags, NULL );
3095                 if ( rc != LDAP_SUCCESS )
3096                         goto nomem;
3097         }
3098
3099         rc = ldap_dn2bv_x( newDN, bv, LDAP_DN_FORMAT_LDAPV3, NULL );
3100
3101 nomem:
3102         for (;baseAVA < newAVA; baseAVA++) {
3103                 if (baseAVA->la_flags & LDAP_AVA_FREE_ATTR)
3104                         LDAP_FREE( baseAVA->la_attr.bv_val );
3105                 if (baseAVA->la_flags & LDAP_AVA_FREE_VALUE)
3106                         LDAP_FREE( baseAVA->la_value.bv_val );
3107         }
3108
3109         if ( oidsize != 0 )
3110                 LDAP_FREE( oidbuf );
3111         if ( newDN != (LDAPDN)(char *) ptrs )
3112                 LDAP_FREE( newDN );
3113         return rc;
3114 }
3115