Diff for /libraries/libldap/tls_o.c between versions 1.2 and 1.17

version 1.2, 2008/12/05 08:00:24 version 1.17, 2010/04/13 20:17:57
Line 1 Line 1
 /* tls_o.c - Handle tls/ssl using SSLeay or OpenSSL */  /* tls_o.c - Handle tls/ssl using OpenSSL */
 /* $OpenLDAP: pkg/ldap/libraries/libldap/tls_o.c,v 1.1 2008/08/13 14:18:51 hyc Exp $ */  /* $OpenLDAP: pkg/ldap/libraries/libldap/tls_o.c,v 1.16 2010/04/12 01:21:05 hyc Exp $ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.  /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *   *
  * Copyright 2008 The OpenLDAP Foundation.   * Copyright 2008-2010 The OpenLDAP Foundation.
  * All rights reserved.   * All rights reserved.
  *   *
  * Redistribution and use in source and binary forms, with or without   * Redistribution and use in source and binary forms, with or without
Line 51 Line 51
 #include <ssl.h>  #include <ssl.h>
 #endif  #endif
   
 typedef struct tlso_ctx {  typedef SSL_CTX tlso_ctx;
         tls_impl *tc_impl;  typedef SSL tlso_session;
         SSL_CTX *tc_ctx;  
         int tc_refcnt;  
 } tlso_ctx;  
   
 typedef struct tlso_session {  
         tls_impl *ts_impl;  
         SSL *ts_session;  
 } tlso_session;  
   
 extern tls_impl ldap_int_openssl_impl;  
   
 static int  tlso_opt_trace = 1;  static int  tlso_opt_trace = 1;
   
Line 87  static int tlso_seed_PRNG( const char *r Line 77  static int tlso_seed_PRNG( const char *r
   
 #ifdef LDAP_R_COMPILE  #ifdef LDAP_R_COMPILE
 /*  /*
  * provide mutexes for the SSLeay library.   * provide mutexes for the OpenSSL library.
  */   */
 static ldap_pvt_thread_mutex_t  tlso_mutexes[CRYPTO_NUM_LOCKS];  static ldap_pvt_thread_mutex_t  tlso_mutexes[CRYPTO_NUM_LOCKS];
 static ldap_pvt_thread_mutex_t  tlso_dh_mutex;  static ldap_pvt_thread_mutex_t  tlso_dh_mutex;
Line 172  tlso_init( void ) Line 162  tlso_init( void )
 #endif  #endif
   
         SSL_load_error_strings();          SSL_load_error_strings();
         SSLeay_add_ssl_algorithms();          SSL_library_init();
           OpenSSL_add_all_digests();
   
         /* FIXME: mod_ssl does this */          /* FIXME: mod_ssl does this */
         X509V3_add_standard_extensions();          X509V3_add_standard_extensions();
