contrib/wpa/src/crypto/tls_gnutls.c

   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 #if GNUTLS_VERSION_NUMBER >= 0x030103
  16 #include <gnutls/ocsp.h>
  17 #endif /* 3.1.3 */
  18
  19 #include "common.h"
  20 #include "crypto/crypto.h"
  21 #include "tls.h"
  22
  23
  24 static int tls_gnutls_ref_count = 0;
  25
  26 struct tls_global {
  27         /* Data for session resumption */
  28         void *session_data;
  29         size_t session_data_size;
  30
  31         int server;
  32
  33         int params_set;
  34         gnutls_certificate_credentials_t xcred;
  35
  36         void (*event_cb)(void *ctx, enum tls_event ev,
  37                          union tls_event_data *data);
  38         void *cb_ctx;
  39         int cert_in_cb;
  40 };
  41
  42 struct tls_connection {
  43         struct tls_global *global;
  44         gnutls_session_t session;
  45         int read_alerts, write_alerts, failed;
  46
  47         u8 *pre_shared_secret;
  48         size_t pre_shared_secret_len;
  49         int established;
  50         int verify_peer;
  51         unsigned int disable_time_checks:1;
  52
  53         struct wpabuf *push_buf;
  54         struct wpabuf *pull_buf;
  55         const u8 *pull_buf_offset;
  56
  57         int params_set;
  58         gnutls_certificate_credentials_t xcred;
  59
  60         char *suffix_match;
  61         char *domain_match;
  62         unsigned int flags;
  63 };
  64
  65
  66 static int tls_connection_verify_peer(gnutls_session_t session);
  67
  68
  69 static void tls_log_func(int level, const char *msg)
  70 {
  71         char *s, *pos;
  72         if (level == 6 || level == 7) {
  73                 /* These levels seem to be mostly I/O debug and msg dumps */
  74                 return;
  75         }
  76
  77         s = os_strdup(msg);
  78         if (s == NULL)
  79                 return;
  80
  81         pos = s;
  82         while (*pos != '\0') {
  83                 if (*pos == '\n') {
  84                         *pos = '\0';
  85                         break;
  86                 }
  87                 pos++;
  88         }
  89         wpa_printf(level > 3 ? MSG_MSGDUMP : MSG_DEBUG,
  90                    "gnutls<%d> %s", level, s);
  91         os_free(s);
  92 }
  93
  94
  95 void * tls_init(const struct tls_config *conf)
  96 {
  97         struct tls_global *global;
  98
  99         if (tls_gnutls_ref_count == 0) {
 100                 wpa_printf(MSG_DEBUG,
 101                            "GnuTLS: Library version %s (runtime) - %s (build)",
 102                            gnutls_check_version(NULL), GNUTLS_VERSION);
 103         }
 104
 105         global = os_zalloc(sizeof(*global));
 106         if (global == NULL)
 107                 return NULL;
 108
 109         if (tls_gnutls_ref_count == 0 && gnutls_global_init() < 0) {
 110                 os_free(global);
 111                 return NULL;
 112         }
 113         tls_gnutls_ref_count++;
 114
 115         gnutls_global_set_log_function(tls_log_func);
 116         if (wpa_debug_show_keys)
 117                 gnutls_global_set_log_level(11);
 118
 119         if (conf) {
 120                 global->event_cb = conf->event_cb;
 121                 global->cb_ctx = conf->cb_ctx;
 122                 global->cert_in_cb = conf->cert_in_cb;
 123         }
 124
 125         return global;
 126 }
 127
 128
 129 void tls_deinit(void *ssl_ctx)
 130 {
 131         struct tls_global *global = ssl_ctx;
 132         if (global) {
 133                 if (global->params_set)
 134                         gnutls_certificate_free_credentials(global->xcred);
 135                 os_free(global->session_data);
 136                 os_free(global);
 137         }
 138
 139         tls_gnutls_ref_count--;
 140         if (tls_gnutls_ref_count == 0)
 141                 gnutls_global_deinit();
 142 }
 143
 144
 145 int tls_get_errors(void *ssl_ctx)
 146 {
 147         return 0;
 148 }
 149
 150
 151 static ssize_t tls_pull_func(gnutls_transport_ptr_t ptr, void *buf,
 152                              size_t len)
 153 {
 154         struct tls_connection *conn = (struct tls_connection *) ptr;
 155         const u8 *end;
 156         if (conn->pull_buf == NULL) {
 157                 errno = EWOULDBLOCK;
 158                 return -1;
 159         }
 160
 161         end = wpabuf_head_u8(conn->pull_buf) + wpabuf_len(conn->pull_buf);
 162         if ((size_t) (end - conn->pull_buf_offset) < len)
 163                 len = end - conn->pull_buf_offset;
 164         os_memcpy(buf, conn->pull_buf_offset, len);
 165         conn->pull_buf_offset += len;
 166         if (conn->pull_buf_offset == end) {
 167                 wpa_printf(MSG_DEBUG, "%s - pull_buf consumed", __func__);
 168                 wpabuf_free(conn->pull_buf);
 169                 conn->pull_buf = NULL;
 170                 conn->pull_buf_offset = NULL;
 171         } else {
 172                 wpa_printf(MSG_DEBUG, "%s - %lu bytes remaining in pull_buf",
 173                            __func__,
 174                            (unsigned long) (end - conn->pull_buf_offset));
 175         }
 176         return len;
 177 }
 178
 179
 180 static ssize_t tls_push_func(gnutls_transport_ptr_t ptr, const void *buf,
 181                              size_t len)
 182 {
 183         struct tls_connection *conn = (struct tls_connection *) ptr;
 184
 185         if (wpabuf_resize(&conn->push_buf, len) < 0) {
 186                 errno = ENOMEM;
 187                 return -1;
 188         }
 189         wpabuf_put_data(conn->push_buf, buf, len);
 190
 191         return len;
 192 }
 193
 194
 195 static int tls_gnutls_init_session(struct tls_global *global,
 196                                    struct tls_connection *conn)
 197 {
 198         const char *err;
 199         int ret;
 200
 201         ret = gnutls_init(&conn->session,
 202                           global->server ? GNUTLS_SERVER : GNUTLS_CLIENT);
 203         if (ret < 0) {
 204                 wpa_printf(MSG_INFO, "TLS: Failed to initialize new TLS "
 205                            "connection: %s", gnutls_strerror(ret));
 206                 return -1;
 207         }
 208
 209         ret = gnutls_set_default_priority(conn->session);
 210         if (ret < 0)
 211                 goto fail;
 212
 213         ret = gnutls_priority_set_direct(conn->session, "NORMAL:-VERS-SSL3.0",
 214                                          &err);
 215         if (ret < 0) {
 216                 wpa_printf(MSG_ERROR, "GnuTLS: Priority string failure at "
 217                            "'%s'", err);
 218                 goto fail;
 219         }
 220
 221         gnutls_transport_set_pull_function(conn->session, tls_pull_func);
 222         gnutls_transport_set_push_function(conn->session, tls_push_func);
 223         gnutls_transport_set_ptr(conn->session, (gnutls_transport_ptr_t) conn);
 224         gnutls_session_set_ptr(conn->session, conn);
 225
 226         return 0;
 227
 228 fail:
 229         wpa_printf(MSG_INFO, "TLS: Failed to setup new TLS connection: %s",
 230                    gnutls_strerror(ret));
 231         gnutls_deinit(conn->session);
 232         return -1;
 233 }
 234
 235
 236 struct tls_connection * tls_connection_init(void *ssl_ctx)
 237 {
 238         struct tls_global *global = ssl_ctx;
 239         struct tls_connection *conn;
 240         int ret;
 241
 242         conn = os_zalloc(sizeof(*conn));
 243         if (conn == NULL)
 244                 return NULL;
 245         conn->global = global;
 246
 247         if (tls_gnutls_init_session(global, conn)) {
 248                 os_free(conn);
 249                 return NULL;
 250         }
 251
 252         if (global->params_set) {
 253                 ret = gnutls_credentials_set(conn->session,
 254                                              GNUTLS_CRD_CERTIFICATE,
 255                                              global->xcred);
 256                 if (ret < 0) {
 257                         wpa_printf(MSG_INFO, "Failed to configure "
 258                                    "credentials: %s", gnutls_strerror(ret));
 259                         os_free(conn);
 260                         return NULL;
 261                 }
 262         }
 263
 264         if (gnutls_certificate_allocate_credentials(&conn->xcred)) {
 265                 os_free(conn);
 266                 return NULL;
 267         }
 268
 269         return conn;
 270 }
 271
 272
 273 void tls_connection_deinit(void *ssl_ctx, struct tls_connection *conn)
 274 {
 275         if (conn == NULL)
 276                 return;
 277
 278         gnutls_certificate_free_credentials(conn->xcred);
 279         gnutls_deinit(conn->session);
 280         os_free(conn->pre_shared_secret);
 281         wpabuf_free(conn->push_buf);
 282         wpabuf_free(conn->pull_buf);
 283         os_free(conn->suffix_match);
 284         os_free(conn->domain_match);
 285         os_free(conn);
 286 }
 287
 288
 289 int tls_connection_established(void *ssl_ctx, struct tls_connection *conn)
 290 {
 291         return conn ? conn->established : 0;
 292 }
 293
 294
 295 int tls_connection_shutdown(void *ssl_ctx, struct tls_connection *conn)
 296 {
 297         struct tls_global *global = ssl_ctx;
 298         int ret;
 299
 300         if (conn == NULL)
 301                 return -1;
 302
 303         /* Shutdown previous TLS connection without notifying the peer
 304          * because the connection was already terminated in practice
 305          * and "close notify" shutdown alert would confuse AS. */
 306         gnutls_bye(conn->session, GNUTLS_SHUT_RDWR);
 307         wpabuf_free(conn->push_buf);
 308         conn->push_buf = NULL;
 309         conn->established = 0;
 310
 311         gnutls_deinit(conn->session);
 312         if (tls_gnutls_init_session(global, conn)) {
 313                 wpa_printf(MSG_INFO, "GnuTLS: Failed to preparare new session "
 314                            "for session resumption use");
 315                 return -1;
 316         }
 317
 318         ret = gnutls_credentials_set(conn->session, GNUTLS_CRD_CERTIFICATE,
 319                                      conn->params_set ? conn->xcred :
 320                                      global->xcred);
 321         if (ret < 0) {
 322                 wpa_printf(MSG_INFO, "GnuTLS: Failed to configure credentials "
 323                            "for session resumption: %s", gnutls_strerror(ret));
 324                 return -1;
 325         }
 326
 327         if (global->session_data) {
 328                 ret = gnutls_session_set_data(conn->session,
 329                                               global->session_data,
 330                                               global->session_data_size);
 331                 if (ret < 0) {
 332                         wpa_printf(MSG_INFO, "GnuTLS: Failed to set session "
 333                                    "data: %s", gnutls_strerror(ret));
 334                         return -1;
 335                 }
 336         }
 337
 338         return 0;
 339 }
 340
 341
 342 int tls_connection_set_params(void *tls_ctx, struct tls_connection *conn,
 343                               const struct tls_connection_params *params)
 344 {
 345         int ret;
 346
 347         if (conn == NULL || params == NULL)
 348                 return -1;
 349
 350         if (params->subject_match) {
 351                 wpa_printf(MSG_INFO, "GnuTLS: subject_match not supported");
 352                 return -1;
 353         }
 354
 355         if (params->altsubject_match) {
 356                 wpa_printf(MSG_INFO, "GnuTLS: altsubject_match not supported");
 357                 return -1;
 358         }
 359
 360         os_free(conn->suffix_match);
 361         conn->suffix_match = NULL;
 362         if (params->suffix_match) {
 363                 conn->suffix_match = os_strdup(params->suffix_match);
 364                 if (conn->suffix_match == NULL)
 365                         return -1;
 366         }
 367
 368 #if GNUTLS_VERSION_NUMBER >= 0x030300
 369         os_free(conn->domain_match);
 370         conn->domain_match = NULL;
 371         if (params->domain_match) {
 372                 conn->domain_match = os_strdup(params->domain_match);
 373                 if (conn->domain_match == NULL)
 374                         return -1;
 375         }
 376 #else /* < 3.3.0 */
 377         if (params->domain_match) {
 378                 wpa_printf(MSG_INFO, "GnuTLS: domain_match not supported");
 379                 return -1;
 380         }
 381 #endif /* >= 3.3.0 */
 382
 383         conn->flags = params->flags;
 384
 385         if (params->openssl_ciphers) {
 386                 wpa_printf(MSG_INFO, "GnuTLS: openssl_ciphers not supported");
 387                 return -1;
 388         }
 389
 390         /* TODO: gnutls_certificate_set_verify_flags(xcred, flags);
 391          * to force peer validation(?) */
 392
 393         if (params->ca_cert) {
 394                 wpa_printf(MSG_DEBUG, "GnuTLS: Try to parse %s in DER format",
 395                            params->ca_cert);
 396                 ret = gnutls_certificate_set_x509_trust_file(
 397                         conn->xcred, params->ca_cert, GNUTLS_X509_FMT_DER);
 398                 if (ret < 0) {
 399                         wpa_printf(MSG_DEBUG,
 400                                    "GnuTLS: Failed to read CA cert '%s' in DER format (%s) - try in PEM format",
 401                                    params->ca_cert,
 402                                    gnutls_strerror(ret));
 403                         ret = gnutls_certificate_set_x509_trust_file(
 404                                 conn->xcred, params->ca_cert,
 405                                 GNUTLS_X509_FMT_PEM);
 406                         if (ret < 0) {
 407                                 wpa_printf(MSG_DEBUG,
 408                                            "Failed to read CA cert '%s' in PEM format: %s",
 409                                            params->ca_cert,
 410                                            gnutls_strerror(ret));
 411                                 return -1;
 412                         }
 413                 }
 414         } else if (params->ca_cert_blob) {
 415                 gnutls_datum_t ca;
 416
 417                 ca.data = (unsigned char *) params->ca_cert_blob;
 418                 ca.size = params->ca_cert_blob_len;
 419
 420                 ret = gnutls_certificate_set_x509_trust_mem(
 421                         conn->xcred, &ca, GNUTLS_X509_FMT_DER);
 422                 if (ret < 0) {
 423                         wpa_printf(MSG_DEBUG,
 424                                    "Failed to parse CA cert in DER format: %s",
 425                                    gnutls_strerror(ret));
 426                         ret = gnutls_certificate_set_x509_trust_mem(
 427                                 conn->xcred, &ca, GNUTLS_X509_FMT_PEM);
 428                         if (ret < 0) {
 429                                 wpa_printf(MSG_DEBUG,
 430                                            "Failed to parse CA cert in PEM format: %s",
 431                                            gnutls_strerror(ret));
 432                                 return -1;
 433                         }
 434                 }
 435         } else if (params->ca_path) {
 436                 wpa_printf(MSG_INFO, "GnuTLS: ca_path not supported");
 437                 return -1;
 438         }
 439
 440         conn->disable_time_checks = 0;
 441         if (params->ca_cert || params->ca_cert_blob) {
 442                 conn->verify_peer = 1;
 443                 gnutls_certificate_set_verify_function(
 444                         conn->xcred, tls_connection_verify_peer);
 445
 446                 if (params->flags & TLS_CONN_ALLOW_SIGN_RSA_MD5) {
 447                         gnutls_certificate_set_verify_flags(
 448                                 conn->xcred, GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD5);
 449                 }
 450
 451                 if (params->flags & TLS_CONN_DISABLE_TIME_CHECKS) {
 452                         conn->disable_time_checks = 1;
 453                         gnutls_certificate_set_verify_flags(
 454                                 conn->xcred,
 455                                 GNUTLS_VERIFY_DISABLE_TIME_CHECKS);
 456                 }
 457         }
 458
 459         if (params->client_cert && params->private_key) {
 460 #if GNUTLS_VERSION_NUMBER >= 0x03010b
 461                 ret = gnutls_certificate_set_x509_key_file2(
 462                         conn->xcred, params->client_cert, params->private_key,
 463                         GNUTLS_X509_FMT_DER, params->private_key_passwd, 0);
 464 #else
 465                 /* private_key_passwd not (easily) supported here */
 466                 ret = gnutls_certificate_set_x509_key_file(
 467                         conn->xcred, params->client_cert, params->private_key,
 468                         GNUTLS_X509_FMT_DER);
 469 #endif
 470                 if (ret < 0) {
 471                         wpa_printf(MSG_DEBUG, "Failed to read client cert/key "
 472                                    "in DER format: %s", gnutls_strerror(ret));
 473 #if GNUTLS_VERSION_NUMBER >= 0x03010b
 474                         ret = gnutls_certificate_set_x509_key_file2(
 475                                 conn->xcred, params->client_cert,
 476                                 params->private_key, GNUTLS_X509_FMT_PEM,
 477                                 params->private_key_passwd, 0);
 478 #else
 479                         ret = gnutls_certificate_set_x509_key_file(
 480                                 conn->xcred, params->client_cert,
 481                                 params->private_key, GNUTLS_X509_FMT_PEM);
 482 #endif
 483                         if (ret < 0) {
 484                                 wpa_printf(MSG_DEBUG, "Failed to read client "
 485                                            "cert/key in PEM format: %s",
 486                                            gnutls_strerror(ret));
 487                                 return ret;
 488                         }
 489                 }
 490         } else if (params->private_key) {
 491                 int pkcs12_ok = 0;
 492 #ifdef PKCS12_FUNCS
 493                 /* Try to load in PKCS#12 format */
 494                 ret = gnutls_certificate_set_x509_simple_pkcs12_file(
 495                         conn->xcred, params->private_key, GNUTLS_X509_FMT_DER,
 496                         params->private_key_passwd);
 497                 if (ret != 0) {
 498                         wpa_printf(MSG_DEBUG, "Failed to load private_key in "
 499                                    "PKCS#12 format: %s", gnutls_strerror(ret));
 500                         return -1;
 501                 } else
 502                         pkcs12_ok = 1;
 503 #endif /* PKCS12_FUNCS */
 504
 505                 if (!pkcs12_ok) {
 506                         wpa_printf(MSG_DEBUG, "GnuTLS: PKCS#12 support not "
 507                                    "included");
 508                         return -1;
 509                 }
 510         } else if (params->client_cert_blob && params->private_key_blob) {
 511                 gnutls_datum_t cert, key;
 512
 513                 cert.data = (unsigned char *) params->client_cert_blob;
 514                 cert.size = params->client_cert_blob_len;
 515                 key.data = (unsigned char *) params->private_key_blob;
 516                 key.size = params->private_key_blob_len;
 517
 518 #if GNUTLS_VERSION_NUMBER >= 0x03010b
 519                 ret = gnutls_certificate_set_x509_key_mem2(
 520                         conn->xcred, &cert, &key, GNUTLS_X509_FMT_DER,
 521                         params->private_key_passwd, 0);
 522 #else
 523                 /* private_key_passwd not (easily) supported here */
 524                 ret = gnutls_certificate_set_x509_key_mem(
 525                         conn->xcred, &cert, &key, GNUTLS_X509_FMT_DER);
 526 #endif
 527                 if (ret < 0) {
 528                         wpa_printf(MSG_DEBUG, "Failed to read client cert/key "
 529                                    "in DER format: %s", gnutls_strerror(ret));
 530 #if GNUTLS_VERSION_NUMBER >= 0x03010b
 531                         ret = gnutls_certificate_set_x509_key_mem2(
 532                                 conn->xcred, &cert, &key, GNUTLS_X509_FMT_PEM,
 533                                 params->private_key_passwd, 0);
 534 #else
 535                         /* private_key_passwd not (easily) supported here */
 536                         ret = gnutls_certificate_set_x509_key_mem(
 537                                 conn->xcred, &cert, &key, GNUTLS_X509_FMT_PEM);
 538 #endif
 539                         if (ret < 0) {
 540                                 wpa_printf(MSG_DEBUG, "Failed to read client "
 541                                            "cert/key in PEM format: %s",
 542                                            gnutls_strerror(ret));
 543                                 return ret;
 544                         }
 545                 }
 546         } else if (params->private_key_blob) {
 547 #ifdef PKCS12_FUNCS
 548                 gnutls_datum_t key;
 549
 550                 key.data = (unsigned char *) params->private_key_blob;
 551                 key.size = params->private_key_blob_len;
 552
 553                 /* Try to load in PKCS#12 format */
 554                 ret = gnutls_certificate_set_x509_simple_pkcs12_mem(
 555                         conn->xcred, &key, GNUTLS_X509_FMT_DER,
 556                         params->private_key_passwd);
 557                 if (ret != 0) {
 558                         wpa_printf(MSG_DEBUG, "Failed to load private_key in "
 559                                    "PKCS#12 format: %s", gnutls_strerror(ret));
 560                         return -1;
 561                 }
 562 #else /* PKCS12_FUNCS */
 563                 wpa_printf(MSG_DEBUG, "GnuTLS: PKCS#12 support not included");
 564                 return -1;
 565 #endif /* PKCS12_FUNCS */
 566         }
 567
 568 #if GNUTLS_VERSION_NUMBER >= 0x030103
 569         if (params->flags & (TLS_CONN_REQUEST_OCSP | TLS_CONN_REQUIRE_OCSP)) {
 570                 ret = gnutls_ocsp_status_request_enable_client(conn->session,
 571                                                                NULL, 0, NULL);
 572                 if (ret != GNUTLS_E_SUCCESS) {
 573                         wpa_printf(MSG_INFO,
 574                                    "GnuTLS: Failed to enable OCSP client");
 575                         return -1;
 576                 }
 577         }
 578 #else /* 3.1.3 */
 579         if (params->flags & TLS_CONN_REQUIRE_OCSP) {
 580                 wpa_printf(MSG_INFO,
 581                            "GnuTLS: OCSP not supported by this version of GnuTLS");
 582                 return -1;
 583         }
 584 #endif /* 3.1.3 */
 585
 586         conn->params_set = 1;
 587
 588         ret = gnutls_credentials_set(conn->session, GNUTLS_CRD_CERTIFICATE,
 589                                      conn->xcred);
 590         if (ret < 0) {
 591                 wpa_printf(MSG_INFO, "Failed to configure credentials: %s",
 592                            gnutls_strerror(ret));
 593         }
 594
 595         return ret;
 596 }
 597
 598
 599 int tls_global_set_params(void *tls_ctx,
 600                           const struct tls_connection_params *params)
 601 {
 602         struct tls_global *global = tls_ctx;
 603         int ret;
 604
 605         /* Currently, global parameters are only set when running in server
 606          * mode. */
 607         global->server = 1;
 608
 609         if (global->params_set) {
 610                 gnutls_certificate_free_credentials(global->xcred);
 611                 global->params_set = 0;
 612         }
 613
 614         ret = gnutls_certificate_allocate_credentials(&global->xcred);
 615         if (ret) {
 616                 wpa_printf(MSG_DEBUG, "Failed to allocate global credentials "
 617                            "%s", gnutls_strerror(ret));
 618                 return -1;
 619         }
 620
 621         if (params->ca_cert) {
 622                 ret = gnutls_certificate_set_x509_trust_file(
 623                         global->xcred, params->ca_cert, GNUTLS_X509_FMT_DER);
 624                 if (ret < 0) {
 625                         wpa_printf(MSG_DEBUG, "Failed to read CA cert '%s' "
 626                                    "in DER format: %s", params->ca_cert,
 627                                    gnutls_strerror(ret));
 628                         ret = gnutls_certificate_set_x509_trust_file(
 629                                 global->xcred, params->ca_cert,
 630                                 GNUTLS_X509_FMT_PEM);
 631                         if (ret < 0) {
 632                                 wpa_printf(MSG_DEBUG, "Failed to read CA cert "
 633                                            "'%s' in PEM format: %s",
 634                                            params->ca_cert,
 635                                            gnutls_strerror(ret));
 636                                 goto fail;
 637                         }
 638                 }
 639
 640                 if (params->flags & TLS_CONN_ALLOW_SIGN_RSA_MD5) {
 641                         gnutls_certificate_set_verify_flags(
 642                                 global->xcred,
 643                                 GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD5);
 644                 }
 645
 646                 if (params->flags & TLS_CONN_DISABLE_TIME_CHECKS) {
 647                         gnutls_certificate_set_verify_flags(
 648                                 global->xcred,
 649                                 GNUTLS_VERIFY_DISABLE_TIME_CHECKS);
 650                 }
 651         }
 652
 653         if (params->client_cert && params->private_key) {
 654                 /* TODO: private_key_passwd? */
 655                 ret = gnutls_certificate_set_x509_key_file(
 656                         global->xcred, params->client_cert,
 657                         params->private_key, GNUTLS_X509_FMT_DER);
 658                 if (ret < 0) {
 659                         wpa_printf(MSG_DEBUG, "Failed to read client cert/key "
 660                                    "in DER format: %s", gnutls_strerror(ret));
 661                         ret = gnutls_certificate_set_x509_key_file(
 662                                 global->xcred, params->client_cert,
 663                                 params->private_key, GNUTLS_X509_FMT_PEM);
 664                         if (ret < 0) {
 665                                 wpa_printf(MSG_DEBUG, "Failed to read client "
 666                                            "cert/key in PEM format: %s",
 667                                            gnutls_strerror(ret));
 668                                 goto fail;
 669                         }
 670                 }
 671         } else if (params->private_key) {
 672                 int pkcs12_ok = 0;
 673 #ifdef PKCS12_FUNCS
 674                 /* Try to load in PKCS#12 format */
 675                 ret = gnutls_certificate_set_x509_simple_pkcs12_file(
 676                         global->xcred, params->private_key,
 677                         GNUTLS_X509_FMT_DER, params->private_key_passwd);
 678                 if (ret != 0) {
 679                         wpa_printf(MSG_DEBUG, "Failed to load private_key in "
 680                                    "PKCS#12 format: %s", gnutls_strerror(ret));
 681                         goto fail;
 682                 } else
 683                         pkcs12_ok = 1;
 684 #endif /* PKCS12_FUNCS */
 685
 686                 if (!pkcs12_ok) {
 687                         wpa_printf(MSG_DEBUG, "GnuTLS: PKCS#12 support not "
 688                                    "included");
 689                         goto fail;
 690                 }
 691         }
 692
 693         global->params_set = 1;
 694
 695         return 0;
 696
 697 fail:
 698         gnutls_certificate_free_credentials(global->xcred);
 699         return -1;
 700 }
 701
 702
 703 int tls_global_set_verify(void *ssl_ctx, int check_crl)
 704 {
 705         /* TODO */
 706         return 0;
 707 }
 708
 709
 710 int tls_connection_set_verify(void *ssl_ctx, struct tls_connection *conn,
 711                               int verify_peer)
 712 {
 713         if (conn == NULL || conn->session == NULL)
 714                 return -1;
 715
 716         conn->verify_peer = verify_peer;
 717         gnutls_certificate_server_set_request(conn->session,
 718                                               verify_peer ? GNUTLS_CERT_REQUIRE
 719                                               : GNUTLS_CERT_REQUEST);
 720
 721         return 0;
 722 }
 723
 724
 725 int tls_connection_get_keys(void *ssl_ctx, struct tls_connection *conn,
 726                             struct tls_keys *keys)
 727 {
 728 #if GNUTLS_VERSION_NUMBER >= 0x030012
 729         gnutls_datum_t client, server;
 730
 731         if (conn == NULL || conn->session == NULL || keys == NULL)
 732                 return -1;
 733
 734         os_memset(keys, 0, sizeof(*keys));
 735         gnutls_session_get_random(conn->session, &client, &server);
 736         keys->client_random = client.data;
 737         keys->server_random = server.data;
 738         keys->client_random_len = client.size;
 739         keys->server_random_len = client.size;
 740
 741         return 0;
 742 #else /* 3.0.18 */
 743         return -1;
 744 #endif /* 3.0.18 */
 745 }
 746
 747
 748 int tls_connection_prf(void *tls_ctx, struct tls_connection *conn,
 749                        const char *label, int server_random_first,
 750                        u8 *out, size_t out_len)
 751 {
 752         if (conn == NULL || conn->session == NULL)
 753                 return -1;
 754
 755         return gnutls_prf(conn->session, os_strlen(label), label,
 756                           server_random_first, 0, NULL, out_len, (char *) out);
 757 }
 758
 759
 760 static void gnutls_tls_fail_event(struct tls_connection *conn,
 761                                   const gnutls_datum_t *cert, int depth,
 762                                   const char *subject, const char *err_str,
 763                                   enum tls_fail_reason reason)
 764 {
 765         union tls_event_data ev;
 766         struct tls_global *global = conn->global;
 767         struct wpabuf *cert_buf = NULL;
 768
 769         if (global->event_cb == NULL)
 770                 return;
 771
 772         os_memset(&ev, 0, sizeof(ev));
 773         ev.cert_fail.depth = depth;
 774         ev.cert_fail.subject = subject ? subject : "";
 775         ev.cert_fail.reason = reason;
 776         ev.cert_fail.reason_txt = err_str;
 777         if (cert) {
 778                 cert_buf = wpabuf_alloc_copy(cert->data, cert->size);
 779                 ev.cert_fail.cert = cert_buf;
 780         }
 781         global->event_cb(global->cb_ctx, TLS_CERT_CHAIN_FAILURE, &ev);
 782         wpabuf_free(cert_buf);
 783 }
 784
 785
 786 #if GNUTLS_VERSION_NUMBER < 0x030300
 787 static int server_eku_purpose(gnutls_x509_crt_t cert)
 788 {
 789         unsigned int i;
 790
 791         for (i = 0; ; i++) {
 792                 char oid[128];
 793                 size_t oid_size = sizeof(oid);
 794                 int res;
 795
 796                 res = gnutls_x509_crt_get_key_purpose_oid(cert, i, oid,
 797                                                           &oid_size, NULL);
 798                 if (res == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE) {
 799                         if (i == 0) {
 800                                 /* No EKU - assume any use allowed */
 801                                 return 1;
 802                         }
 803                         break;
 804                 }
 805
 806                 if (res < 0) {
 807                         wpa_printf(MSG_INFO, "GnuTLS: Failed to get EKU");
 808                         return 0;
 809                 }
 810
 811                 wpa_printf(MSG_DEBUG, "GnuTLS: Certificate purpose: %s", oid);
 812                 if (os_strcmp(oid, GNUTLS_KP_TLS_WWW_SERVER) == 0 ||
 813                     os_strcmp(oid, GNUTLS_KP_ANY) == 0)
 814                         return 1;
 815         }
 816
 817         return 0;
 818 }
 819 #endif /* < 3.3.0 */
 820
 821
 822 static int check_ocsp(struct tls_connection *conn, gnutls_session_t session,
 823                       gnutls_alert_description_t *err)
 824 {
 825 #if GNUTLS_VERSION_NUMBER >= 0x030103
 826         gnutls_datum_t response, buf;
 827         gnutls_ocsp_resp_t resp;
 828         unsigned int cert_status;
 829         int res;
 830
 831         if (!(conn->flags & (TLS_CONN_REQUEST_OCSP | TLS_CONN_REQUIRE_OCSP)))
 832                 return 0;
 833
 834         if (!gnutls_ocsp_status_request_is_checked(session, 0)) {
 835                 if (conn->flags & TLS_CONN_REQUIRE_OCSP) {
 836                         wpa_printf(MSG_INFO,
 837                                    "GnuTLS: No valid OCSP response received");
 838                         goto ocsp_error;
 839                 }
 840
 841                 wpa_printf(MSG_DEBUG,
 842                            "GnuTLS: Valid OCSP response was not received - continue since OCSP was not required");
 843                 return 0;
 844         }
 845
 846         /*
 847          * GnuTLS has already verified the OCSP response in
 848          * check_ocsp_response() and rejected handshake if the certificate was
 849          * found to be revoked. However, if the response indicates that the
 850          * status is unknown, handshake continues and reaches here. We need to
 851          * re-import the OCSP response to check for unknown certificate status,
 852          * but we do not need to repeat gnutls_ocsp_resp_check_crt() and
 853          * gnutls_ocsp_resp_verify_direct() calls.
 854          */
 855
 856         res = gnutls_ocsp_status_request_get(session, &response);
 857         if (res != GNUTLS_E_SUCCESS) {
 858                 wpa_printf(MSG_INFO,
 859                            "GnuTLS: OCSP response was received, but it was not valid");
 860                 goto ocsp_error;
 861         }
 862
 863         if (gnutls_ocsp_resp_init(&resp) != GNUTLS_E_SUCCESS)
 864                 goto ocsp_error;
 865
 866         res = gnutls_ocsp_resp_import(resp, &response);
 867         if (res != GNUTLS_E_SUCCESS) {
 868                 wpa_printf(MSG_INFO,
 869                            "GnuTLS: Could not parse received OCSP response: %s",
 870                            gnutls_strerror(res));
 871                 gnutls_ocsp_resp_deinit(resp);
 872                 goto ocsp_error;
 873         }
 874
 875         res = gnutls_ocsp_resp_print(resp, GNUTLS_OCSP_PRINT_FULL, &buf);
 876         if (res == GNUTLS_E_SUCCESS) {
 877                 wpa_printf(MSG_DEBUG, "GnuTLS: %s", buf.data);
 878                 gnutls_free(buf.data);
 879         }
 880
 881         res = gnutls_ocsp_resp_get_single(resp, 0, NULL, NULL, NULL,
 882                                           NULL, &cert_status, NULL,
 883                                           NULL, NULL, NULL);
 884         gnutls_ocsp_resp_deinit(resp);
 885         if (res != GNUTLS_E_SUCCESS) {
 886                 wpa_printf(MSG_INFO,
 887                            "GnuTLS: Failed to extract OCSP information: %s",
 888                            gnutls_strerror(res));
 889                 goto ocsp_error;
 890         }
 891
 892         if (cert_status == GNUTLS_OCSP_CERT_GOOD) {
 893                 wpa_printf(MSG_DEBUG, "GnuTLS: OCSP cert status: good");
 894         } else if (cert_status == GNUTLS_OCSP_CERT_REVOKED) {
 895                 wpa_printf(MSG_DEBUG,
 896                            "GnuTLS: OCSP cert status: revoked");
 897                 goto ocsp_error;
 898         } else {
 899                 wpa_printf(MSG_DEBUG,
 900                            "GnuTLS: OCSP cert status: unknown");
 901                 if (conn->flags & TLS_CONN_REQUIRE_OCSP)
 902                         goto ocsp_error;
 903                 wpa_printf(MSG_DEBUG,
 904                            "GnuTLS: OCSP was not required, so allow connection to continue");
 905         }
 906
 907         return 0;
 908
 909 ocsp_error:
 910         gnutls_tls_fail_event(conn, NULL, 0, NULL,
 911                               "bad certificate status response",
 912                               TLS_FAIL_REVOKED);
 913         *err = GNUTLS_A_CERTIFICATE_REVOKED;
 914         return -1;
 915 #else /* GnuTLS 3.1.3 or newer */
 916         return 0;
 917 #endif /* GnuTLS 3.1.3 or newer */
 918 }
 919
 920
 921 static int tls_connection_verify_peer(gnutls_session_t session)
 922 {
 923         struct tls_connection *conn;
 924         unsigned int status, num_certs, i;
 925         struct os_time now;
 926         const gnutls_datum_t *certs;
 927         gnutls_x509_crt_t cert;
 928         gnutls_alert_description_t err;
 929         int res;
 930
 931         conn = gnutls_session_get_ptr(session);
 932         if (!conn->verify_peer) {
 933                 wpa_printf(MSG_DEBUG,
 934                            "GnuTLS: No peer certificate verification enabled");
 935                 return 0;
 936         }
 937
 938         wpa_printf(MSG_DEBUG, "GnuTSL: Verifying peer certificate");
 939
 940 #if GNUTLS_VERSION_NUMBER >= 0x030300
 941         {
 942                 gnutls_typed_vdata_st data[1];
 943                 unsigned int elements = 0;
 944
 945                 os_memset(data, 0, sizeof(data));
 946                 if (!conn->global->server) {
 947                         data[elements].type = GNUTLS_DT_KEY_PURPOSE_OID;
 948                         data[elements].data = (void *) GNUTLS_KP_TLS_WWW_SERVER;
 949                         elements++;
 950                 }
 951                 res = gnutls_certificate_verify_peers(session, data, 1,
 952                                                       &status);
 953         }
 954 #else /* < 3.3.0 */
 955         res = gnutls_certificate_verify_peers2(session, &status);
 956 #endif
 957         if (res < 0) {
 958                 wpa_printf(MSG_INFO, "TLS: Failed to verify peer "
 959                            "certificate chain");
 960                 err = GNUTLS_A_INTERNAL_ERROR;
 961                 goto out;
 962         }
 963
 964 #if GNUTLS_VERSION_NUMBER >= 0x030104
 965         {
 966                 gnutls_datum_t info;
 967                 int ret, type;
 968
 969                 type = gnutls_certificate_type_get(session);
 970                 ret = gnutls_certificate_verification_status_print(status, type,
 971                                                                    &info, 0);
 972                 if (ret < 0) {
 973                         wpa_printf(MSG_DEBUG,
 974                                    "GnuTLS: Failed to print verification status");
 975                         err = GNUTLS_A_INTERNAL_ERROR;
 976                         goto out;
 977                 }
 978                 wpa_printf(MSG_DEBUG, "GnuTLS: %s", info.data);
 979                 gnutls_free(info.data);
 980         }
 981 #endif /* GnuTLS 3.1.4 or newer */
 982
 983         certs = gnutls_certificate_get_peers(session, &num_certs);
 984         if (certs == NULL || num_certs == 0) {
 985                 wpa_printf(MSG_INFO, "TLS: No peer certificate chain received");
 986                 err = GNUTLS_A_UNKNOWN_CA;
 987                 goto out;
 988         }
 989
 990         if (conn->verify_peer && (status & GNUTLS_CERT_INVALID)) {
 991                 wpa_printf(MSG_INFO, "TLS: Peer certificate not trusted");
 992                 if (status & GNUTLS_CERT_INSECURE_ALGORITHM) {
 993                         wpa_printf(MSG_INFO, "TLS: Certificate uses insecure "
 994                                    "algorithm");
 995                         gnutls_tls_fail_event(conn, NULL, 0, NULL,
 996                                               "certificate uses insecure algorithm",
 997                                               TLS_FAIL_BAD_CERTIFICATE);
 998                         err = GNUTLS_A_INSUFFICIENT_SECURITY;
 999                         goto out;
1000                 }
1001                 if (status & GNUTLS_CERT_NOT_ACTIVATED) {
1002                         wpa_printf(MSG_INFO, "TLS: Certificate not yet "
1003                                    "activated");
1004                         gnutls_tls_fail_event(conn, NULL, 0, NULL,
1005                                               "certificate not yet valid",
1006                                               TLS_FAIL_NOT_YET_VALID);
1007                         err = GNUTLS_A_CERTIFICATE_EXPIRED;
1008                         goto out;
1009                 }
1010                 if (status & GNUTLS_CERT_EXPIRED) {
1011                         wpa_printf(MSG_INFO, "TLS: Certificate expired");
1012                         gnutls_tls_fail_event(conn, NULL, 0, NULL,
1013                                               "certificate has expired",
1014                                               TLS_FAIL_EXPIRED);
1015                         err = GNUTLS_A_CERTIFICATE_EXPIRED;
1016                         goto out;
1017                 }
1018                 gnutls_tls_fail_event(conn, NULL, 0, NULL,
1019                                       "untrusted certificate",
1020                                       TLS_FAIL_UNTRUSTED);
1021                 err = GNUTLS_A_INTERNAL_ERROR;
1022                 goto out;
1023         }
1024
1025         if (status & GNUTLS_CERT_SIGNER_NOT_FOUND) {
1026                 wpa_printf(MSG_INFO, "TLS: Peer certificate does not have a "
1027                            "known issuer");
1028                 gnutls_tls_fail_event(conn, NULL, 0, NULL, "signed not found",
1029                                       TLS_FAIL_UNTRUSTED);
1030                 err = GNUTLS_A_UNKNOWN_CA;
1031                 goto out;
1032         }
1033
1034         if (status & GNUTLS_CERT_REVOKED) {
1035                 wpa_printf(MSG_INFO, "TLS: Peer certificate has been revoked");
1036                 gnutls_tls_fail_event(conn, NULL, 0, NULL,
1037                                       "certificate revoked",
1038                                       TLS_FAIL_REVOKED);
1039                 err = GNUTLS_A_CERTIFICATE_REVOKED;
1040                 goto out;
1041         }
1042
1043         if (status != 0) {
1044                 wpa_printf(MSG_INFO, "TLS: Unknown verification status: %d",
1045                            status);
1046                 err = GNUTLS_A_INTERNAL_ERROR;
1047                 goto out;
1048         }
1049
1050         if (check_ocsp(conn, session, &err))
1051                 goto out;
1052
1053         os_get_time(&now);
1054
1055         for (i = 0; i < num_certs; i++) {
1056                 char *buf;
1057                 size_t len;
1058                 if (gnutls_x509_crt_init(&cert) < 0) {
1059                         wpa_printf(MSG_INFO, "TLS: Certificate initialization "
1060                                    "failed");
1061                         err = GNUTLS_A_BAD_CERTIFICATE;
1062                         goto out;
1063                 }
1064
1065                 if (gnutls_x509_crt_import(cert, &certs[i],
1066                                            GNUTLS_X509_FMT_DER) < 0) {
1067                         wpa_printf(MSG_INFO, "TLS: Could not parse peer "
1068                                    "certificate %d/%d", i + 1, num_certs);
1069                         gnutls_x509_crt_deinit(cert);
1070                         err = GNUTLS_A_BAD_CERTIFICATE;
1071                         goto out;
1072                 }
1073
1074                 gnutls_x509_crt_get_dn(cert, NULL, &len);
1075                 len++;
1076                 buf = os_malloc(len + 1);
1077                 if (buf) {
1078                         buf[0] = buf[len] = '\0';
1079                         gnutls_x509_crt_get_dn(cert, buf, &len);
1080                 }
1081                 wpa_printf(MSG_DEBUG, "TLS: Peer cert chain %d/%d: %s",
1082                            i + 1, num_certs, buf);
1083
1084                 if (conn->global->event_cb) {
1085                         struct wpabuf *cert_buf = NULL;
1086                         union tls_event_data ev;
1087 #ifdef CONFIG_SHA256
1088                         u8 hash[32];
1089                         const u8 *_addr[1];
1090                         size_t _len[1];
1091 #endif /* CONFIG_SHA256 */
1092
1093                         os_memset(&ev, 0, sizeof(ev));
1094                         if (conn->global->cert_in_cb) {
1095                                 cert_buf = wpabuf_alloc_copy(certs[i].data,
1096                                                              certs[i].size);
1097                                 ev.peer_cert.cert = cert_buf;
1098                         }
1099 #ifdef CONFIG_SHA256
1100                         _addr[0] = certs[i].data;
1101                         _len[0] = certs[i].size;
1102                         if (sha256_vector(1, _addr, _len, hash) == 0) {
1103                                 ev.peer_cert.hash = hash;
1104                                 ev.peer_cert.hash_len = sizeof(hash);
1105                         }
1106 #endif /* CONFIG_SHA256 */
1107                         ev.peer_cert.depth = i;
1108                         ev.peer_cert.subject = buf;
1109                         conn->global->event_cb(conn->global->cb_ctx,
1110                                                TLS_PEER_CERTIFICATE, &ev);
1111                         wpabuf_free(cert_buf);
1112                 }
1113
1114                 if (i == 0) {
1115                         if (conn->suffix_match &&
1116                             !gnutls_x509_crt_check_hostname(
1117                                     cert, conn->suffix_match)) {
1118                                 wpa_printf(MSG_WARNING,
1119                                            "TLS: Domain suffix match '%s' not found",
1120                                            conn->suffix_match);
1121                                 gnutls_tls_fail_event(
1122                                         conn, &certs[i], i, buf,
1123                                         "Domain suffix mismatch",
1124                                         TLS_FAIL_DOMAIN_SUFFIX_MISMATCH);
1125                                 err = GNUTLS_A_BAD_CERTIFICATE;
1126                                 gnutls_x509_crt_deinit(cert);
1127                                 os_free(buf);
1128                                 goto out;
1129                         }
1130
1131 #if GNUTLS_VERSION_NUMBER >= 0x030300
1132                         if (conn->domain_match &&
1133                             !gnutls_x509_crt_check_hostname2(
1134                                     cert, conn->domain_match,
1135                                     GNUTLS_VERIFY_DO_NOT_ALLOW_WILDCARDS)) {
1136                                 wpa_printf(MSG_WARNING,
1137                                            "TLS: Domain match '%s' not found",
1138                                            conn->domain_match);
1139                                 gnutls_tls_fail_event(
1140                                         conn, &certs[i], i, buf,
1141                                         "Domain mismatch",
1142                                         TLS_FAIL_DOMAIN_MISMATCH);
1143                                 err = GNUTLS_A_BAD_CERTIFICATE;
1144                                 gnutls_x509_crt_deinit(cert);
1145                                 os_free(buf);
1146                                 goto out;
1147                         }
1148 #endif /* >= 3.3.0 */
1149
1150                         /* TODO: validate altsubject_match.
1151                          * For now, any such configuration is rejected in
1152                          * tls_connection_set_params() */
1153
1154 #if GNUTLS_VERSION_NUMBER < 0x030300
1155                         /*
1156                          * gnutls_certificate_verify_peers() not available, so
1157                          * need to check EKU separately.
1158                          */
1159                         if (!conn->global->server &&
1160                             !server_eku_purpose(cert)) {
1161                                 wpa_printf(MSG_WARNING,
1162                                            "GnuTLS: No server EKU");
1163                                 gnutls_tls_fail_event(
1164                                         conn, &certs[i], i, buf,
1165                                         "No server EKU",
1166                                         TLS_FAIL_BAD_CERTIFICATE);
1167                                 err = GNUTLS_A_BAD_CERTIFICATE;
1168                                 gnutls_x509_crt_deinit(cert);
1169                                 os_free(buf);
1170                                 goto out;
1171                         }
1172 #endif /* < 3.3.0 */
1173                 }
1174
1175                 if (!conn->disable_time_checks &&
1176                     (gnutls_x509_crt_get_expiration_time(cert) < now.sec ||
1177                      gnutls_x509_crt_get_activation_time(cert) > now.sec)) {
1178                         wpa_printf(MSG_INFO, "TLS: Peer certificate %d/%d is "
1179                                    "not valid at this time",
1180                                    i + 1, num_certs);
1181                         gnutls_tls_fail_event(
1182                                 conn, &certs[i], i, buf,
1183                                 "Certificate is not valid at this time",
1184                                 TLS_FAIL_EXPIRED);
1185                         gnutls_x509_crt_deinit(cert);
1186                         os_free(buf);
1187                         err = GNUTLS_A_CERTIFICATE_EXPIRED;
1188                         goto out;
1189                 }
1190
1191                 os_free(buf);
1192
1193                 gnutls_x509_crt_deinit(cert);
1194         }
1195
1196         if (conn->global->event_cb != NULL)
1197                 conn->global->event_cb(conn->global->cb_ctx,
1198                                        TLS_CERT_CHAIN_SUCCESS, NULL);
1199
1200         return 0;
1201
1202 out:
1203         conn->failed++;
1204         gnutls_alert_send(session, GNUTLS_AL_FATAL, err);
1205         return GNUTLS_E_CERTIFICATE_ERROR;
1206 }
1207
1208
1209 static struct wpabuf * gnutls_get_appl_data(struct tls_connection *conn)
1210 {
1211         int res;
1212         struct wpabuf *ad;
1213         wpa_printf(MSG_DEBUG, "GnuTLS: Check for possible Application Data");
1214         ad = wpabuf_alloc((wpabuf_len(conn->pull_buf) + 500) * 3);
1215         if (ad == NULL)
1216                 return NULL;
1217
1218         res = gnutls_record_recv(conn->session, wpabuf_mhead(ad),
1219                                  wpabuf_size(ad));
1220         wpa_printf(MSG_DEBUG, "GnuTLS: gnutls_record_recv: %d", res);
1221         if (res < 0) {
1222                 wpa_printf(MSG_DEBUG, "%s - gnutls_record_recv failed: %d "
1223                            "(%s)", __func__, (int) res,
1224                            gnutls_strerror(res));
1225                 wpabuf_free(ad);
1226                 return NULL;
1227         }
1228
1229         wpabuf_put(ad, res);
1230         wpa_printf(MSG_DEBUG, "GnuTLS: Received %d bytes of Application Data",
1231                    res);
1232         return ad;
1233 }
1234
1235
1236 struct wpabuf * tls_connection_handshake(void *tls_ctx,
1237                                          struct tls_connection *conn,
1238                                          const struct wpabuf *in_data,
1239                                          struct wpabuf **appl_data)
1240 {
1241         struct tls_global *global = tls_ctx;
1242         struct wpabuf *out_data;
1243         int ret;
1244
1245         if (appl_data)
1246                 *appl_data = NULL;
1247
1248         if (in_data && wpabuf_len(in_data) > 0) {
1249                 if (conn->pull_buf) {
1250                         wpa_printf(MSG_DEBUG, "%s - %lu bytes remaining in "
1251                                    "pull_buf", __func__,
1252                                    (unsigned long) wpabuf_len(conn->pull_buf));
1253                         wpabuf_free(conn->pull_buf);
1254                 }
1255                 conn->pull_buf = wpabuf_dup(in_data);
1256                 if (conn->pull_buf == NULL)
1257                         return NULL;
1258                 conn->pull_buf_offset = wpabuf_head(conn->pull_buf);
1259         }
1260
1261         ret = gnutls_handshake(conn->session);
1262         if (ret < 0) {
1263                 gnutls_alert_description_t alert;
1264
1265                 switch (ret) {
1266                 case GNUTLS_E_AGAIN:
1267                         if (global->server && conn->established &&
1268                             conn->push_buf == NULL) {
1269                                 /* Need to return something to trigger
1270                                  * completion of EAP-TLS. */
1271                                 conn->push_buf = wpabuf_alloc(0);
1272                         }
1273                         break;
1274                 case GNUTLS_E_FATAL_ALERT_RECEIVED:
1275                         alert = gnutls_alert_get(conn->session);
1276                         wpa_printf(MSG_DEBUG, "%s - received fatal '%s' alert",
1277                                    __func__, gnutls_alert_get_name(alert));
1278                         conn->read_alerts++;
1279                         if (conn->global->event_cb != NULL) {
1280                                 union tls_event_data ev;
1281
1282                                 os_memset(&ev, 0, sizeof(ev));
1283                                 ev.alert.is_local = 0;
1284                                 ev.alert.type = gnutls_alert_get_name(alert);
1285                                 ev.alert.description = ev.alert.type;
1286                                 conn->global->event_cb(conn->global->cb_ctx,
1287                                                        TLS_ALERT, &ev);
1288                         }
1289                         /* continue */
1290                 default:
1291                         wpa_printf(MSG_DEBUG, "%s - gnutls_handshake failed "
1292                                    "-> %s", __func__, gnutls_strerror(ret));
1293                         conn->failed++;
1294                 }
1295         } else {
1296                 size_t size;
1297
1298                 wpa_printf(MSG_DEBUG, "TLS: Handshake completed successfully");
1299
1300 #if GNUTLS_VERSION_NUMBER >= 0x03010a
1301                 {
1302                         char *desc;
1303
1304                         desc = gnutls_session_get_desc(conn->session);
1305                         if (desc) {
1306                                 wpa_printf(MSG_DEBUG, "GnuTLS: %s", desc);
1307                                 gnutls_free(desc);
1308                         }
1309                 }
1310 #endif /* GnuTLS 3.1.10 or newer */
1311
1312                 conn->established = 1;
1313                 if (conn->push_buf == NULL) {
1314                         /* Need to return something to get final TLS ACK. */
1315                         conn->push_buf = wpabuf_alloc(0);
1316                 }
1317
1318                 gnutls_session_get_data(conn->session, NULL, &size);
1319                 if (global->session_data == NULL ||
1320                     global->session_data_size < size) {
1321                         os_free(global->session_data);
1322                         global->session_data = os_malloc(size);
1323                 }
1324                 if (global->session_data) {
1325                         global->session_data_size = size;
1326                         gnutls_session_get_data(conn->session,
1327                                                 global->session_data,
1328                                                 &global->session_data_size);
1329                 }
1330
1331                 if (conn->pull_buf && appl_data)
1332                         *appl_data = gnutls_get_appl_data(conn);
1333         }
1334
1335         out_data = conn->push_buf;
1336         conn->push_buf = NULL;
1337         return out_data;
1338 }
1339
1340
1341 struct wpabuf * tls_connection_server_handshake(void *tls_ctx,
1342                                                 struct tls_connection *conn,
1343                                                 const struct wpabuf *in_data,
1344                                                 struct wpabuf **appl_data)
1345 {
1346         return tls_connection_handshake(tls_ctx, conn, in_data, appl_data);
1347 }
1348
1349
1350 struct wpabuf * tls_connection_encrypt(void *tls_ctx,
1351                                        struct tls_connection *conn,
1352                                        const struct wpabuf *in_data)
1353 {
1354         ssize_t res;
1355         struct wpabuf *buf;
1356
1357         res = gnutls_record_send(conn->session, wpabuf_head(in_data),
1358                                  wpabuf_len(in_data));
1359         if (res < 0) {
1360                 wpa_printf(MSG_INFO, "%s: Encryption failed: %s",
1361                            __func__, gnutls_strerror(res));
1362                 return NULL;
1363         }
1364
1365         buf = conn->push_buf;
1366         conn->push_buf = NULL;
1367         return buf;
1368 }
1369
1370
1371 struct wpabuf * tls_connection_decrypt(void *tls_ctx,
1372                                        struct tls_connection *conn,
1373                                        const struct wpabuf *in_data)
1374 {
1375         ssize_t res;
1376         struct wpabuf *out;
1377
1378         if (conn->pull_buf) {
1379                 wpa_printf(MSG_DEBUG, "%s - %lu bytes remaining in "
1380                            "pull_buf", __func__,
1381                            (unsigned long) wpabuf_len(conn->pull_buf));
1382                 wpabuf_free(conn->pull_buf);
1383         }
1384         conn->pull_buf = wpabuf_dup(in_data);
1385         if (conn->pull_buf == NULL)
1386                 return NULL;
1387         conn->pull_buf_offset = wpabuf_head(conn->pull_buf);
1388
1389         /*
1390          * Even though we try to disable TLS compression, it is possible that
1391          * this cannot be done with all TLS libraries. Add extra buffer space
1392          * to handle the possibility of the decrypted data being longer than
1393          * input data.
1394          */
1395         out = wpabuf_alloc((wpabuf_len(in_data) + 500) * 3);
1396         if (out == NULL)
1397                 return NULL;
1398
1399         res = gnutls_record_recv(conn->session, wpabuf_mhead(out),
1400                                  wpabuf_size(out));
1401         if (res < 0) {
1402                 wpa_printf(MSG_DEBUG, "%s - gnutls_record_recv failed: %d "
1403                            "(%s)", __func__, (int) res, gnutls_strerror(res));
1404                 wpabuf_free(out);
1405                 return NULL;
1406         }
1407         wpabuf_put(out, res);
1408
1409         return out;
1410 }
1411
1412
1413 int tls_connection_resumed(void *ssl_ctx, struct tls_connection *conn)
1414 {
1415         if (conn == NULL)
1416                 return 0;
1417         return gnutls_session_is_resumed(conn->session);
1418 }
1419
1420
1421 int tls_connection_set_cipher_list(void *tls_ctx, struct tls_connection *conn,
1422                                    u8 *ciphers)
1423 {
1424         /* TODO */
1425         return -1;
1426 }
1427
1428
1429 int tls_get_cipher(void *ssl_ctx, struct tls_connection *conn,
1430                    char *buf, size_t buflen)
1431 {
1432         /* TODO */
1433         buf[0] = '\0';
1434         return 0;
1435 }
1436
1437
1438 int tls_connection_enable_workaround(void *ssl_ctx,
1439                                      struct tls_connection *conn)
1440 {
1441         gnutls_record_disable_padding(conn->session);
1442         return 0;
1443 }
1444
1445
1446 int tls_connection_client_hello_ext(void *ssl_ctx, struct tls_connection *conn,
1447                                     int ext_type, const u8 *data,
1448                                     size_t data_len)
1449 {
1450         /* TODO */
1451         return -1;
1452 }
1453
1454
1455 int tls_connection_get_failed(void *ssl_ctx, struct tls_connection *conn)
1456 {
1457         if (conn == NULL)
1458                 return -1;
1459         return conn->failed;
1460 }
1461
1462
1463 int tls_connection_get_read_alerts(void *ssl_ctx, struct tls_connection *conn)
1464 {
1465         if (conn == NULL)
1466                 return -1;
1467         return conn->read_alerts;
1468 }
1469
1470
1471 int tls_connection_get_write_alerts(void *ssl_ctx, struct tls_connection *conn)
1472 {
1473         if (conn == NULL)
1474                 return -1;
1475         return conn->write_alerts;
1476 }
1477
1478
1479 int tls_connection_get_keyblock_size(void *tls_ctx,
1480                                      struct tls_connection *conn)
1481 {
1482         /* TODO */
1483         return -1;
1484 }
1485
1486
1487 unsigned int tls_capabilities(void *tls_ctx)
1488 {
1489         return 0;
1490 }
1491
1492
1493 int tls_connection_set_session_ticket_cb(void *tls_ctx,
1494                                          struct tls_connection *conn,
1495                                          tls_session_ticket_cb cb, void *ctx)
1496 {
1497         return -1;
1498 }
1499
1500
1501 int tls_get_library_version(char *buf, size_t buf_len)
1502 {
1503         return os_snprintf(buf, buf_len, "GnuTLS build=%s run=%s",
1504                            GNUTLS_VERSION, gnutls_check_version(NULL));
1505 }