1 /* $NetBSD: tls_g.c,v 1.1.1.1 2010/03/08 02:14:20 lukem Exp $ */ 2 3 /* tls_g.c - Handle tls/ssl using GNUTLS. */ 4 /* OpenLDAP: pkg/ldap/libraries/libldap/tls_g.c,v 1.6.2.7 2009/10/30 17:48:17 quanah Exp */ 5 /* This work is part of OpenLDAP Software <http://www.openldap.org/>. 6 * 7 * Copyright 2008-2009 The OpenLDAP Foundation. 8 * All rights reserved. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted only as authorized by the OpenLDAP 12 * Public License. 13 * 14 * A copy of this license is available in the file LICENSE in the 15 * top-level directory of the distribution or, alternatively, at 16 * <http://www.OpenLDAP.org/license.html>. 17 */ 18 /* ACKNOWLEDGEMENTS: GNUTLS support written by Howard Chu and 19 * Matt Backes; sponsored by The Written Word (thewrittenword.com) 20 * and Stanford University (stanford.edu). 21 */ 22 23 #include "portable.h" 24 25 #ifdef HAVE_GNUTLS 26 27 #include "ldap_config.h" 28 29 #include <stdio.h> 30 31 #include <ac/stdlib.h> 32 #include <ac/errno.h> 33 #include <ac/socket.h> 34 #include <ac/string.h> 35 #include <ac/ctype.h> 36 #include <ac/time.h> 37 #include <ac/unistd.h> 38 #include <ac/param.h> 39 #include <ac/dirent.h> 40 #include <sys/stat.h> 41 #include <fcntl.h> 42 43 #include "ldap-int.h" 44 #include "ldap-tls.h" 45 46 #ifdef LDAP_R_COMPILE 47 #include <ldap_pvt_thread.h> 48 #endif 49 50 #include <gnutls/gnutls.h> 51 #include <gnutls/x509.h> 52 #include <gcrypt.h> 53 54 #define DH_BITS (1024) 55 56 #if LIBGNUTLS_VERSION_NUMBER >= 0x020200 57 #define HAVE_CIPHERSUITES 1 58 /* This is a kludge. gcrypt 1.4.x has support. Recent GnuTLS requires gcrypt 1.4.x 59 * but that dependency isn't reflected in their configure script, resulting in 60 * build errors on older gcrypt. So, if they have a working build environment, 61 * assume gcrypt is new enough. 62 */ 63 #define HAVE_GCRYPT_RAND 1 64 #else 65 #undef HAVE_CIPHERSUITES 66 #undef HAVE_GCRYPT_RAND 67 #endif 68 69 #ifndef HAVE_CIPHERSUITES 70 /* Versions prior to 2.2.0 didn't handle cipher suites, so we had to 71 * kludge them ourselves. 72 */ 73 typedef struct tls_cipher_suite { 74 const char *name; 75 gnutls_kx_algorithm_t kx; 76 gnutls_cipher_algorithm_t cipher; 77 gnutls_mac_algorithm_t mac; 78 gnutls_protocol_t version; 79 } tls_cipher_suite; 80 #endif 81 82 typedef struct tlsg_ctx { 83 struct ldapoptions *lo; 84 gnutls_certificate_credentials_t cred; 85 gnutls_dh_params_t dh_params; 86 unsigned long verify_depth; 87 int refcount; 88 #ifdef HAVE_CIPHERSUITES 89 gnutls_priority_t prios; 90 #else 91 int *kx_list; 92 int *cipher_list; 93 int *mac_list; 94 #endif 95 #ifdef LDAP_R_COMPILE 96 ldap_pvt_thread_mutex_t ref_mutex; 97 #endif 98 } tlsg_ctx; 99 100 typedef struct tlsg_session { 101 gnutls_session_t session; 102 tlsg_ctx *ctx; 103 struct berval peer_der_dn; 104 } tlsg_session; 105 106 #ifndef HAVE_CIPHERSUITES 107 static tls_cipher_suite *tlsg_ciphers; 108 static int tlsg_n_ciphers; 109 #endif 110 111 static int tlsg_parse_ciphers( tlsg_ctx *ctx, char *suites ); 112 static int tlsg_cert_verify( tlsg_session *s ); 113 114 #ifdef LDAP_R_COMPILE 115 116 static int 117 tlsg_mutex_init( void **priv ) 118 { 119 int err = 0; 120 ldap_pvt_thread_mutex_t *lock = LDAP_MALLOC( sizeof( ldap_pvt_thread_mutex_t )); 121 122 if ( !lock ) 123 err = ENOMEM; 124 if ( !err ) { 125 err = ldap_pvt_thread_mutex_init( lock ); 126 if ( err ) 127 LDAP_FREE( lock ); 128 else 129 *priv = lock; 130 } 131 return err; 132 } 133 134 static int 135 tlsg_mutex_destroy( void **lock ) 136 { 137 int err = ldap_pvt_thread_mutex_destroy( *lock ); 138 LDAP_FREE( *lock ); 139 return err; 140 } 141 142 static int 143 tlsg_mutex_lock( void **lock ) 144 { 145 return ldap_pvt_thread_mutex_lock( *lock ); 146 } 147 148 static int 149 tlsg_mutex_unlock( void **lock ) 150 { 151 return ldap_pvt_thread_mutex_unlock( *lock ); 152 } 153 154 static struct gcry_thread_cbs tlsg_thread_cbs = { 155 GCRY_THREAD_OPTION_USER, 156 NULL, 157 tlsg_mutex_init, 158 tlsg_mutex_destroy, 159 tlsg_mutex_lock, 160 tlsg_mutex_unlock, 161 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL 162 }; 163 164 static void 165 tlsg_thr_init( void ) 166 { 167 gcry_control (GCRYCTL_SET_THREAD_CBS, &tlsg_thread_cbs); 168 } 169 #endif /* LDAP_R_COMPILE */ 170 171 /* 172 * Initialize TLS subsystem. Should be called only once. 173 */ 174 static int 175 tlsg_init( void ) 176 { 177 #ifdef HAVE_GCRYPT_RAND 178 struct ldapoptions *lo = LDAP_INT_GLOBAL_OPT(); 179 if ( lo->ldo_tls_randfile && 180 gcry_control( GCRYCTL_SET_RNDEGD_SOCKET, lo->ldo_tls_randfile )) { 181 Debug( LDAP_DEBUG_ANY, 182 "TLS: gcry_control GCRYCTL_SET_RNDEGD_SOCKET failed\n", 183 0, 0, 0); 184 return -1; 185 } 186 #endif 187 188 gnutls_global_init(); 189 190 #ifndef HAVE_CIPHERSUITES 191 /* GNUtls cipher suite handling: The library ought to parse suite 192 * names for us, but it doesn't. It will return a list of suite names 193 * that it supports, so we can do parsing ourselves. It ought to tell 194 * us how long the list is, but it doesn't do that either, so we just 195 * have to count it manually... 196 */ 197 { 198 int i = 0; 199 tls_cipher_suite *ptr, tmp; 200 char cs_id[2]; 201 202 while ( gnutls_cipher_suite_info( i, cs_id, &tmp.kx, &tmp.cipher, 203 &tmp.mac, &tmp.version )) 204 i++; 205 tlsg_n_ciphers = i; 206 207 /* Store a copy */ 208 tlsg_ciphers = LDAP_MALLOC(tlsg_n_ciphers * sizeof(tls_cipher_suite)); 209 if ( !tlsg_ciphers ) 210 return -1; 211 for ( i=0; i<tlsg_n_ciphers; i++ ) { 212 tlsg_ciphers[i].name = gnutls_cipher_suite_info( i, cs_id, 213 &tlsg_ciphers[i].kx, &tlsg_ciphers[i].cipher, &tlsg_ciphers[i].mac, 214 &tlsg_ciphers[i].version ); 215 } 216 } 217 #endif 218 return 0; 219 } 220 221 /* 222 * Tear down the TLS subsystem. Should only be called once. 223 */ 224 static void 225 tlsg_destroy( void ) 226 { 227 #ifndef HAVE_CIPHERSUITES 228 LDAP_FREE( tlsg_ciphers ); 229 tlsg_ciphers = NULL; 230 tlsg_n_ciphers = 0; 231 #endif 232 gnutls_global_deinit(); 233 } 234 235 static tls_ctx * 236 tlsg_ctx_new ( struct ldapoptions *lo ) 237 { 238 tlsg_ctx *ctx; 239 240 ctx = ber_memcalloc ( 1, sizeof (*ctx) ); 241 if ( ctx ) { 242 ctx->lo = lo; 243 if ( gnutls_certificate_allocate_credentials( &ctx->cred )) { 244 ber_memfree( ctx ); 245 return NULL; 246 } 247 ctx->refcount = 1; 248 #ifdef HAVE_CIPHERSUITES 249 gnutls_priority_init( &ctx->prios, "NORMAL", NULL ); 250 #endif 251 #ifdef LDAP_R_COMPILE 252 ldap_pvt_thread_mutex_init( &ctx->ref_mutex ); 253 #endif 254 } 255 return (tls_ctx *)ctx; 256 } 257 258 static void 259 tlsg_ctx_ref( tls_ctx *ctx ) 260 { 261 tlsg_ctx *c = (tlsg_ctx *)ctx; 262 #ifdef LDAP_R_COMPILE 263 ldap_pvt_thread_mutex_lock( &c->ref_mutex ); 264 #endif 265 c->refcount++; 266 #ifdef LDAP_R_COMPILE 267 ldap_pvt_thread_mutex_unlock( &c->ref_mutex ); 268 #endif 269 } 270 271 static void 272 tlsg_ctx_free ( tls_ctx *ctx ) 273 { 274 tlsg_ctx *c = (tlsg_ctx *)ctx; 275 int refcount; 276 277 if ( !c ) return; 278 279 #ifdef LDAP_R_COMPILE 280 ldap_pvt_thread_mutex_lock( &c->ref_mutex ); 281 #endif 282 refcount = --c->refcount; 283 #ifdef LDAP_R_COMPILE 284 ldap_pvt_thread_mutex_unlock( &c->ref_mutex ); 285 #endif 286 if ( refcount ) 287 return; 288 #ifdef HAVE_CIPHERSUITES 289 gnutls_priority_deinit( c->prios ); 290 #else 291 LDAP_FREE( c->kx_list ); 292 #endif 293 gnutls_certificate_free_credentials( c->cred ); 294 ber_memfree ( c ); 295 } 296 297 static int 298 tlsg_getfile( const char *path, gnutls_datum_t *buf ) 299 { 300 int rc = -1, fd; 301 struct stat st; 302 303 fd = open( path, O_RDONLY ); 304 if ( fd >= 0 && fstat( fd, &st ) == 0 ) { 305 buf->size = st.st_size; 306 buf->data = LDAP_MALLOC( st.st_size + 1 ); 307 if ( buf->data ) { 308 rc = read( fd, buf->data, st.st_size ); 309 close( fd ); 310 if ( rc < st.st_size ) 311 rc = -1; 312 else 313 rc = 0; 314 } 315 } 316 return rc; 317 } 318 319 /* This is the GnuTLS default */ 320 #define VERIFY_DEPTH 6 321 322 /* 323 * initialize a new TLS context 324 */ 325 static int 326 tlsg_ctx_init( struct ldapoptions *lo, struct ldaptls *lt, int is_server ) 327 { 328 tlsg_ctx *ctx = lo->ldo_tls_ctx; 329 int rc; 330 331 if ( lo->ldo_tls_ciphersuite && 332 tlsg_parse_ciphers( ctx, lt->lt_ciphersuite )) { 333 Debug( LDAP_DEBUG_ANY, 334 "TLS: could not set cipher list %s.\n", 335 lo->ldo_tls_ciphersuite, 0, 0 ); 336 return -1; 337 } 338 339 if (lo->ldo_tls_cacertdir != NULL) { 340 Debug( LDAP_DEBUG_ANY, 341 "TLS: warning: cacertdir not implemented for gnutls\n", 342 NULL, NULL, NULL ); 343 } 344 345 if (lo->ldo_tls_cacertfile != NULL) { 346 rc = gnutls_certificate_set_x509_trust_file( 347 ctx->cred, 348 lt->lt_cacertfile, 349 GNUTLS_X509_FMT_PEM ); 350 if ( rc < 0 ) return -1; 351 } 352 353 if ( lo->ldo_tls_certfile && lo->ldo_tls_keyfile ) { 354 gnutls_x509_privkey_t key; 355 gnutls_datum_t buf; 356 gnutls_x509_crt_t certs[VERIFY_DEPTH]; 357 unsigned int max = VERIFY_DEPTH; 358 359 rc = gnutls_x509_privkey_init( &key ); 360 if ( rc ) return -1; 361 362 /* OpenSSL builds the cert chain for us, but GnuTLS 363 * expects it to be present in the certfile. If it's 364 * not, we have to build it ourselves. So we have to 365 * do some special checks here... 366 */ 367 rc = tlsg_getfile( lt->lt_keyfile, &buf ); 368 if ( rc ) return -1; 369 rc = gnutls_x509_privkey_import( key, &buf, 370 GNUTLS_X509_FMT_PEM ); 371 LDAP_FREE( buf.data ); 372 if ( rc < 0 ) return rc; 373 374 rc = tlsg_getfile( lt->lt_certfile, &buf ); 375 if ( rc ) return -1; 376 rc = gnutls_x509_crt_list_import( certs, &max, &buf, 377 GNUTLS_X509_FMT_PEM, 0 ); 378 LDAP_FREE( buf.data ); 379 if ( rc < 0 ) return rc; 380 381 /* If there's only one cert and it's not self-signed, 382 * then we have to build the cert chain. 383 */ 384 if ( max == 1 && !gnutls_x509_crt_check_issuer( certs[0], certs[0] )) { 385 gnutls_x509_crt_t *cas; 386 unsigned int i, j, ncas; 387 388 gnutls_certificate_get_x509_cas( ctx->cred, &cas, &ncas ); 389 for ( i = 1; i<VERIFY_DEPTH; i++ ) { 390 for ( j = 0; j<ncas; j++ ) { 391 if ( gnutls_x509_crt_check_issuer( certs[i-1], cas[j] )) { 392 certs[i] = cas[j]; 393 max++; 394 /* If this CA is self-signed, we're done */ 395 if ( gnutls_x509_crt_check_issuer( cas[j], cas[j] )) 396 j = ncas; 397 break; 398 } 399 } 400 /* only continue if we found a CA and it was not self-signed */ 401 if ( j == ncas ) 402 break; 403 } 404 } 405 rc = gnutls_certificate_set_x509_key( ctx->cred, certs, max, key ); 406 if ( rc ) return -1; 407 } else if ( lo->ldo_tls_certfile || lo->ldo_tls_keyfile ) { 408 Debug( LDAP_DEBUG_ANY, 409 "TLS: only one of certfile and keyfile specified\n", 410 NULL, NULL, NULL ); 411 return -1; 412 } 413 414 if ( lo->ldo_tls_dhfile ) { 415 Debug( LDAP_DEBUG_ANY, 416 "TLS: warning: ignoring dhfile\n", 417 NULL, NULL, NULL ); 418 } 419 420 if ( lo->ldo_tls_crlfile ) { 421 rc = gnutls_certificate_set_x509_crl_file( 422 ctx->cred, 423 lt->lt_crlfile, 424 GNUTLS_X509_FMT_PEM ); 425 if ( rc < 0 ) return -1; 426 rc = 0; 427 } 428 429 /* FIXME: ITS#5992 - this should go be configurable, 430 * and V1 CA certs should be phased out ASAP. 431 */ 432 gnutls_certificate_set_verify_flags( ctx->cred, 433 GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT ); 434 435 if ( is_server ) { 436 gnutls_dh_params_init(&ctx->dh_params); 437 gnutls_dh_params_generate2(ctx->dh_params, DH_BITS); 438 } 439 return 0; 440 } 441 442 static tls_session * 443 tlsg_session_new ( tls_ctx * ctx, int is_server ) 444 { 445 tlsg_ctx *c = (tlsg_ctx *)ctx; 446 tlsg_session *session; 447 448 session = ber_memcalloc ( 1, sizeof (*session) ); 449 if ( !session ) 450 return NULL; 451 452 session->ctx = c; 453 gnutls_init( &session->session, is_server ? GNUTLS_SERVER : GNUTLS_CLIENT ); 454 #ifdef HAVE_CIPHERSUITES 455 gnutls_priority_set( session->session, c->prios ); 456 #else 457 gnutls_set_default_priority( session->session ); 458 if ( c->kx_list ) { 459 gnutls_kx_set_priority( session->session, c->kx_list ); 460 gnutls_cipher_set_priority( session->session, c->cipher_list ); 461 gnutls_mac_set_priority( session->session, c->mac_list ); 462 } 463 #endif 464 if ( c->cred ) 465 gnutls_credentials_set( session->session, GNUTLS_CRD_CERTIFICATE, c->cred ); 466 467 if ( is_server ) { 468 int flag = 0; 469 if ( c->lo->ldo_tls_require_cert ) { 470 flag = GNUTLS_CERT_REQUEST; 471 if ( c->lo->ldo_tls_require_cert == LDAP_OPT_X_TLS_DEMAND || 472 c->lo->ldo_tls_require_cert == LDAP_OPT_X_TLS_HARD ) 473 flag = GNUTLS_CERT_REQUIRE; 474 gnutls_certificate_server_set_request( session->session, flag ); 475 } 476 } 477 return (tls_session *)session; 478 } 479 480 static int 481 tlsg_session_accept( tls_session *session ) 482 { 483 tlsg_session *s = (tlsg_session *)session; 484 int rc; 485 486 rc = gnutls_handshake( s->session ); 487 if ( rc == 0 && s->ctx->lo->ldo_tls_require_cert != LDAP_OPT_X_TLS_NEVER ) { 488 const gnutls_datum_t *peer_cert_list; 489 unsigned int list_size; 490 491 peer_cert_list = gnutls_certificate_get_peers( s->session, 492 &list_size ); 493 if ( !peer_cert_list && s->ctx->lo->ldo_tls_require_cert == LDAP_OPT_X_TLS_TRY ) 494 rc = 0; 495 else { 496 rc = tlsg_cert_verify( s ); 497 if ( rc && s->ctx->lo->ldo_tls_require_cert == LDAP_OPT_X_TLS_ALLOW ) 498 rc = 0; 499 } 500 } 501 return rc; 502 } 503 504 static int 505 tlsg_session_connect( LDAP *ld, tls_session *session ) 506 { 507 return tlsg_session_accept( session); 508 } 509 510 static int 511 tlsg_session_upflags( Sockbuf *sb, tls_session *session, int rc ) 512 { 513 tlsg_session *s = (tlsg_session *)session; 514 515 if ( rc != GNUTLS_E_INTERRUPTED && rc != GNUTLS_E_AGAIN ) 516 return 0; 517 518 switch (gnutls_record_get_direction (s->session)) { 519 case 0: 520 sb->sb_trans_needs_read = 1; 521 return 1; 522 case 1: 523 sb->sb_trans_needs_write = 1; 524 return 1; 525 } 526 return 0; 527 } 528 529 static char * 530 tlsg_session_errmsg( tls_session *sess, int rc, char *buf, size_t len ) 531 { 532 return (char *)gnutls_strerror( rc ); 533 } 534 535 static void 536 tlsg_x509_cert_dn( struct berval *cert, struct berval *dn, int get_subject ) 537 { 538 BerElementBuffer berbuf; 539 BerElement *ber = (BerElement *)&berbuf; 540 ber_tag_t tag; 541 ber_len_t len; 542 ber_int_t i; 543 544 ber_init2( ber, cert, LBER_USE_DER ); 545 tag = ber_skip_tag( ber, &len ); /* Sequence */ 546 tag = ber_skip_tag( ber, &len ); /* Sequence */ 547 tag = ber_skip_tag( ber, &len ); /* Context + Constructed (version) */ 548 if ( tag == 0xa0 ) /* Version is optional */ 549 tag = ber_get_int( ber, &i ); /* Int: Version */ 550 tag = ber_get_int( ber, &i ); /* Int: Serial */ 551 tag = ber_skip_tag( ber, &len ); /* Sequence: Signature */ 552 ber_skip_data( ber, len ); 553 if ( !get_subject ) { 554 tag = ber_peek_tag( ber, &len ); /* Sequence: Issuer DN */ 555 } else { 556 tag = ber_skip_tag( ber, &len ); 557 ber_skip_data( ber, len ); 558 tag = ber_skip_tag( ber, &len ); /* Sequence: Validity */ 559 ber_skip_data( ber, len ); 560 tag = ber_peek_tag( ber, &len ); /* Sequence: Subject DN */ 561 } 562 len = ber_ptrlen( ber ); 563 dn->bv_val = cert->bv_val + len; 564 dn->bv_len = cert->bv_len - len; 565 } 566 567 static int 568 tlsg_session_my_dn( tls_session *session, struct berval *der_dn ) 569 { 570 tlsg_session *s = (tlsg_session *)session; 571 const gnutls_datum_t *x; 572 struct berval bv; 573 574 x = gnutls_certificate_get_ours( s->session ); 575 576 if (!x) return LDAP_INVALID_CREDENTIALS; 577 578 bv.bv_val = (char *) x->data; 579 bv.bv_len = x->size; 580 581 tlsg_x509_cert_dn( &bv, der_dn, 1 ); 582 return 0; 583 } 584 585 static int 586 tlsg_session_peer_dn( tls_session *session, struct berval *der_dn ) 587 { 588 tlsg_session *s = (tlsg_session *)session; 589 if ( !s->peer_der_dn.bv_val ) { 590 const gnutls_datum_t *peer_cert_list; 591 unsigned int list_size; 592 struct berval bv; 593 594 peer_cert_list = gnutls_certificate_get_peers( s->session, 595 &list_size ); 596 if ( !peer_cert_list ) return LDAP_INVALID_CREDENTIALS; 597 598 bv.bv_len = peer_cert_list->size; 599 bv.bv_val = (char *) peer_cert_list->data; 600 601 tlsg_x509_cert_dn( &bv, &s->peer_der_dn, 1 ); 602 } 603 *der_dn = s->peer_der_dn; 604 return 0; 605 } 606 607 /* what kind of hostname were we given? */ 608 #define IS_DNS 0 609 #define IS_IP4 1 610 #define IS_IP6 2 611 612 #define CN_OID "2.5.4.3" 613 614 static int 615 tlsg_session_chkhost( LDAP *ld, tls_session *session, const char *name_in ) 616 { 617 tlsg_session *s = (tlsg_session *)session; 618 int i, ret; 619 const gnutls_datum_t *peer_cert_list; 620 unsigned int list_size; 621 char altname[NI_MAXHOST]; 622 size_t altnamesize; 623 624 gnutls_x509_crt_t cert; 625 const char *name; 626 char *ptr; 627 char *domain = NULL; 628 #ifdef LDAP_PF_INET6 629 struct in6_addr addr; 630 #else 631 struct in_addr addr; 632 #endif 633 int len1 = 0, len2 = 0; 634 int ntype = IS_DNS; 635 636 if( ldap_int_hostname && 637 ( !name_in || !strcasecmp( name_in, "localhost" ) ) ) 638 { 639 name = ldap_int_hostname; 640 } else { 641 name = name_in; 642 } 643 644 peer_cert_list = gnutls_certificate_get_peers( s->session, 645 &list_size ); 646 if ( !peer_cert_list ) { 647 Debug( LDAP_DEBUG_ANY, 648 "TLS: unable to get peer certificate.\n", 649 0, 0, 0 ); 650 /* If this was a fatal condition, things would have 651 * aborted long before now. 652 */ 653 return LDAP_SUCCESS; 654 } 655 ret = gnutls_x509_crt_init( &cert ); 656 if ( ret < 0 ) 657 return LDAP_LOCAL_ERROR; 658 ret = gnutls_x509_crt_import( cert, peer_cert_list, GNUTLS_X509_FMT_DER ); 659 if ( ret ) { 660 gnutls_x509_crt_deinit( cert ); 661 return LDAP_LOCAL_ERROR; 662 } 663 664 #ifdef LDAP_PF_INET6 665 if (name[0] == '[' && strchr(name, ']')) { 666 char *n2 = ldap_strdup(name+1); 667 *strchr(n2, ']') = 0; 668 if (inet_pton(AF_INET6, n2, &addr)) 669 ntype = IS_IP6; 670 LDAP_FREE(n2); 671 } else 672 #endif 673 if ((ptr = strrchr(name, '.')) && isdigit((unsigned char)ptr[1])) { 674 if (inet_aton(name, (struct in_addr *)&addr)) ntype = IS_IP4; 675 } 676 677 if (ntype == IS_DNS) { 678 len1 = strlen(name); 679 domain = strchr(name, '.'); 680 if (domain) { 681 len2 = len1 - (domain-name); 682 } 683 } 684 685 for ( i=0, ret=0; ret >= 0; i++ ) { 686 altnamesize = sizeof(altname); 687 ret = gnutls_x509_crt_get_subject_alt_name( cert, i, 688 altname, &altnamesize, NULL ); 689 if ( ret < 0 ) break; 690 691 /* ignore empty */ 692 if ( altnamesize == 0 ) continue; 693 694 if ( ret == GNUTLS_SAN_DNSNAME ) { 695 if (ntype != IS_DNS) continue; 696 697 /* Is this an exact match? */ 698 if ((len1 == altnamesize) && !strncasecmp(name, altname, len1)) { 699 break; 700 } 701 702 /* Is this a wildcard match? */ 703 if (domain && (altname[0] == '*') && (altname[1] == '.') && 704 (len2 == altnamesize-1) && !strncasecmp(domain, &altname[1], len2)) 705 { 706 break; 707 } 708 } else if ( ret == GNUTLS_SAN_IPADDRESS ) { 709 if (ntype == IS_DNS) continue; 710 711 #ifdef LDAP_PF_INET6 712 if (ntype == IS_IP6 && altnamesize != sizeof(struct in6_addr)) { 713 continue; 714 } else 715 #endif 716 if (ntype == IS_IP4 && altnamesize != sizeof(struct in_addr)) { 717 continue; 718 } 719 if (!memcmp(altname, &addr, altnamesize)) { 720 break; 721 } 722 } 723 } 724 if ( ret >= 0 ) { 725 ret = LDAP_SUCCESS; 726 } else { 727 /* find the last CN */ 728 i=0; 729 do { 730 altnamesize = 0; 731 ret = gnutls_x509_crt_get_dn_by_oid( cert, CN_OID, 732 i, 1, altname, &altnamesize ); 733 if ( ret == GNUTLS_E_SHORT_MEMORY_BUFFER ) 734 i++; 735 else 736 break; 737 } while ( 1 ); 738 739 if ( i ) { 740 altnamesize = sizeof(altname); 741 ret = gnutls_x509_crt_get_dn_by_oid( cert, CN_OID, 742 i-1, 0, altname, &altnamesize ); 743 } 744 745 if ( ret < 0 ) { 746 Debug( LDAP_DEBUG_ANY, 747 "TLS: unable to get common name from peer certificate.\n", 748 0, 0, 0 ); 749 ret = LDAP_CONNECT_ERROR; 750 if ( ld->ld_error ) { 751 LDAP_FREE( ld->ld_error ); 752 } 753 ld->ld_error = LDAP_STRDUP( 754 _("TLS: unable to get CN from peer certificate")); 755 756 } else { 757 ret = LDAP_LOCAL_ERROR; 758 if ( !len1 ) len1 = strlen( name ); 759 if ( len1 == altnamesize && strncasecmp(name, altname, altnamesize) == 0 ) { 760 ret = LDAP_SUCCESS; 761 762 } else if (( altname[0] == '*' ) && ( altname[1] == '.' )) { 763 /* Is this a wildcard match? */ 764 if( domain && 765 (len2 == altnamesize-1) && !strncasecmp(domain, &altname[1], len2)) { 766 ret = LDAP_SUCCESS; 767 } 768 } 769 } 770 771 if( ret == LDAP_LOCAL_ERROR ) { 772 altname[altnamesize] = '\0'; 773 Debug( LDAP_DEBUG_ANY, "TLS: hostname (%s) does not match " 774 "common name in certificate (%s).\n", 775 name, altname, 0 ); 776 ret = LDAP_CONNECT_ERROR; 777 if ( ld->ld_error ) { 778 LDAP_FREE( ld->ld_error ); 779 } 780 ld->ld_error = LDAP_STRDUP( 781 _("TLS: hostname does not match CN in peer certificate")); 782 } 783 } 784 gnutls_x509_crt_deinit( cert ); 785 return ret; 786 } 787 788 static int 789 tlsg_session_strength( tls_session *session ) 790 { 791 tlsg_session *s = (tlsg_session *)session; 792 gnutls_cipher_algorithm_t c; 793 794 c = gnutls_cipher_get( s->session ); 795 return gnutls_cipher_get_key_size( c ) * 8; 796 } 797 798 /* suites is a string of colon-separated cipher suite names. */ 799 static int 800 tlsg_parse_ciphers( tlsg_ctx *ctx, char *suites ) 801 { 802 #ifdef HAVE_CIPHERSUITES 803 const char *err; 804 return gnutls_priority_init( &ctx->prios, suites, &err ); 805 #else 806 char *ptr, *end; 807 int i, j, len, num; 808 int *list, nkx = 0, ncipher = 0, nmac = 0; 809 int *kx, *cipher, *mac; 810 811 num = 0; 812 ptr = suites; 813 do { 814 end = strchr(ptr, ':'); 815 if ( end ) 816 len = end - ptr; 817 else 818 len = strlen(ptr); 819 for (i=0; i<tlsg_n_ciphers; i++) { 820 if ( !strncasecmp( tlsg_ciphers[i].name, ptr, len )) { 821 num++; 822 break; 823 } 824 } 825 if ( i == tlsg_n_ciphers ) { 826 /* unrecognized cipher suite */ 827 return -1; 828 } 829 ptr += len + 1; 830 } while (end); 831 832 /* Space for all 3 lists */ 833 list = LDAP_MALLOC( (num+1) * sizeof(int) * 3 ); 834 if ( !list ) 835 return -1; 836 kx = list; 837 cipher = kx+num+1; 838 mac = cipher+num+1; 839 840 ptr = suites; 841 do { 842 end = strchr(ptr, ':'); 843 if ( end ) 844 len = end - ptr; 845 else 846 len = strlen(ptr); 847 for (i=0; i<tlsg_n_ciphers; i++) { 848 /* For each cipher suite, insert its algorithms into 849 * their respective priority lists. Make sure they 850 * only appear once in each list. 851 */ 852 if ( !strncasecmp( tlsg_ciphers[i].name, ptr, len )) { 853 for (j=0; j<nkx; j++) 854 if ( kx[j] == tlsg_ciphers[i].kx ) 855 break; 856 if ( j == nkx ) 857 kx[nkx++] = tlsg_ciphers[i].kx; 858 for (j=0; j<ncipher; j++) 859 if ( cipher[j] == tlsg_ciphers[i].cipher ) 860 break; 861 if ( j == ncipher ) 862 cipher[ncipher++] = tlsg_ciphers[i].cipher; 863 for (j=0; j<nmac; j++) 864 if ( mac[j] == tlsg_ciphers[i].mac ) 865 break; 866 if ( j == nmac ) 867 mac[nmac++] = tlsg_ciphers[i].mac; 868 break; 869 } 870 } 871 ptr += len + 1; 872 } while (end); 873 kx[nkx] = 0; 874 cipher[ncipher] = 0; 875 mac[nmac] = 0; 876 ctx->kx_list = kx; 877 ctx->cipher_list = cipher; 878 ctx->mac_list = mac; 879 return 0; 880 #endif 881 } 882 883 /* 884 * TLS support for LBER Sockbufs 885 */ 886 887 struct tls_data { 888 tlsg_session *session; 889 Sockbuf_IO_Desc *sbiod; 890 }; 891 892 static ssize_t 893 tlsg_recv( gnutls_transport_ptr_t ptr, void *buf, size_t len ) 894 { 895 struct tls_data *p; 896 897 if ( buf == NULL || len <= 0 ) return 0; 898 899 p = (struct tls_data *)ptr; 900 901 if ( p == NULL || p->sbiod == NULL ) { 902 return 0; 903 } 904 905 return LBER_SBIOD_READ_NEXT( p->sbiod, buf, len ); 906 } 907 908 static ssize_t 909 tlsg_send( gnutls_transport_ptr_t ptr, const void *buf, size_t len ) 910 { 911 struct tls_data *p; 912 913 if ( buf == NULL || len <= 0 ) return 0; 914 915 p = (struct tls_data *)ptr; 916 917 if ( p == NULL || p->sbiod == NULL ) { 918 return 0; 919 } 920 921 return LBER_SBIOD_WRITE_NEXT( p->sbiod, (char *)buf, len ); 922 } 923 924 static int 925 tlsg_sb_setup( Sockbuf_IO_Desc *sbiod, void *arg ) 926 { 927 struct tls_data *p; 928 tlsg_session *session = arg; 929 930 assert( sbiod != NULL ); 931 932 p = LBER_MALLOC( sizeof( *p ) ); 933 if ( p == NULL ) { 934 return -1; 935 } 936 937 gnutls_transport_set_ptr( session->session, (gnutls_transport_ptr)p ); 938 gnutls_transport_set_pull_function( session->session, tlsg_recv ); 939 gnutls_transport_set_push_function( session->session, tlsg_send ); 940 p->session = session; 941 p->sbiod = sbiod; 942 sbiod->sbiod_pvt = p; 943 return 0; 944 } 945 946 static int 947 tlsg_sb_remove( Sockbuf_IO_Desc *sbiod ) 948 { 949 struct tls_data *p; 950 951 assert( sbiod != NULL ); 952 assert( sbiod->sbiod_pvt != NULL ); 953 954 p = (struct tls_data *)sbiod->sbiod_pvt; 955 gnutls_deinit ( p->session->session ); 956 LBER_FREE( p->session ); 957 LBER_FREE( sbiod->sbiod_pvt ); 958 sbiod->sbiod_pvt = NULL; 959 return 0; 960 } 961 962 static int 963 tlsg_sb_close( Sockbuf_IO_Desc *sbiod ) 964 { 965 struct tls_data *p; 966 967 assert( sbiod != NULL ); 968 assert( sbiod->sbiod_pvt != NULL ); 969 970 p = (struct tls_data *)sbiod->sbiod_pvt; 971 gnutls_bye ( p->session->session, GNUTLS_SHUT_RDWR ); 972 return 0; 973 } 974 975 static int 976 tlsg_sb_ctrl( Sockbuf_IO_Desc *sbiod, int opt, void *arg ) 977 { 978 struct tls_data *p; 979 980 assert( sbiod != NULL ); 981 assert( sbiod->sbiod_pvt != NULL ); 982 983 p = (struct tls_data *)sbiod->sbiod_pvt; 984 985 if ( opt == LBER_SB_OPT_GET_SSL ) { 986 *((tlsg_session **)arg) = p->session; 987 return 1; 988 989 } else if ( opt == LBER_SB_OPT_DATA_READY ) { 990 if( gnutls_record_check_pending( p->session->session ) > 0 ) { 991 return 1; 992 } 993 } 994 995 return LBER_SBIOD_CTRL_NEXT( sbiod, opt, arg ); 996 } 997 998 static ber_slen_t 999 tlsg_sb_read( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len) 1000 { 1001 struct tls_data *p; 1002 ber_slen_t ret; 1003 1004 assert( sbiod != NULL ); 1005 assert( SOCKBUF_VALID( sbiod->sbiod_sb ) ); 1006 1007 p = (struct tls_data *)sbiod->sbiod_pvt; 1008 1009 ret = gnutls_record_recv ( p->session->session, buf, len ); 1010 switch (ret) { 1011 case GNUTLS_E_INTERRUPTED: 1012 case GNUTLS_E_AGAIN: 1013 sbiod->sbiod_sb->sb_trans_needs_read = 1; 1014 sock_errset(EWOULDBLOCK); 1015 ret = 0; 1016 break; 1017 case GNUTLS_E_REHANDSHAKE: 1018 for ( ret = gnutls_handshake ( p->session->session ); 1019 ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN; 1020 ret = gnutls_handshake ( p->session->session ) ); 1021 sbiod->sbiod_sb->sb_trans_needs_read = 1; 1022 ret = 0; 1023 break; 1024 default: 1025 sbiod->sbiod_sb->sb_trans_needs_read = 0; 1026 } 1027 return ret; 1028 } 1029 1030 static ber_slen_t 1031 tlsg_sb_write( Sockbuf_IO_Desc *sbiod, void *buf, ber_len_t len) 1032 { 1033 struct tls_data *p; 1034 ber_slen_t ret; 1035 1036 assert( sbiod != NULL ); 1037 assert( SOCKBUF_VALID( sbiod->sbiod_sb ) ); 1038 1039 p = (struct tls_data *)sbiod->sbiod_pvt; 1040 1041 ret = gnutls_record_send ( p->session->session, (char *)buf, len ); 1042 1043 if ( ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN ) { 1044 sbiod->sbiod_sb->sb_trans_needs_write = 1; 1045 sock_errset(EWOULDBLOCK); 1046 ret = 0; 1047 } else { 1048 sbiod->sbiod_sb->sb_trans_needs_write = 0; 1049 } 1050 return ret; 1051 } 1052 1053 static Sockbuf_IO tlsg_sbio = 1054 { 1055 tlsg_sb_setup, /* sbi_setup */ 1056 tlsg_sb_remove, /* sbi_remove */ 1057 tlsg_sb_ctrl, /* sbi_ctrl */ 1058 tlsg_sb_read, /* sbi_read */ 1059 tlsg_sb_write, /* sbi_write */ 1060 tlsg_sb_close /* sbi_close */ 1061 }; 1062 1063 /* Certs are not automatically varified during the handshake */ 1064 static int 1065 tlsg_cert_verify( tlsg_session *ssl ) 1066 { 1067 unsigned int status = 0; 1068 int err; 1069 time_t now = time(0); 1070 time_t peertime; 1071 1072 err = gnutls_certificate_verify_peers2( ssl->session, &status ); 1073 if ( err < 0 ) { 1074 Debug( LDAP_DEBUG_ANY,"TLS: gnutls_certificate_verify_peers2 failed %d\n", 1075 err,0,0 ); 1076 return -1; 1077 } 1078 if ( status ) { 1079 Debug( LDAP_DEBUG_TRACE,"TLS: peer cert untrusted or revoked (0x%x)\n", 1080 status, 0,0 ); 1081 return -1; 1082 } 1083 peertime = gnutls_certificate_expiration_time_peers( ssl->session ); 1084 if ( peertime == (time_t) -1 ) { 1085 Debug( LDAP_DEBUG_ANY, "TLS: gnutls_certificate_expiration_time_peers failed\n", 1086 0, 0, 0 ); 1087 return -1; 1088 } 1089 if ( peertime < now ) { 1090 Debug( LDAP_DEBUG_ANY, "TLS: peer certificate is expired\n", 1091 0, 0, 0 ); 1092 return -1; 1093 } 1094 peertime = gnutls_certificate_activation_time_peers( ssl->session ); 1095 if ( peertime == (time_t) -1 ) { 1096 Debug( LDAP_DEBUG_ANY, "TLS: gnutls_certificate_activation_time_peers failed\n", 1097 0, 0, 0 ); 1098 return -1; 1099 } 1100 if ( peertime > now ) { 1101 Debug( LDAP_DEBUG_ANY, "TLS: peer certificate not yet active\n", 1102 0, 0, 0 ); 1103 return -1; 1104 } 1105 return 0; 1106 } 1107 1108 tls_impl ldap_int_tls_impl = { 1109 "GnuTLS", 1110 1111 tlsg_init, 1112 tlsg_destroy, 1113 1114 tlsg_ctx_new, 1115 tlsg_ctx_ref, 1116 tlsg_ctx_free, 1117 tlsg_ctx_init, 1118 1119 tlsg_session_new, 1120 tlsg_session_connect, 1121 tlsg_session_accept, 1122 tlsg_session_upflags, 1123 tlsg_session_errmsg, 1124 tlsg_session_my_dn, 1125 tlsg_session_peer_dn, 1126 tlsg_session_chkhost, 1127 tlsg_session_strength, 1128 1129 &tlsg_sbio, 1130 1131 #ifdef LDAP_R_COMPILE 1132 tlsg_thr_init, 1133 #else 1134 NULL, 1135 #endif 1136 1137 0 1138 }; 1139 1140 #endif /* HAVE_GNUTLS */ 1141