Line 201  tlso_destroy( void ) Line 192  tlso_destroy( void )
 static tls_ctx *  static tls_ctx *
 tlso_ctx_new( struct ldapoptions *lo )  tlso_ctx_new( struct ldapoptions *lo )
 {  {
         tlso_ctx *ctx = LDAP_MALLOC( sizeof(tlso_ctx) );          return (tls_ctx *) SSL_CTX_new( SSLv23_method() );
         if ( ctx ) {  
                 ctx->tc_ctx = SSL_CTX_new( SSLv23_method() );  
                 if ( ctx->tc_ctx ) {  
                         ctx->tc_impl = &ldap_int_openssl_impl;  
                         ctx->tc_refcnt = 1;  
                 } else {  
                         LDAP_FREE( ctx );  
                         ctx = NULL;  
                 }  
         }  
         return (tls_ctx *)ctx;  
 }  }
   
 static void  static void
 tlso_ctx_ref( tls_ctx *ctx )  tlso_ctx_ref( tls_ctx *ctx )
 {  {
         tlso_ctx *c = (tlso_ctx *)ctx;          tlso_ctx *c = (tlso_ctx *)ctx;
         c->tc_refcnt++;          CRYPTO_add( &c->references, 1, CRYPTO_LOCK_SSL_CTX );
 }  }
   
 static void  static void
 tlso_ctx_free ( tls_ctx *ctx )  tlso_ctx_free ( tls_ctx *ctx )
 {  {
         tlso_ctx *c = (tlso_ctx *)ctx;          tlso_ctx *c = (tlso_ctx *)ctx;
         c->tc_refcnt--;          SSL_CTX_free( c );
         if ( c->tc_refcnt < 1 ) {  
                 SSL_CTX_free( c->tc_ctx );  
                 LDAP_FREE( c );  
         }  
 }  }
   
 /*  /*
Line 239  tlso_ctx_free ( tls_ctx *ctx ) Line 215  tlso_ctx_free ( tls_ctx *ctx )
 static int  static int
 tlso_ctx_init( struct ldapoptions *lo, struct ldaptls *lt, int is_server )  tlso_ctx_init( struct ldapoptions *lo, struct ldaptls *lt, int is_server )
 {  {
         tlso_ctx *tc = (tlso_ctx *)lo->ldo_tls_ctx;          tlso_ctx *ctx = (tlso_ctx *)lo->ldo_tls_ctx;
         SSL_CTX *ctx = tc->tc_ctx;  
         int i;          int i;
   
         if ( is_server ) {          if ( is_server ) {
Line 248  tlso_ctx_init( struct ldapoptions *lo, s Line 223  tlso_ctx_init( struct ldapoptions *lo, s
                         (const unsigned char *) "OpenLDAP", sizeof("OpenLDAP")-1 );                          (const unsigned char *) "OpenLDAP", sizeof("OpenLDAP")-1 );
         }          }
   
           if ( lo->ldo_tls_protocol_min > LDAP_OPT_X_TLS_PROTOCOL_SSL3 )
                   SSL_CTX_set_options( ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 );
           else if ( lo->ldo_tls_protocol_min > LDAP_OPT_X_TLS_PROTOCOL_SSL2 )
                   SSL_CTX_set_options( ctx, SSL_OP_NO_SSLv2 );
   
         if ( lo->ldo_tls_ciphersuite &&          if ( lo->ldo_tls_ciphersuite &&
                 !SSL_CTX_set_cipher_list( ctx, lt->lt_ciphersuite ) )                  !SSL_CTX_set_cipher_list( ctx, lt->lt_ciphersuite ) )
         {          {
Line 375  static tls_session * Line 355  static tls_session *
 tlso_session_new( tls_ctx *ctx, int is_server )  tlso_session_new( tls_ctx *ctx, int is_server )
 {  {
         tlso_ctx *c = (tlso_ctx *)ctx;          tlso_ctx *c = (tlso_ctx *)ctx;
         tlso_session *s = LDAP_MALLOC( sizeof(tlso_session));          return (tls_session *)SSL_new( c );
         if ( s ) {  
                 s->ts_session = SSL_new( c->tc_ctx );  
                 if ( s->ts_session ) {  
                         s->ts_impl = &ldap_int_openssl_impl;  
                 } else {  
                         LDAP_FREE( s );  
                         s = NULL;  
                 }  
         }  
         return (tls_session *)s;  
 }  }
   
 static int  static int
Line 394  tlso_session_connect( LDAP *ld, tls_sess Line 364  tlso_session_connect( LDAP *ld, tls_sess
         tlso_session *s = (tlso_session *)sess;          tlso_session *s = (tlso_session *)sess;
   
         /* Caller expects 0 = success, OpenSSL returns 1 = success */          /* Caller expects 0 = success, OpenSSL returns 1 = success */
         return SSL_connect( s->ts_session ) - 1;          return SSL_connect( s ) - 1;
 }  }
   
 static int  static int
