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