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