1 /* 2 * SSL/TLS interface functions for GnuTLS 3 * Copyright (c) 2004-2011, Jouni Malinen <j@w1.fi> 4 * 5 * This software may be distributed under the terms of the BSD license. 6 * See README for more details. 7 */ 8 9 #include "includes.h" 10 #include <gnutls/gnutls.h> 11 #include <gnutls/x509.h> 12 #ifdef PKCS12_FUNCS 13 #include <gnutls/pkcs12.h> 14 #endif /* PKCS12_FUNCS */ 15 16 #include "common.h" 17 #include "tls.h" 18 19 20 #define WPA_TLS_RANDOM_SIZE 32 21 #define WPA_TLS_MASTER_SIZE 48 22 23 24 #if LIBGNUTLS_VERSION_NUMBER < 0x010302 25 /* GnuTLS 1.3.2 added functions for using master secret. Older versions require 26 * use of internal structures to get the master_secret and 27 * {server,client}_random. 28 */ 29 #define GNUTLS_INTERNAL_STRUCTURE_HACK 30 #endif /* LIBGNUTLS_VERSION_NUMBER < 0x010302 */ 31 32 33 #ifdef GNUTLS_INTERNAL_STRUCTURE_HACK 34 /* 35 * It looks like gnutls does not provide access to client/server_random and 36 * master_key. This is somewhat unfortunate since these are needed for key 37 * derivation in EAP-{TLS,TTLS,PEAP,FAST}. Workaround for now is a horrible 38 * hack that copies the gnutls_session_int definition from gnutls_int.h so that 39 * we can get the needed information. 40 */ 41 42 typedef u8 uint8; 43 typedef unsigned char opaque; 44 typedef struct { 45 uint8 suite[2]; 46 } cipher_suite_st; 47 48 typedef struct { 49 gnutls_connection_end_t entity; 50 gnutls_kx_algorithm_t kx_algorithm; 51 gnutls_cipher_algorithm_t read_bulk_cipher_algorithm; 52 gnutls_mac_algorithm_t read_mac_algorithm; 53 gnutls_compression_method_t read_compression_algorithm; 54 gnutls_cipher_algorithm_t write_bulk_cipher_algorithm; 55 gnutls_mac_algorithm_t write_mac_algorithm; 56 gnutls_compression_method_t write_compression_algorithm; 57 cipher_suite_st current_cipher_suite; 58 opaque master_secret[WPA_TLS_MASTER_SIZE]; 59 opaque client_random[WPA_TLS_RANDOM_SIZE]; 60 opaque server_random[WPA_TLS_RANDOM_SIZE]; 61 /* followed by stuff we are not interested in */ 62 } security_parameters_st; 63 64 struct gnutls_session_int { 65 security_parameters_st security_parameters; 66 /* followed by things we are not interested in */ 67 }; 68 #endif /* LIBGNUTLS_VERSION_NUMBER < 0x010302 */ 69 70 static int tls_gnutls_ref_count = 0; 71 72 struct tls_global { 73 /* Data for session resumption */ 74 void *session_data; 75 size_t session_data_size; 76 77 int server; 78 79 int params_set; 80 gnutls_certificate_credentials_t xcred; 81 }; 82 83 struct tls_connection { 84 gnutls_session session; 85 char *subject_match, *altsubject_match; 86 int read_alerts, write_alerts, failed; 87 88 u8 *pre_shared_secret; 89 size_t pre_shared_secret_len; 90 int established; 91 int verify_peer; 92 93 struct wpabuf *push_buf; 94 struct wpabuf *pull_buf; 95 const u8 *pull_buf_offset; 96 97 int params_set; 98 gnutls_certificate_credentials_t xcred; 99 }; 100 101 102 static void tls_log_func(int level, const char *msg) 103 { 104 char *s, *pos; 105 if (level == 6 || level == 7) { 106 /* These levels seem to be mostly I/O debug and msg dumps */ 107 return; 108 } 109 110 s = os_strdup(msg); 111 if (s == NULL) 112 return; 113 114 pos = s; 115 while (*pos != '\0') { 116 if (*pos == '\n') { 117 *pos = '\0'; 118 break; 119 } 120 pos++; 121 } 122 wpa_printf(level > 3 ? MSG_MSGDUMP : MSG_DEBUG, 123 "gnutls<%d> %s", level, s); 124 os_free(s); 125 } 126 127 128 void * tls_init(const struct tls_config *conf) 129 { 130 struct tls_global *global; 131 132 #ifdef GNUTLS_INTERNAL_STRUCTURE_HACK 133 /* Because of the horrible hack to get master_secret and client/server 134 * random, we need to make sure that the gnutls version is something 135 * that is expected to have same structure definition for the session 136 * data.. */ 137 const char *ver; 138 const char *ok_ver[] = { "1.2.3", "1.2.4", "1.2.5", "1.2.6", "1.2.9", 139 "1.3.2", 140 NULL }; 141 int i; 142 #endif /* GNUTLS_INTERNAL_STRUCTURE_HACK */ 143 144 global = os_zalloc(sizeof(*global)); 145 if (global == NULL) 146 return NULL; 147 148 if (tls_gnutls_ref_count == 0 && gnutls_global_init() < 0) { 149 os_free(global); 150 return NULL; 151 } 152 tls_gnutls_ref_count++; 153 154 #ifdef GNUTLS_INTERNAL_STRUCTURE_HACK 155 ver = gnutls_check_version(NULL); 156 if (ver == NULL) { 157 tls_deinit(global); 158 return NULL; 159 } 160 wpa_printf(MSG_DEBUG, "%s - gnutls version %s", __func__, ver); 161 for (i = 0; ok_ver[i]; i++) { 162 if (strcmp(ok_ver[i], ver) == 0) 163 break; 164 } 165 if (ok_ver[i] == NULL) { 166 wpa_printf(MSG_INFO, "Untested gnutls version %s - this needs " 167 "to be tested and enabled in tls_gnutls.c", ver); 168 tls_deinit(global); 169 return NULL; 170 } 171 #endif /* GNUTLS_INTERNAL_STRUCTURE_HACK */ 172 173 gnutls_global_set_log_function(tls_log_func); 174 if (wpa_debug_show_keys) 175 gnutls_global_set_log_level(11); 176 return global; 177 } 178 179 180 void tls_deinit(void *ssl_ctx) 181 { 182 struct tls_global *global = ssl_ctx; 183 if (global) { 184 if (global->params_set) 185 gnutls_certificate_free_credentials(global->xcred); 186 os_free(global->session_data); 187 os_free(global); 188 } 189 190 tls_gnutls_ref_count--; 191 if (tls_gnutls_ref_count == 0) 192 gnutls_global_deinit(); 193 } 194 195 196 int tls_get_errors(void *ssl_ctx) 197 { 198 return 0; 199 } 200 201 202 static ssize_t tls_pull_func(gnutls_transport_ptr ptr, void *buf, 203 size_t len) 204 { 205 struct tls_connection *conn = (struct tls_connection *) ptr; 206 const u8 *end; 207 if (conn->pull_buf == NULL) { 208 errno = EWOULDBLOCK; 209 return -1; 210 } 211 212 end = wpabuf_head_u8(conn->pull_buf) + wpabuf_len(conn->pull_buf); 213 if ((size_t) (end - conn->pull_buf_offset) < len) 214 len = end - conn->pull_buf_offset; 215 os_memcpy(buf, conn->pull_buf_offset, len); 216 conn->pull_buf_offset += len; 217 if (conn->pull_buf_offset == end) { 218 wpa_printf(MSG_DEBUG, "%s - pull_buf consumed", __func__); 219 wpabuf_free(conn->pull_buf); 220 conn->pull_buf = NULL; 221 conn->pull_buf_offset = NULL; 222 } else { 223 wpa_printf(MSG_DEBUG, "%s - %lu bytes remaining in pull_buf", 224 __func__, 225 (unsigned long) (end - conn->pull_buf_offset)); 226 } 227 return len; 228 } 229 230 231 static ssize_t tls_push_func(gnutls_transport_ptr ptr, const void *buf, 232 size_t len) 233 { 234 struct tls_connection *conn = (struct tls_connection *) ptr; 235 236 if (wpabuf_resize(&conn->push_buf, len) < 0) { 237 errno = ENOMEM; 238 return -1; 239 } 240 wpabuf_put_data(conn->push_buf, buf, len); 241 242 return len; 243 } 244 245 246 static int tls_gnutls_init_session(struct tls_global *global, 247 struct tls_connection *conn) 248 { 249 #if LIBGNUTLS_VERSION_NUMBER >= 0x020200 250 const char *err; 251 #else /* LIBGNUTLS_VERSION_NUMBER >= 0x020200 */ 252 const int cert_types[2] = { GNUTLS_CRT_X509, 0 }; 253 const int protos[2] = { GNUTLS_TLS1, 0 }; 254 #endif /* LIBGNUTLS_VERSION_NUMBER < 0x020200 */ 255 int ret; 256 257 ret = gnutls_init(&conn->session, 258 global->server ? GNUTLS_SERVER : GNUTLS_CLIENT); 259 if (ret < 0) { 260 wpa_printf(MSG_INFO, "TLS: Failed to initialize new TLS " 261 "connection: %s", gnutls_strerror(ret)); 262 return -1; 263 } 264 265 ret = gnutls_set_default_priority(conn->session); 266 if (ret < 0) 267 goto fail; 268 269 #if LIBGNUTLS_VERSION_NUMBER >= 0x020200 270 ret = gnutls_priority_set_direct(conn->session, "NORMAL:-VERS-SSL3.0", 271 &err); 272 if (ret < 0) { 273 wpa_printf(MSG_ERROR, "GnuTLS: Priority string failure at " 274 "'%s'", err); 275 goto fail; 276 } 277 #else /* LIBGNUTLS_VERSION_NUMBER >= 0x020200 */ 278 ret = gnutls_certificate_type_set_priority(conn->session, cert_types); 279 if (ret < 0) 280 goto fail; 281 282 ret = gnutls_protocol_set_priority(conn->session, protos); 283 if (ret < 0) 284 goto fail; 285 #endif /* LIBGNUTLS_VERSION_NUMBER < 0x020200 */ 286 287 gnutls_transport_set_pull_function(conn->session, tls_pull_func); 288 gnutls_transport_set_push_function(conn->session, tls_push_func); 289 gnutls_transport_set_ptr(conn->session, (gnutls_transport_ptr) conn); 290 291 return 0; 292 293 fail: 294 wpa_printf(MSG_INFO, "TLS: Failed to setup new TLS connection: %s", 295 gnutls_strerror(ret)); 296 gnutls_deinit(conn->session); 297 return -1; 298 } 299 300 301 struct tls_connection * tls_connection_init(void *ssl_ctx) 302 { 303 struct tls_global *global = ssl_ctx; 304 struct tls_connection *conn; 305 int ret; 306 307 conn = os_zalloc(sizeof(*conn)); 308 if (conn == NULL) 309 return NULL; 310 311 if (tls_gnutls_init_session(global, conn)) { 312 os_free(conn); 313 return NULL; 314 } 315 316 if (global->params_set) { 317 ret = gnutls_credentials_set(conn->session, 318 GNUTLS_CRD_CERTIFICATE, 319 global->xcred); 320 if (ret < 0) { 321 wpa_printf(MSG_INFO, "Failed to configure " 322 "credentials: %s", gnutls_strerror(ret)); 323 os_free(conn); 324 return NULL; 325 } 326 } 327 328 if (gnutls_certificate_allocate_credentials(&conn->xcred)) { 329 os_free(conn); 330 return NULL; 331 } 332 333 return conn; 334 } 335 336 337 void tls_connection_deinit(void *ssl_ctx, struct tls_connection *conn) 338 { 339 if (conn == NULL) 340 return; 341 342 gnutls_certificate_free_credentials(conn->xcred); 343 gnutls_deinit(conn->session); 344 os_free(conn->pre_shared_secret); 345 os_free(conn->subject_match); 346 os_free(conn->altsubject_match); 347 wpabuf_free(conn->push_buf); 348 wpabuf_free(conn->pull_buf); 349 os_free(conn); 350 } 351 352 353 int tls_connection_established(void *ssl_ctx, struct tls_connection *conn) 354 { 355 return conn ? conn->established : 0; 356 } 357 358 359 int tls_connection_shutdown(void *ssl_ctx, struct tls_connection *conn) 360 { 361 struct tls_global *global = ssl_ctx; 362 int ret; 363 364 if (conn == NULL) 365 return -1; 366 367 /* Shutdown previous TLS connection without notifying the peer 368 * because the connection was already terminated in practice 369 * and "close notify" shutdown alert would confuse AS. */ 370 gnutls_bye(conn->session, GNUTLS_SHUT_RDWR); 371 wpabuf_free(conn->push_buf); 372 conn->push_buf = NULL; 373 conn->established = 0; 374 375 gnutls_deinit(conn->session); 376 if (tls_gnutls_init_session(global, conn)) { 377 wpa_printf(MSG_INFO, "GnuTLS: Failed to preparare new session " 378 "for session resumption use"); 379 return -1; 380 } 381 382 ret = gnutls_credentials_set(conn->session, GNUTLS_CRD_CERTIFICATE, 383 conn->params_set ? conn->xcred : 384 global->xcred); 385 if (ret < 0) { 386 wpa_printf(MSG_INFO, "GnuTLS: Failed to configure credentials " 387 "for session resumption: %s", gnutls_strerror(ret)); 388 return -1; 389 } 390 391 if (global->session_data) { 392 ret = gnutls_session_set_data(conn->session, 393 global->session_data, 394 global->session_data_size); 395 if (ret < 0) { 396 wpa_printf(MSG_INFO, "GnuTLS: Failed to set session " 397 "data: %s", gnutls_strerror(ret)); 398 return -1; 399 } 400 } 401 402 return 0; 403 } 404 405 406 #if 0 407 static int tls_match_altsubject(X509 *cert, const char *match) 408 { 409 GENERAL_NAME *gen; 410 char *field, *tmp; 411 void *ext; 412 int i, found = 0; 413 size_t len; 414 415 ext = X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL); 416 417 for (i = 0; ext && i < sk_GENERAL_NAME_num(ext); i++) { 418 gen = sk_GENERAL_NAME_value(ext, i); 419 switch (gen->type) { 420 case GEN_EMAIL: 421 field = "EMAIL"; 422 break; 423 case GEN_DNS: 424 field = "DNS"; 425 break; 426 case GEN_URI: 427 field = "URI"; 428 break; 429 default: 430 field = NULL; 431 wpa_printf(MSG_DEBUG, "TLS: altSubjectName: " 432 "unsupported type=%d", gen->type); 433 break; 434 } 435 436 if (!field) 437 continue; 438 439 wpa_printf(MSG_DEBUG, "TLS: altSubjectName: %s:%s", 440 field, gen->d.ia5->data); 441 len = os_strlen(field) + 1 + 442 strlen((char *) gen->d.ia5->data) + 1; 443 tmp = os_malloc(len); 444 if (tmp == NULL) 445 continue; 446 snprintf(tmp, len, "%s:%s", field, gen->d.ia5->data); 447 if (strstr(tmp, match)) 448 found++; 449 os_free(tmp); 450 } 451 452 return found; 453 } 454 #endif 455 456 457 #if 0 458 static int tls_verify_cb(int preverify_ok, X509_STORE_CTX *x509_ctx) 459 { 460 char buf[256]; 461 X509 *err_cert; 462 int err, depth; 463 SSL *ssl; 464 struct tls_connection *conn; 465 char *match, *altmatch; 466 467 err_cert = X509_STORE_CTX_get_current_cert(x509_ctx); 468 err = X509_STORE_CTX_get_error(x509_ctx); 469 depth = X509_STORE_CTX_get_error_depth(x509_ctx); 470 ssl = X509_STORE_CTX_get_ex_data(x509_ctx, 471 SSL_get_ex_data_X509_STORE_CTX_idx()); 472 X509_NAME_oneline(X509_get_subject_name(err_cert), buf, sizeof(buf)); 473 474 conn = SSL_get_app_data(ssl); 475 match = conn ? conn->subject_match : NULL; 476 altmatch = conn ? conn->altsubject_match : NULL; 477 478 if (!preverify_ok) { 479 wpa_printf(MSG_WARNING, "TLS: Certificate verification failed," 480 " error %d (%s) depth %d for '%s'", err, 481 X509_verify_cert_error_string(err), depth, buf); 482 } else { 483 wpa_printf(MSG_DEBUG, "TLS: tls_verify_cb - " 484 "preverify_ok=%d err=%d (%s) depth=%d buf='%s'", 485 preverify_ok, err, 486 X509_verify_cert_error_string(err), depth, buf); 487 if (depth == 0 && match && strstr(buf, match) == NULL) { 488 wpa_printf(MSG_WARNING, "TLS: Subject '%s' did not " 489 "match with '%s'", buf, match); 490 preverify_ok = 0; 491 } else if (depth == 0 && altmatch && 492 !tls_match_altsubject(err_cert, altmatch)) { 493 wpa_printf(MSG_WARNING, "TLS: altSubjectName match " 494 "'%s' not found", altmatch); 495 preverify_ok = 0; 496 } 497 } 498 499 return preverify_ok; 500 } 501 #endif 502 503 504 int tls_connection_set_params(void *tls_ctx, struct tls_connection *conn, 505 const struct tls_connection_params *params) 506 { 507 int ret; 508 509 if (conn == NULL || params == NULL) 510 return -1; 511 512 os_free(conn->subject_match); 513 conn->subject_match = NULL; 514 if (params->subject_match) { 515 conn->subject_match = os_strdup(params->subject_match); 516 if (conn->subject_match == NULL) 517 return -1; 518 } 519 520 os_free(conn->altsubject_match); 521 conn->altsubject_match = NULL; 522 if (params->altsubject_match) { 523 conn->altsubject_match = os_strdup(params->altsubject_match); 524 if (conn->altsubject_match == NULL) 525 return -1; 526 } 527 528 /* TODO: gnutls_certificate_set_verify_flags(xcred, flags); 529 * to force peer validation(?) */ 530 531 if (params->ca_cert) { 532 conn->verify_peer = 1; 533 ret = gnutls_certificate_set_x509_trust_file( 534 conn->xcred, params->ca_cert, GNUTLS_X509_FMT_PEM); 535 if (ret < 0) { 536 wpa_printf(MSG_DEBUG, "Failed to read CA cert '%s' " 537 "in PEM format: %s", params->ca_cert, 538 gnutls_strerror(ret)); 539 ret = gnutls_certificate_set_x509_trust_file( 540 conn->xcred, params->ca_cert, 541 GNUTLS_X509_FMT_DER); 542 if (ret < 0) { 543 wpa_printf(MSG_DEBUG, "Failed to read CA cert " 544 "'%s' in DER format: %s", 545 params->ca_cert, 546 gnutls_strerror(ret)); 547 return -1; 548 } 549 } 550 551 if (params->flags & TLS_CONN_ALLOW_SIGN_RSA_MD5) { 552 gnutls_certificate_set_verify_flags( 553 conn->xcred, GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD5); 554 } 555 556 #if LIBGNUTLS_VERSION_NUMBER >= 0x020800 557 if (params->flags & TLS_CONN_DISABLE_TIME_CHECKS) { 558 gnutls_certificate_set_verify_flags( 559 conn->xcred, 560 GNUTLS_VERIFY_DISABLE_TIME_CHECKS); 561 } 562 #endif /* LIBGNUTLS_VERSION_NUMBER >= 0x020800 */ 563 } 564 565 if (params->client_cert && params->private_key) { 566 /* TODO: private_key_passwd? */ 567 ret = gnutls_certificate_set_x509_key_file( 568 conn->xcred, params->client_cert, params->private_key, 569 GNUTLS_X509_FMT_PEM); 570 if (ret < 0) { 571 wpa_printf(MSG_DEBUG, "Failed to read client cert/key " 572 "in PEM format: %s", gnutls_strerror(ret)); 573 ret = gnutls_certificate_set_x509_key_file( 574 conn->xcred, params->client_cert, 575 params->private_key, GNUTLS_X509_FMT_DER); 576 if (ret < 0) { 577 wpa_printf(MSG_DEBUG, "Failed to read client " 578 "cert/key in DER format: %s", 579 gnutls_strerror(ret)); 580 return ret; 581 } 582 } 583 } else if (params->private_key) { 584 int pkcs12_ok = 0; 585 #ifdef PKCS12_FUNCS 586 /* Try to load in PKCS#12 format */ 587 #if LIBGNUTLS_VERSION_NUMBER >= 0x010302 588 ret = gnutls_certificate_set_x509_simple_pkcs12_file( 589 conn->xcred, params->private_key, GNUTLS_X509_FMT_DER, 590 params->private_key_passwd); 591 if (ret != 0) { 592 wpa_printf(MSG_DEBUG, "Failed to load private_key in " 593 "PKCS#12 format: %s", gnutls_strerror(ret)); 594 return -1; 595 } else 596 pkcs12_ok = 1; 597 #endif /* LIBGNUTLS_VERSION_NUMBER >= 0x010302 */ 598 #endif /* PKCS12_FUNCS */ 599 600 if (!pkcs12_ok) { 601 wpa_printf(MSG_DEBUG, "GnuTLS: PKCS#12 support not " 602 "included"); 603 return -1; 604 } 605 } 606 607 conn->params_set = 1; 608 609 ret = gnutls_credentials_set(conn->session, GNUTLS_CRD_CERTIFICATE, 610 conn->xcred); 611 if (ret < 0) { 612 wpa_printf(MSG_INFO, "Failed to configure credentials: %s", 613 gnutls_strerror(ret)); 614 } 615 616 return ret; 617 } 618 619 620 int tls_global_set_params(void *tls_ctx, 621 const struct tls_connection_params *params) 622 { 623 struct tls_global *global = tls_ctx; 624 int ret; 625 626 /* Currently, global parameters are only set when running in server 627 * mode. */ 628 global->server = 1; 629 630 if (global->params_set) { 631 gnutls_certificate_free_credentials(global->xcred); 632 global->params_set = 0; 633 } 634 635 ret = gnutls_certificate_allocate_credentials(&global->xcred); 636 if (ret) { 637 wpa_printf(MSG_DEBUG, "Failed to allocate global credentials " 638 "%s", gnutls_strerror(ret)); 639 return -1; 640 } 641 642 if (params->ca_cert) { 643 ret = gnutls_certificate_set_x509_trust_file( 644 global->xcred, params->ca_cert, GNUTLS_X509_FMT_PEM); 645 if (ret < 0) { 646 wpa_printf(MSG_DEBUG, "Failed to read CA cert '%s' " 647 "in PEM format: %s", params->ca_cert, 648 gnutls_strerror(ret)); 649 ret = gnutls_certificate_set_x509_trust_file( 650 global->xcred, params->ca_cert, 651 GNUTLS_X509_FMT_DER); 652 if (ret < 0) { 653 wpa_printf(MSG_DEBUG, "Failed to read CA cert " 654 "'%s' in DER format: %s", 655 params->ca_cert, 656 gnutls_strerror(ret)); 657 goto fail; 658 } 659 } 660 661 if (params->flags & TLS_CONN_ALLOW_SIGN_RSA_MD5) { 662 gnutls_certificate_set_verify_flags( 663 global->xcred, 664 GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD5); 665 } 666 667 #if LIBGNUTLS_VERSION_NUMBER >= 0x020800 668 if (params->flags & TLS_CONN_DISABLE_TIME_CHECKS) { 669 gnutls_certificate_set_verify_flags( 670 global->xcred, 671 GNUTLS_VERIFY_DISABLE_TIME_CHECKS); 672 } 673 #endif /* LIBGNUTLS_VERSION_NUMBER >= 0x020800 */ 674 } 675 676 if (params->client_cert && params->private_key) { 677 /* TODO: private_key_passwd? */ 678 ret = gnutls_certificate_set_x509_key_file( 679 global->xcred, params->client_cert, 680 params->private_key, GNUTLS_X509_FMT_PEM); 681 if (ret < 0) { 682 wpa_printf(MSG_DEBUG, "Failed to read client cert/key " 683 "in PEM format: %s", gnutls_strerror(ret)); 684 ret = gnutls_certificate_set_x509_key_file( 685 global->xcred, params->client_cert, 686 params->private_key, GNUTLS_X509_FMT_DER); 687 if (ret < 0) { 688 wpa_printf(MSG_DEBUG, "Failed to read client " 689 "cert/key in DER format: %s", 690 gnutls_strerror(ret)); 691 goto fail; 692 } 693 } 694 } else if (params->private_key) { 695 int pkcs12_ok = 0; 696 #ifdef PKCS12_FUNCS 697 /* Try to load in PKCS#12 format */ 698 #if LIBGNUTLS_VERSION_NUMBER >= 0x010302 699 ret = gnutls_certificate_set_x509_simple_pkcs12_file( 700 global->xcred, params->private_key, 701 GNUTLS_X509_FMT_DER, params->private_key_passwd); 702 if (ret != 0) { 703 wpa_printf(MSG_DEBUG, "Failed to load private_key in " 704 "PKCS#12 format: %s", gnutls_strerror(ret)); 705 goto fail; 706 } else 707 pkcs12_ok = 1; 708 #endif /* LIBGNUTLS_VERSION_NUMBER >= 0x010302 */ 709 #endif /* PKCS12_FUNCS */ 710 711 if (!pkcs12_ok) { 712 wpa_printf(MSG_DEBUG, "GnuTLS: PKCS#12 support not " 713 "included"); 714 goto fail; 715 } 716 } 717 718 global->params_set = 1; 719 720 return 0; 721 722 fail: 723 gnutls_certificate_free_credentials(global->xcred); 724 return -1; 725 } 726 727 728 int tls_global_set_verify(void *ssl_ctx, int check_crl) 729 { 730 /* TODO */ 731 return 0; 732 } 733 734 735 int tls_connection_set_verify(void *ssl_ctx, struct tls_connection *conn, 736 int verify_peer) 737 { 738 if (conn == NULL || conn->session == NULL) 739 return -1; 740 741 conn->verify_peer = verify_peer; 742 gnutls_certificate_server_set_request(conn->session, 743 verify_peer ? GNUTLS_CERT_REQUIRE 744 : GNUTLS_CERT_REQUEST); 745 746 return 0; 747 } 748 749 750 int tls_connection_get_keys(void *ssl_ctx, struct tls_connection *conn, 751 struct tls_keys *keys) 752 { 753 #ifdef GNUTLS_INTERNAL_STRUCTURE_HACK 754 security_parameters_st *sec; 755 #endif /* GNUTLS_INTERNAL_STRUCTURE_HACK */ 756 757 if (conn == NULL || conn->session == NULL || keys == NULL) 758 return -1; 759 760 os_memset(keys, 0, sizeof(*keys)); 761 762 #if LIBGNUTLS_VERSION_NUMBER < 0x020c00 763 #ifdef GNUTLS_INTERNAL_STRUCTURE_HACK 764 sec = &conn->session->security_parameters; 765 keys->master_key = sec->master_secret; 766 keys->master_key_len = WPA_TLS_MASTER_SIZE; 767 keys->client_random = sec->client_random; 768 keys->server_random = sec->server_random; 769 #else /* GNUTLS_INTERNAL_STRUCTURE_HACK */ 770 keys->client_random = 771 (u8 *) gnutls_session_get_client_random(conn->session); 772 keys->server_random = 773 (u8 *) gnutls_session_get_server_random(conn->session); 774 /* No access to master_secret */ 775 #endif /* GNUTLS_INTERNAL_STRUCTURE_HACK */ 776 #endif /* LIBGNUTLS_VERSION_NUMBER < 0x020c00 */ 777 778 #if LIBGNUTLS_VERSION_NUMBER < 0x020c00 779 keys->client_random_len = WPA_TLS_RANDOM_SIZE; 780 keys->server_random_len = WPA_TLS_RANDOM_SIZE; 781 #endif /* LIBGNUTLS_VERSION_NUMBER < 0x020c00 */ 782 783 return 0; 784 } 785 786 787 int tls_connection_prf(void *tls_ctx, struct tls_connection *conn, 788 const char *label, int server_random_first, 789 u8 *out, size_t out_len) 790 { 791 #if LIBGNUTLS_VERSION_NUMBER >= 0x010302 792 if (conn == NULL || conn->session == NULL) 793 return -1; 794 795 return gnutls_prf(conn->session, os_strlen(label), label, 796 server_random_first, 0, NULL, out_len, (char *) out); 797 #else /* LIBGNUTLS_VERSION_NUMBER >= 0x010302 */ 798 return -1; 799 #endif /* LIBGNUTLS_VERSION_NUMBER >= 0x010302 */ 800 } 801 802 803 static int tls_connection_verify_peer(struct tls_connection *conn, 804 gnutls_alert_description_t *err) 805 { 806 unsigned int status, num_certs, i; 807 struct os_time now; 808 const gnutls_datum_t *certs; 809 gnutls_x509_crt_t cert; 810 811 if (gnutls_certificate_verify_peers2(conn->session, &status) < 0) { 812 wpa_printf(MSG_INFO, "TLS: Failed to verify peer " 813 "certificate chain"); 814 *err = GNUTLS_A_INTERNAL_ERROR; 815 return -1; 816 } 817 818 if (conn->verify_peer && (status & GNUTLS_CERT_INVALID)) { 819 wpa_printf(MSG_INFO, "TLS: Peer certificate not trusted"); 820 *err = GNUTLS_A_INTERNAL_ERROR; 821 if (status & GNUTLS_CERT_INSECURE_ALGORITHM) { 822 wpa_printf(MSG_INFO, "TLS: Certificate uses insecure " 823 "algorithm"); 824 *err = GNUTLS_A_INSUFFICIENT_SECURITY; 825 } 826 #if LIBGNUTLS_VERSION_NUMBER >= 0x020800 827 if (status & GNUTLS_CERT_NOT_ACTIVATED) { 828 wpa_printf(MSG_INFO, "TLS: Certificate not yet " 829 "activated"); 830 *err = GNUTLS_A_CERTIFICATE_EXPIRED; 831 } 832 if (status & GNUTLS_CERT_EXPIRED) { 833 wpa_printf(MSG_INFO, "TLS: Certificate expired"); 834 *err = GNUTLS_A_CERTIFICATE_EXPIRED; 835 } 836 #endif /* LIBGNUTLS_VERSION_NUMBER >= 0x020800 */ 837 return -1; 838 } 839 840 if (status & GNUTLS_CERT_SIGNER_NOT_FOUND) { 841 wpa_printf(MSG_INFO, "TLS: Peer certificate does not have a " 842 "known issuer"); 843 *err = GNUTLS_A_UNKNOWN_CA; 844 return -1; 845 } 846 847 if (status & GNUTLS_CERT_REVOKED) { 848 wpa_printf(MSG_INFO, "TLS: Peer certificate has been revoked"); 849 *err = GNUTLS_A_CERTIFICATE_REVOKED; 850 return -1; 851 } 852 853 os_get_time(&now); 854 855 certs = gnutls_certificate_get_peers(conn->session, &num_certs); 856 if (certs == NULL) { 857 wpa_printf(MSG_INFO, "TLS: No peer certificate chain " 858 "received"); 859 *err = GNUTLS_A_UNKNOWN_CA; 860 return -1; 861 } 862 863 for (i = 0; i < num_certs; i++) { 864 char *buf; 865 size_t len; 866 if (gnutls_x509_crt_init(&cert) < 0) { 867 wpa_printf(MSG_INFO, "TLS: Certificate initialization " 868 "failed"); 869 *err = GNUTLS_A_BAD_CERTIFICATE; 870 return -1; 871 } 872 873 if (gnutls_x509_crt_import(cert, &certs[i], 874 GNUTLS_X509_FMT_DER) < 0) { 875 wpa_printf(MSG_INFO, "TLS: Could not parse peer " 876 "certificate %d/%d", i + 1, num_certs); 877 gnutls_x509_crt_deinit(cert); 878 *err = GNUTLS_A_BAD_CERTIFICATE; 879 return -1; 880 } 881 882 gnutls_x509_crt_get_dn(cert, NULL, &len); 883 len++; 884 buf = os_malloc(len + 1); 885 if (buf) { 886 buf[0] = buf[len] = '\0'; 887 gnutls_x509_crt_get_dn(cert, buf, &len); 888 } 889 wpa_printf(MSG_DEBUG, "TLS: Peer cert chain %d/%d: %s", 890 i + 1, num_certs, buf); 891 892 if (i == 0) { 893 /* TODO: validate subject_match and altsubject_match */ 894 } 895 896 os_free(buf); 897 898 if (gnutls_x509_crt_get_expiration_time(cert) < now.sec || 899 gnutls_x509_crt_get_activation_time(cert) > now.sec) { 900 wpa_printf(MSG_INFO, "TLS: Peer certificate %d/%d is " 901 "not valid at this time", 902 i + 1, num_certs); 903 gnutls_x509_crt_deinit(cert); 904 *err = GNUTLS_A_CERTIFICATE_EXPIRED; 905 return -1; 906 } 907 908 gnutls_x509_crt_deinit(cert); 909 } 910 911 return 0; 912 } 913 914 915 static struct wpabuf * gnutls_get_appl_data(struct tls_connection *conn) 916 { 917 int res; 918 struct wpabuf *ad; 919 wpa_printf(MSG_DEBUG, "GnuTLS: Check for possible Application Data"); 920 ad = wpabuf_alloc((wpabuf_len(conn->pull_buf) + 500) * 3); 921 if (ad == NULL) 922 return NULL; 923 924 res = gnutls_record_recv(conn->session, wpabuf_mhead(ad), 925 wpabuf_size(ad)); 926 wpa_printf(MSG_DEBUG, "GnuTLS: gnutls_record_recv: %d", res); 927 if (res < 0) { 928 wpa_printf(MSG_DEBUG, "%s - gnutls_record_recv failed: %d " 929 "(%s)", __func__, (int) res, 930 gnutls_strerror(res)); 931 wpabuf_free(ad); 932 return NULL; 933 } 934 935 wpabuf_put(ad, res); 936 wpa_printf(MSG_DEBUG, "GnuTLS: Received %d bytes of Application Data", 937 res); 938 return ad; 939 } 940 941 942 struct wpabuf * tls_connection_handshake(void *tls_ctx, 943 struct tls_connection *conn, 944 const struct wpabuf *in_data, 945 struct wpabuf **appl_data) 946 { 947 struct tls_global *global = tls_ctx; 948 struct wpabuf *out_data; 949 int ret; 950 951 if (appl_data) 952 *appl_data = NULL; 953 954 if (in_data && wpabuf_len(in_data) > 0) { 955 if (conn->pull_buf) { 956 wpa_printf(MSG_DEBUG, "%s - %lu bytes remaining in " 957 "pull_buf", __func__, 958 (unsigned long) wpabuf_len(conn->pull_buf)); 959 wpabuf_free(conn->pull_buf); 960 } 961 conn->pull_buf = wpabuf_dup(in_data); 962 if (conn->pull_buf == NULL) 963 return NULL; 964 conn->pull_buf_offset = wpabuf_head(conn->pull_buf); 965 } 966 967 ret = gnutls_handshake(conn->session); 968 if (ret < 0) { 969 switch (ret) { 970 case GNUTLS_E_AGAIN: 971 if (global->server && conn->established && 972 conn->push_buf == NULL) { 973 /* Need to return something to trigger 974 * completion of EAP-TLS. */ 975 conn->push_buf = wpabuf_alloc(0); 976 } 977 break; 978 case GNUTLS_E_FATAL_ALERT_RECEIVED: 979 wpa_printf(MSG_DEBUG, "%s - received fatal '%s' alert", 980 __func__, gnutls_alert_get_name( 981 gnutls_alert_get(conn->session))); 982 conn->read_alerts++; 983 /* continue */ 984 default: 985 wpa_printf(MSG_DEBUG, "%s - gnutls_handshake failed " 986 "-> %s", __func__, gnutls_strerror(ret)); 987 conn->failed++; 988 } 989 } else { 990 size_t size; 991 gnutls_alert_description_t err; 992 993 if (conn->verify_peer && 994 tls_connection_verify_peer(conn, &err)) { 995 wpa_printf(MSG_INFO, "TLS: Peer certificate chain " 996 "failed validation"); 997 conn->failed++; 998 gnutls_alert_send(conn->session, GNUTLS_AL_FATAL, err); 999 goto out; 1000 } 1001 1002 wpa_printf(MSG_DEBUG, "TLS: Handshake completed successfully"); 1003 conn->established = 1; 1004 if (conn->push_buf == NULL) { 1005 /* Need to return something to get final TLS ACK. */ 1006 conn->push_buf = wpabuf_alloc(0); 1007 } 1008 1009 gnutls_session_get_data(conn->session, NULL, &size); 1010 if (global->session_data == NULL || 1011 global->session_data_size < size) { 1012 os_free(global->session_data); 1013 global->session_data = os_malloc(size); 1014 } 1015 if (global->session_data) { 1016 global->session_data_size = size; 1017 gnutls_session_get_data(conn->session, 1018 global->session_data, 1019 &global->session_data_size); 1020 } 1021 1022 if (conn->pull_buf && appl_data) 1023 *appl_data = gnutls_get_appl_data(conn); 1024 } 1025 1026 out: 1027 out_data = conn->push_buf; 1028 conn->push_buf = NULL; 1029 return out_data; 1030 } 1031 1032 1033 struct wpabuf * tls_connection_server_handshake(void *tls_ctx, 1034 struct tls_connection *conn, 1035 const struct wpabuf *in_data, 1036 struct wpabuf **appl_data) 1037 { 1038 return tls_connection_handshake(tls_ctx, conn, in_data, appl_data); 1039 } 1040 1041 1042 struct wpabuf * tls_connection_encrypt(void *tls_ctx, 1043 struct tls_connection *conn, 1044 const struct wpabuf *in_data) 1045 { 1046 ssize_t res; 1047 struct wpabuf *buf; 1048 1049 res = gnutls_record_send(conn->session, wpabuf_head(in_data), 1050 wpabuf_len(in_data)); 1051 if (res < 0) { 1052 wpa_printf(MSG_INFO, "%s: Encryption failed: %s", 1053 __func__, gnutls_strerror(res)); 1054 return NULL; 1055 } 1056 1057 buf = conn->push_buf; 1058 conn->push_buf = NULL; 1059 return buf; 1060 } 1061 1062 1063 struct wpabuf * tls_connection_decrypt(void *tls_ctx, 1064 struct tls_connection *conn, 1065 const struct wpabuf *in_data) 1066 { 1067 ssize_t res; 1068 struct wpabuf *out; 1069 1070 if (conn->pull_buf) { 1071 wpa_printf(MSG_DEBUG, "%s - %lu bytes remaining in " 1072 "pull_buf", __func__, 1073 (unsigned long) wpabuf_len(conn->pull_buf)); 1074 wpabuf_free(conn->pull_buf); 1075 } 1076 conn->pull_buf = wpabuf_dup(in_data); 1077 if (conn->pull_buf == NULL) 1078 return NULL; 1079 conn->pull_buf_offset = wpabuf_head(conn->pull_buf); 1080 1081 /* 1082 * Even though we try to disable TLS compression, it is possible that 1083 * this cannot be done with all TLS libraries. Add extra buffer space 1084 * to handle the possibility of the decrypted data being longer than 1085 * input data. 1086 */ 1087 out = wpabuf_alloc((wpabuf_len(in_data) + 500) * 3); 1088 if (out == NULL) 1089 return NULL; 1090 1091 res = gnutls_record_recv(conn->session, wpabuf_mhead(out), 1092 wpabuf_size(out)); 1093 if (res < 0) { 1094 wpa_printf(MSG_DEBUG, "%s - gnutls_record_recv failed: %d " 1095 "(%s)", __func__, (int) res, gnutls_strerror(res)); 1096 wpabuf_free(out); 1097 return NULL; 1098 } 1099 wpabuf_put(out, res); 1100 1101 return out; 1102 } 1103 1104 1105 int tls_connection_resumed(void *ssl_ctx, struct tls_connection *conn) 1106 { 1107 if (conn == NULL) 1108 return 0; 1109 return gnutls_session_is_resumed(conn->session); 1110 } 1111 1112 1113 int tls_connection_set_cipher_list(void *tls_ctx, struct tls_connection *conn, 1114 u8 *ciphers) 1115 { 1116 /* TODO */ 1117 return -1; 1118 } 1119 1120 1121 int tls_get_cipher(void *ssl_ctx, struct tls_connection *conn, 1122 char *buf, size_t buflen) 1123 { 1124 /* TODO */ 1125 buf[0] = '\0'; 1126 return 0; 1127 } 1128 1129 1130 int tls_connection_enable_workaround(void *ssl_ctx, 1131 struct tls_connection *conn) 1132 { 1133 gnutls_record_disable_padding(conn->session); 1134 return 0; 1135 } 1136 1137 1138 int tls_connection_client_hello_ext(void *ssl_ctx, struct tls_connection *conn, 1139 int ext_type, const u8 *data, 1140 size_t data_len) 1141 { 1142 /* TODO */ 1143 return -1; 1144 } 1145 1146 1147 int tls_connection_get_failed(void *ssl_ctx, struct tls_connection *conn) 1148 { 1149 if (conn == NULL) 1150 return -1; 1151 return conn->failed; 1152 } 1153 1154 1155 int tls_connection_get_read_alerts(void *ssl_ctx, struct tls_connection *conn) 1156 { 1157 if (conn == NULL) 1158 return -1; 1159 return conn->read_alerts; 1160 } 1161 1162 1163 int tls_connection_get_write_alerts(void *ssl_ctx, struct tls_connection *conn) 1164 { 1165 if (conn == NULL) 1166 return -1; 1167 return conn->write_alerts; 1168 } 1169 1170 1171 int tls_connection_get_keyblock_size(void *tls_ctx, 1172 struct tls_connection *conn) 1173 { 1174 /* TODO */ 1175 return -1; 1176 } 1177 1178 1179 unsigned int tls_capabilities(void *tls_ctx) 1180 { 1181 return 0; 1182 } 1183 1184 1185 int tls_connection_set_session_ticket_cb(void *tls_ctx, 1186 struct tls_connection *conn, 1187 tls_session_ticket_cb cb, void *ctx) 1188 { 1189 return -1; 1190 } 1191