Line 403  tlso_session_accept( tls_session *sess ) Line 373  tlso_session_accept( tls_session *sess )
         tlso_session *s = (tlso_session *)sess;          tlso_session *s = (tlso_session *)sess;
   
         /* Caller expects 0 = success, OpenSSL returns 1 = success */          /* Caller expects 0 = success, OpenSSL returns 1 = success */
         return SSL_accept( s->ts_session ) - 1;          return SSL_accept( s ) - 1;
 }  }
   
 static int  static int
Line 412  tlso_session_upflags( Sockbuf *sb, tls_s Line 382  tlso_session_upflags( Sockbuf *sb, tls_s
         tlso_session *s = (tlso_session *)sess;          tlso_session *s = (tlso_session *)sess;
   
         /* 1 was subtracted above, offset it back now */          /* 1 was subtracted above, offset it back now */
         rc = SSL_get_error(s->ts_session, rc+1);          rc = SSL_get_error(s, rc+1);
         if (rc == SSL_ERROR_WANT_READ) {          if (rc == SSL_ERROR_WANT_READ) {
                 sb->sb_trans_needs_read  = 1;                  sb->sb_trans_needs_read  = 1;
                 return 1;                  return 1;
Line 428  tlso_session_upflags( Sockbuf *sb, tls_s Line 398  tlso_session_upflags( Sockbuf *sb, tls_s
 }  }
   
 static char *  static char *
 tlso_session_errmsg( int rc, char *buf, size_t len )  tlso_session_errmsg( tls_session *sess, int rc, char *buf, size_t len )
 {  {
           char err[256] = "";
           const char *certerr=NULL;
           tlso_session *s = (tlso_session *)sess;
   
         rc = ERR_peek_error();          rc = ERR_peek_error();
         if ( rc ) {          if ( rc ) {
                 ERR_error_string_n( rc, buf, len );                  ERR_error_string_n( rc, err, sizeof(err) );
                   if ( ( ERR_GET_LIB(rc) == ERR_LIB_SSL ) && 
                                   ( ERR_GET_REASON(rc) == SSL_R_CERTIFICATE_VERIFY_FAILED ) ) {
                           int certrc = SSL_get_verify_result(s);
                           certerr = (char *)X509_verify_cert_error_string(certrc);
                   }
                   snprintf(buf, len, "%s%s%s%s", err, certerr ? " (" :"", 
                                   certerr ? certerr : "", certerr ?  ")" : "" );
                 return buf;                  return buf;
         }          }
         return NULL;          return NULL;
Line 445  tlso_session_my_dn( tls_session *sess, s Line 426  tlso_session_my_dn( tls_session *sess, s
         X509 *x;          X509 *x;
         X509_NAME *xn;          X509_NAME *xn;
   
         x = SSL_get_certificate( s->ts_session );          x = SSL_get_certificate( s );
   
         if (!x) return LDAP_INVALID_CREDENTIALS;          if (!x) return LDAP_INVALID_CREDENTIALS;
                   
         xn = X509_get_subject_name(x);          xn = X509_get_subject_name(x);
         der_dn->bv_len = i2d_X509_NAME( xn, NULL );          der_dn->bv_len = i2d_X509_NAME( xn, NULL );
         der_dn->bv_val = xn->bytes->data;          der_dn->bv_val = xn->bytes->data;
         X509_free(x);          /* Don't X509_free, the session is still using it */
         return 0;          return 0;
 }  }
   
Line 470  static int Line 451  static int
 tlso_session_peer_dn( tls_session *sess, struct berval *der_dn )  tlso_session_peer_dn( tls_session *sess, struct berval *der_dn )
 {  {
         tlso_session *s = (tlso_session *)sess;          tlso_session *s = (tlso_session *)sess;
         X509 *x = tlso_get_cert( s->ts_session );          X509 *x = tlso_get_cert( s );
         X509_NAME *xn;          X509_NAME *xn;
   
         if ( !x )          if ( !x )
Line 496  tlso_session_chkhost( LDAP *ld, tls_sess Line 477  tlso_session_chkhost( LDAP *ld, tls_sess
         X509 *x;          X509 *x;
         const char *name;          const char *name;
         char *ptr;          char *ptr;
         int ntype = IS_DNS;          int ntype = IS_DNS, nlen;
 #ifdef LDAP_PF_INET6  #ifdef LDAP_PF_INET6
         struct in6_addr addr;          struct in6_addr addr;
 #else  #else
Line 510  tlso_session_chkhost( LDAP *ld, tls_sess Line 491  tlso_session_chkhost( LDAP *ld, tls_sess
         } else {          } else {
                 name = name_in;                  name = name_in;
         }          }
           nlen = strlen(name);
   
         x = tlso_get_cert(s->ts_session);          x = tlso_get_cert(s);
         if (!x) {          if (!x) {
                 Debug( LDAP_DEBUG_ANY,                  Debug( LDAP_DEBUG_ANY,
                         "TLS: unable to get peer certificate.\n",                          "TLS: unable to get peer certificate.\n",
Line 525  tlso_session_chkhost( LDAP *ld, tls_sess Line 507  tlso_session_chkhost( LDAP *ld, tls_sess
 #ifdef LDAP_PF_INET6  #ifdef LDAP_PF_INET6
         if (name[0] == '[' && strchr(name, ']')) {          if (name[0] == '[' && strchr(name, ']')) {
                 char *n2 = ldap_strdup(name+1);                  char *n2 = ldap_strdup(name+1);
                 *strchr(n2, ']') = 2;                  *strchr(n2, ']') = 0;
                 if (inet_pton(AF_INET6, n2, &addr))                  if (inet_pton(AF_INET6, n2, &addr))
                         ntype = IS_IP6;                          ntype = IS_IP6;
                 LDAP_FREE(n2);                  LDAP_FREE(n2);
Line 543  tlso_session_chkhost( LDAP *ld, tls_sess Line 525  tlso_session_chkhost( LDAP *ld, tls_sess
                 ex = X509_get_ext(x, i);                  ex = X509_get_ext(x, i);
                 alt = X509V3_EXT_d2i(ex);                  alt = X509V3_EXT_d2i(ex);
                 if (alt) {                  if (alt) {
                         int n, len1 = 0, len2 = 0;                          int n, len2 = 0;
                         char *domain = NULL;                          char *domain = NULL;
                         GENERAL_NAME *gn;                          GENERAL_NAME *gn;
   
                         if (ntype == IS_DNS) {                          if (ntype == IS_DNS) {
                                 len1 = strlen(name);  
                                 domain = strchr(name, '.');                                  domain = strchr(name, '.');
                                 if (domain) {                                  if (domain) {
                                         len2 = len1 - (domain-name);                                          len2 = nlen - (domain-name);
                                 }                                  }
                         }                          }
                         n = sk_GENERAL_NAME_num(alt);                          n = sk_GENERAL_NAME_num(alt);
Line 569  tlso_session_chkhost( LDAP *ld, tls_sess Line 550  tlso_session_chkhost( LDAP *ld, tls_sess
                                         if (sl == 0) continue;                                          if (sl == 0) continue;
   
                                         /* Is this an exact match? */                                          /* Is this an exact match? */
                                         if ((len1 == sl) && !strncasecmp(name, sn, len1)) {                                          if ((nlen == sl) && !strncasecmp(name, sn, nlen)) {
                                                 break;                                                  break;
                                         }                                          }
   
Line 609  tlso_session_chkhost( LDAP *ld, tls_sess Line 590  tlso_session_chkhost( LDAP *ld, tls_sess
   
         if (ret != LDAP_SUCCESS) {          if (ret != LDAP_SUCCESS) {
                 X509_NAME *xn;                  X509_NAME *xn;
                 char buf[2048];                  X509_NAME_ENTRY *ne;
                 buf[0] = '\0';                  ASN1_OBJECT *obj;
                   ASN1_STRING *cn = NULL;
                   int navas;
   
                   /* find the last CN */
                   obj = OBJ_nid2obj( NID_commonName );
                   if ( !obj ) goto no_cn; /* should never happen */
   
                 xn = X509_get_subject_name(x);                  xn = X509_get_subject_name(x);
                 if( X509_NAME_get_text_by_NID( xn, NID_commonName,                  navas = X509_NAME_entry_count( xn );
                         buf, sizeof(buf)) == -1)                  for ( i=navas-1; i>=0; i-- ) {
                           ne = X509_NAME_get_entry( xn, i );
                           if ( !OBJ_cmp( ne->object, obj )) {
                                   cn = X509_NAME_ENTRY_get_data( ne );
                                   break;
                           }
                   }
   
                   if( !cn )
                 {                  {
   no_cn:
                         Debug( LDAP_DEBUG_ANY,                          Debug( LDAP_DEBUG_ANY,
                                 "TLS: unable to get common name from peer certificate.\n",                                  "TLS: unable to get common name from peer certificate.\n",
                                 0, 0, 0 );                                  0, 0, 0 );
Line 626  tlso_session_chkhost( LDAP *ld, tls_sess Line 622  tlso_session_chkhost( LDAP *ld, tls_sess
                         ld->ld_error = LDAP_STRDUP(                          ld->ld_error = LDAP_STRDUP(
                                 _("TLS: unable to get CN from peer certificate"));                                  _("TLS: unable to get CN from peer certificate"));
   
                 } else if (strcasecmp(name, buf) == 0 ) {                  } else if ( cn->length == nlen &&
                           strncasecmp( name, (char *) cn->data, nlen ) == 0 ) {
                         ret = LDAP_SUCCESS;                          ret = LDAP_SUCCESS;
   
                 } else if (( buf[0] == '*' ) && ( buf[1] == '.' )) {                  } else if (( cn->data[0] == '*' ) && ( cn->data[1] == '.' )) {
                         char *domain = strchr(name, '.');                          char *domain = strchr(name, '.');
                         if( domain ) {                          if( domain ) {
                                 size_t dlen = 0;                                  int dlen;
                                 size_t sl;  
   
                                 sl = strlen(name);                                  dlen = nlen - (domain-name);
                                 dlen = sl - (domain-name);  
                                 sl = strlen(buf);  
   
                                 /* Is this a wildcard match? */                                  /* Is this a wildcard match? */
                                 if ((dlen == sl-1) && !strncasecmp(domain, &buf[1], dlen)) {                                  if ((dlen == cn->length-1) &&
                                           !strncasecmp(domain, (char *) &cn->data[1], dlen)) {
                                         ret = LDAP_SUCCESS;                                          ret = LDAP_SUCCESS;
                                 }                                  }
                         }                          }
Line 648  tlso_session_chkhost( LDAP *ld, tls_sess Line 643  tlso_session_chkhost( LDAP *ld, tls_sess
   
                 if( ret == LDAP_LOCAL_ERROR ) {                  if( ret == LDAP_LOCAL_ERROR ) {
                         Debug( LDAP_DEBUG_ANY, "TLS: hostname (%s) does not match "                          Debug( LDAP_DEBUG_ANY, "TLS: hostname (%s) does not match "
                                 "common name in certificate (%s).\n",                                   "common name in certificate (%.*s).\n", 
                                 name, buf, 0 );                                  name, cn->length, cn->data );
                         ret = LDAP_CONNECT_ERROR;                          ret = LDAP_CONNECT_ERROR;
                         if ( ld->ld_error ) {                          if ( ld->ld_error ) {
                                 LDAP_FREE( ld->ld_error );                                  LDAP_FREE( ld->ld_error );
Line 668  tlso_session_strength( tls_session *sess Line 663  tlso_session_strength( tls_session *sess
         tlso_session *s = (tlso_session *)sess;          tlso_session *s = (tlso_session *)sess;
         SSL_CIPHER *c;          SSL_CIPHER *c;
   
         c = SSL_get_current_cipher(s->ts_session);          c = SSL_get_current_cipher(s);
         return SSL_CIPHER_get_bits(c, NULL);          return SSL_CIPHER_get_bits(c, NULL);
 }  }
   
Line 807  tlso_sb_setup( Sockbuf_IO_Desc *sbiod, v Line 802  tlso_sb_setup( Sockbuf_IO_Desc *sbiod, v
         p->sbiod = sbiod;          p->sbiod = sbiod;
         bio = BIO_new( &tlso_bio_method );          bio = BIO_new( &tlso_bio_method );
         bio->ptr = (void *)p;          bio->ptr = (void *)p;
         SSL_set_bio( p->session->ts_session, bio, bio );          SSL_set_bio( p->session, bio, bio );
         sbiod->sbiod_pvt = p;          sbiod->sbiod_pvt = p;
         return 0;          return 0;
 }  }
Line 821  tlso_sb_remove( Sockbuf_IO_Desc *sbiod ) Line 816  tlso_sb_remove( Sockbuf_IO_Desc *sbiod )
         assert( sbiod->sbiod_pvt != NULL );          assert( sbiod->sbiod_pvt != NULL );
   
         p = (struct tls_data *)sbiod->sbiod_pvt;          p = (struct tls_data *)sbiod->sbiod_pvt;
         SSL_free( p->session->ts_session );          SSL_free( p->session );
         LDAP_FREE( p->session );  
         LBER_FREE( sbiod->sbiod_pvt );          LBER_FREE( sbiod->sbiod_pvt );
         sbiod->sbiod_pvt = NULL;          sbiod->sbiod_pvt = NULL;
         return 0;          return 0;
Line 837  tlso_sb_close( Sockbuf_IO_Desc *sbiod ) Line 831  tlso_sb_close( Sockbuf_IO_Desc *sbiod )
         assert( sbiod->sbiod_pvt != NULL );          assert( sbiod->sbiod_pvt != NULL );
   
         p = (struct tls_data *)sbiod->sbiod_pvt;          p = (struct tls_data *)sbiod->sbiod_pvt;
         SSL_shutdown( p->session->ts_session );          SSL_shutdown( p->session );
         return 0;          return 0;
 }  }
   
Line 856  tlso_sb_ctrl( Sockbuf_IO_Desc *sbiod, in Line 850  tlso_sb_ctrl( Sockbuf_IO_Desc *sbiod, in
                 return 1;                  return 1;
   
         } else if ( opt == LBER_SB_OPT_DATA_READY ) {          } else if ( opt == LBER_SB_OPT_DATA_READY ) {
                 if( SSL_pending( p->session->ts_session ) > 0 ) {                  if( SSL_pending( p->session ) > 0 ) {
                         return 1;                          return 1;
                 }                  }
         }          }
Line 876  tlso_sb_read( Sockbuf_IO_Desc *sbiod, vo Line 870  tlso_sb_read( Sockbuf_IO_Desc *sbiod, vo
   
         p = (struct tls_data *)sbiod->sbiod_pvt;          p = (struct tls_data *)sbiod->sbiod_pvt;
   
         ret = SSL_read( p->session->ts_session, (char *)buf, len );          ret = SSL_read( p->session, (char *)buf, len );
 #ifdef HAVE_WINSOCK  #ifdef HAVE_WINSOCK
         errno = WSAGetLastError();          errno = WSAGetLastError();
 #endif  #endif
         err = SSL_get_error( p->session->ts_session, ret );          err = SSL_get_error( p->session, ret );
         if (err == SSL_ERROR_WANT_READ ) {          if (err == SSL_ERROR_WANT_READ ) {
                 sbiod->sbiod_sb->sb_trans_needs_read = 1;                  sbiod->sbiod_sb->sb_trans_needs_read = 1;
                 sock_errset(EWOULDBLOCK);                  sock_errset(EWOULDBLOCK);
Line 902  tlso_sb_write( Sockbuf_IO_Desc *sbiod, v Line 896  tlso_sb_write( Sockbuf_IO_Desc *sbiod, v
   
         p = (struct tls_data *)sbiod->sbiod_pvt;          p = (struct tls_data *)sbiod->sbiod_pvt;
   
         ret = SSL_write( p->session->ts_session, (char *)buf, len );          ret = SSL_write( p->session, (char *)buf, len );
 #ifdef HAVE_WINSOCK  #ifdef HAVE_WINSOCK
         errno = WSAGetLastError();          errno = WSAGetLastError();
 #endif  #endif
         err = SSL_get_error( p->session->ts_session, ret );          err = SSL_get_error( p->session, ret );
         if (err == SSL_ERROR_WANT_WRITE ) {          if (err == SSL_ERROR_WANT_WRITE ) {
                 sbiod->sbiod_sb->sb_trans_needs_write = 1;                  sbiod->sbiod_sb->sb_trans_needs_write = 1;
                 sock_errset(EWOULDBLOCK);                  sock_errset(EWOULDBLOCK);
Line 1083  static RSA * Line 1077  static RSA *
 tlso_tmp_rsa_cb( SSL *ssl, int is_export, int key_length )  tlso_tmp_rsa_cb( SSL *ssl, int is_export, int key_length )
 {  {
         RSA *tmp_rsa;          RSA *tmp_rsa;
   
         /* FIXME:  Pregenerate the key on startup */          /* FIXME:  Pregenerate the key on startup */
         /* FIXME:  Who frees the key? */          /* FIXME:  Who frees the key? */
   #if OPENSSL_VERSION_NUMBER >= 0x00908000
           BIGNUM *bn = BN_new();
           tmp_rsa = NULL;
           if ( bn ) {
                   if ( BN_set_word( bn, RSA_F4 )) {
                           tmp_rsa = RSA_new();
                           if ( tmp_rsa && !RSA_generate_key_ex( tmp_rsa, key_length, bn, NULL )) {
                                   RSA_free( tmp_rsa );
                                   tmp_rsa = NULL;
                           }
                   }
                   BN_free( bn );
           }
   #else
         tmp_rsa = RSA_generate_key( key_length, RSA_F4, NULL, NULL );          tmp_rsa = RSA_generate_key( key_length, RSA_F4, NULL, NULL );
   #endif
   
         if ( !tmp_rsa ) {          if ( !tmp_rsa ) {
                 Debug( LDAP_DEBUG_ANY,                  Debug( LDAP_DEBUG_ANY,
                         "TLS: Failed to generate temporary %d-bit %s RSA key\n",                          "TLS: Failed to generate temporary %d-bit %s RSA key\n",
                         key_length, is_export ? "export" : "domestic", 0 );                          key_length, is_export ? "export" : "domestic", 0 );
                 return NULL;  
         }          }
         return tmp_rsa;          return tmp_rsa;
 }  }
Line 1253  tlso_tmp_dh_cb( SSL *ssl, int is_export, Line 1260  tlso_tmp_dh_cb( SSL *ssl, int is_export,
         return dh;          return dh;
 }  }
   
 tls_impl ldap_int_openssl_impl = {  tls_impl ldap_int_tls_impl = {
         "OpenSSL",          "OpenSSL",
   
         tlso_init,          tlso_init,

Removed from v.1.2  
changed lines
  Added in v.1.17


______________
© Copyright 1998-2020, OpenLDAP Foundation, info@OpenLDAP.org