tls_openssl.c

   1 /*
   2  * WPA Supplicant / SSL/TLS interface functions for openssl
   3  * Copyright (c) 2004-2006, Jouni Malinen <j@w1.fi>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * Alternatively, this software may be distributed under the terms of BSD
  10  * license.
  11  *
  12  * See README and COPYING for more details.
  13  */
  14
  15 #include "includes.h"
  16
  17 #ifndef CONFIG_SMARTCARD
  18 #ifndef OPENSSL_NO_ENGINE
  19 #define OPENSSL_NO_ENGINE
  20 #endif
  21 #endif
  22
  23 #include <openssl/ssl.h>
  24 #include <openssl/err.h>
  25 #include <openssl/pkcs12.h>
  26 #include <openssl/x509v3.h>
  27 #ifndef OPENSSL_NO_ENGINE
  28 #include <openssl/engine.h>
  29 #endif /* OPENSSL_NO_ENGINE */
  30
  31 #include "common.h"
  32 #include "tls.h"
  33
  34 #if OPENSSL_VERSION_NUMBER >= 0x0090800fL
  35 #define OPENSSL_d2i_TYPE const unsigned char **
  36 #else
  37 #define OPENSSL_d2i_TYPE unsigned char **
  38 #endif
  39
  40 static int tls_openssl_ref_count = 0;
  41
  42 struct tls_connection {
  43         SSL *ssl;
  44         BIO *ssl_in, *ssl_out;
  45 #ifndef OPENSSL_NO_ENGINE
  46         ENGINE *engine;        /* functional reference to the engine */
  47         EVP_PKEY *private_key; /* the private key if using engine */
  48 #endif /* OPENSSL_NO_ENGINE */
  49         char *subject_match, *altsubject_match;
  50         int read_alerts, write_alerts, failed;
  51
  52         u8 *pre_shared_secret;
  53         size_t pre_shared_secret_len;
  54 };
  55
  56
  57 #ifdef CONFIG_NO_STDOUT_DEBUG
  58
  59 static void _tls_show_errors(void)
  60 {
  61         unsigned long err;
  62
  63         while ((err = ERR_get_error())) {
  64                 /* Just ignore the errors, since stdout is disabled */
  65         }
  66 }
  67 #define tls_show_errors(l, f, t) _tls_show_errors()
  68
  69 #else /* CONFIG_NO_STDOUT_DEBUG */
  70
  71 static void tls_show_errors(int level, const char *func, const char *txt)
  72 {
  73         unsigned long err;
  74
  75         wpa_printf(level, "OpenSSL: %s - %s %s",
  76                    func, txt, ERR_error_string(ERR_get_error(), NULL));
  77
  78         while ((err = ERR_get_error())) {
  79                 wpa_printf(MSG_INFO, "OpenSSL: pending error: %s",
  80                            ERR_error_string(err, NULL));
  81         }
  82 }
  83
  84 #endif /* CONFIG_NO_STDOUT_DEBUG */
  85
  86
  87 #ifdef CONFIG_NATIVE_WINDOWS
  88
  89 /* Windows CryptoAPI and access to certificate stores */
  90 #include <wincrypt.h>
  91
  92 #ifdef __MINGW32_VERSION
  93 /*
  94  * MinGW does not yet include all the needed definitions for CryptoAPI, so
  95  * define here whatever extra is needed.
  96  */
  97 #define CALG_SSL3_SHAMD5 (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_SSL3SHAMD5)
  98 #define CERT_SYSTEM_STORE_CURRENT_USER (1 << 16)
  99 #define CERT_STORE_READONLY_FLAG 0x00008000
 100 #define CERT_STORE_OPEN_EXISTING_FLAG 0x00004000
 101 #define CRYPT_ACQUIRE_COMPARE_KEY_FLAG 0x00000004
 102
 103 static BOOL WINAPI
 104 (*CryptAcquireCertificatePrivateKey)(PCCERT_CONTEXT pCert, DWORD dwFlags,
 105                                      void *pvReserved, HCRYPTPROV *phCryptProv,
 106                                      DWORD *pdwKeySpec, BOOL *pfCallerFreeProv)
 107 = NULL; /* to be loaded from crypt32.dll */
 108
 109 static PCCERT_CONTEXT WINAPI
 110 (*CertEnumCertificatesInStore)(HCERTSTORE hCertStore,
 111                                PCCERT_CONTEXT pPrevCertContext)
 112 = NULL; /* to be loaded from crypt32.dll */
 113
 114 static int mingw_load_crypto_func(void)
 115 {
 116         HINSTANCE dll;
 117
 118         /* MinGW does not yet have full CryptoAPI support, so load the needed
 119          * function here. */
 120
 121         if (CryptAcquireCertificatePrivateKey)
 122                 return 0;
 123
 124         dll = LoadLibrary("crypt32");
 125         if (dll == NULL) {
 126                 wpa_printf(MSG_DEBUG, "CryptoAPI: Could not load crypt32 "
 127                            "library");
 128                 return -1;
 129         }
 130
 131         CryptAcquireCertificatePrivateKey = GetProcAddress(
 132                 dll, "CryptAcquireCertificatePrivateKey");
 133         if (CryptAcquireCertificatePrivateKey == NULL) {
 134                 wpa_printf(MSG_DEBUG, "CryptoAPI: Could not get "
 135                            "CryptAcquireCertificatePrivateKey() address from "
 136                            "crypt32 library");
 137                 return -1;
 138         }
 139
 140         CertEnumCertificatesInStore = (void *) GetProcAddress(
 141                 dll, "CertEnumCertificatesInStore");
 142         if (CertEnumCertificatesInStore == NULL) {
 143                 wpa_printf(MSG_DEBUG, "CryptoAPI: Could not get "
 144                            "CertEnumCertificatesInStore() address from "
 145                            "crypt32 library");
 146                 return -1;
 147         }
 148
 149         return 0;
 150 }
 151
 152 #else /* __MINGW32_VERSION */
 153
 154 static int mingw_load_crypto_func(void)
 155 {
 156         return 0;
 157 }
 158
 159 #endif /* __MINGW32_VERSION */
 160
 161
 162 struct cryptoapi_rsa_data {
 163         const CERT_CONTEXT *cert;
 164         HCRYPTPROV crypt_prov;
 165         DWORD key_spec;
 166         BOOL free_crypt_prov;
 167 };
 168
 169
 170 static void cryptoapi_error(const char *msg)
 171 {
 172         wpa_printf(MSG_INFO, "CryptoAPI: %s; err=%u",
 173                    msg, (unsigned int) GetLastError());
 174 }
 175
 176
 177 static int cryptoapi_rsa_pub_enc(int flen, const unsigned char *from,
 178                                  unsigned char *to, RSA *rsa, int padding)
 179 {
 180         wpa_printf(MSG_DEBUG, "%s - not implemented", __func__);
 181         return 0;
 182 }
 183
 184
 185 static int cryptoapi_rsa_pub_dec(int flen, const unsigned char *from,
 186                                  unsigned char *to, RSA *rsa, int padding)
 187 {
 188         wpa_printf(MSG_DEBUG, "%s - not implemented", __func__);
 189         return 0;
 190 }
 191
 192
 193 static int cryptoapi_rsa_priv_enc(int flen, const unsigned char *from,
 194                                   unsigned char *to, RSA *rsa, int padding)
 195 {
 196         struct cryptoapi_rsa_data *priv =
 197                 (struct cryptoapi_rsa_data *) rsa->meth->app_data;
 198         HCRYPTHASH hash;
 199         DWORD hash_size, len, i;
 200         unsigned char *buf = NULL;
 201         int ret = 0;
 202
 203         if (priv == NULL) {
 204                 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,
 205                        ERR_R_PASSED_NULL_PARAMETER);
 206                 return 0;
 207         }
 208
 209         if (padding != RSA_PKCS1_PADDING) {
 210                 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,
 211                        RSA_R_UNKNOWN_PADDING_TYPE);
 212                 return 0;
 213         }
 214
 215         if (flen != 16 /* MD5 */ + 20 /* SHA-1 */) {
 216                 wpa_printf(MSG_INFO, "%s - only MD5-SHA1 hash supported",
 217                            __func__);
 218                 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,
 219                        RSA_R_INVALID_MESSAGE_LENGTH);
 220                 return 0;
 221         }
 222
 223         if (!CryptCreateHash(priv->crypt_prov, CALG_SSL3_SHAMD5, 0, 0, &hash))
 224         {
 225                 cryptoapi_error("CryptCreateHash failed");
 226                 return 0;
 227         }
 228
 229         len = sizeof(hash_size);
 230         if (!CryptGetHashParam(hash, HP_HASHSIZE, (BYTE *) &hash_size, &len,
 231                                0)) {
 232                 cryptoapi_error("CryptGetHashParam failed");
 233                 goto err;
 234         }
 235
 236         if ((int) hash_size != flen) {
 237                 wpa_printf(MSG_INFO, "CryptoAPI: Invalid hash size (%u != %d)",
 238                            (unsigned) hash_size, flen);
 239                 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,
 240                        RSA_R_INVALID_MESSAGE_LENGTH);
 241                 goto err;
 242         }
 243         if (!CryptSetHashParam(hash, HP_HASHVAL, (BYTE * ) from, 0)) {
 244                 cryptoapi_error("CryptSetHashParam failed");
 245                 goto err;
 246         }
 247
 248         len = RSA_size(rsa);
 249         buf = os_malloc(len);
 250         if (buf == NULL) {
 251                 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT, ERR_R_MALLOC_FAILURE);
 252                 goto err;
 253         }
 254
 255         if (!CryptSignHash(hash, priv->key_spec, NULL, 0, buf, &len)) {
 256                 cryptoapi_error("CryptSignHash failed");
 257                 goto err;
 258         }
 259
 260         for (i = 0; i < len; i++)
 261                 to[i] = buf[len - i - 1];
 262         ret = len;
 263
 264 err:
 265         os_free(buf);
 266         CryptDestroyHash(hash);
 267
 268         return ret;
 269 }
 270
 271
 272 static int cryptoapi_rsa_priv_dec(int flen, const unsigned char *from,
 273                                   unsigned char *to, RSA *rsa, int padding)
 274 {
 275         wpa_printf(MSG_DEBUG, "%s - not implemented", __func__);
 276         return 0;
 277 }
 278
 279
 280 static void cryptoapi_free_data(struct cryptoapi_rsa_data *priv)
 281 {
 282         if (priv == NULL)
 283                 return;
 284         if (priv->crypt_prov && priv->free_crypt_prov)
 285                 CryptReleaseContext(priv->crypt_prov, 0);
 286         if (priv->cert)
 287                 CertFreeCertificateContext(priv->cert);
 288         os_free(priv);
 289 }
 290
 291
 292 static int cryptoapi_finish(RSA *rsa)
 293 {
 294         cryptoapi_free_data((struct cryptoapi_rsa_data *) rsa->meth->app_data);
 295         os_free((void *) rsa->meth);
 296         rsa->meth = NULL;
 297         return 1;
 298 }
 299
 300
 301 static const CERT_CONTEXT * cryptoapi_find_cert(const char *name, DWORD store)
 302 {
 303         HCERTSTORE cs;
 304         const CERT_CONTEXT *ret = NULL;
 305
 306         cs = CertOpenStore((LPCSTR) CERT_STORE_PROV_SYSTEM, 0, 0,
 307                            store | CERT_STORE_OPEN_EXISTING_FLAG |
 308                            CERT_STORE_READONLY_FLAG, L"MY");
 309         if (cs == NULL) {
 310                 cryptoapi_error("Failed to open 'My system store'");
 311                 return NULL;
 312         }
 313
 314         if (strncmp(name, "cert://", 7) == 0) {
 315                 unsigned short wbuf[255];
 316                 MultiByteToWideChar(CP_ACP, 0, name + 7, -1, wbuf, 255);
 317                 ret = CertFindCertificateInStore(cs, X509_ASN_ENCODING |
 318                                                  PKCS_7_ASN_ENCODING,
 319                                                  0, CERT_FIND_SUBJECT_STR,
 320                                                  wbuf, NULL);
 321         } else if (strncmp(name, "hash://", 7) == 0) {
 322                 CRYPT_HASH_BLOB blob;
 323                 int len;
 324                 const char *hash = name + 7;
 325                 unsigned char *buf;
 326
 327                 len = os_strlen(hash) / 2;
 328                 buf = os_malloc(len);
 329                 if (buf && hexstr2bin(hash, buf, len) == 0) {
 330                         blob.cbData = len;
 331                         blob.pbData = buf;
 332                         ret = CertFindCertificateInStore(cs,
 333                                                          X509_ASN_ENCODING |
 334                                                          PKCS_7_ASN_ENCODING,
 335                                                          0, CERT_FIND_HASH,
 336                                                          &blob, NULL);
 337                 }
 338                 os_free(buf);
 339         }
 340
 341         CertCloseStore(cs, 0);
 342
 343         return ret;
 344 }
 345
 346
 347 static int tls_cryptoapi_cert(SSL *ssl, const char *name)
 348 {
 349         X509 *cert = NULL;
 350         RSA *rsa = NULL, *pub_rsa;
 351         struct cryptoapi_rsa_data *priv;
 352         RSA_METHOD *rsa_meth;
 353
 354         if (name == NULL ||
 355             (strncmp(name, "cert://", 7) != 0 &&
 356              strncmp(name, "hash://", 7) != 0))
 357                 return -1;
 358
 359         priv = os_zalloc(sizeof(*priv));
 360         rsa_meth = os_zalloc(sizeof(*rsa_meth));
 361         if (priv == NULL || rsa_meth == NULL) {
 362                 wpa_printf(MSG_WARNING, "CryptoAPI: Failed to allocate memory "
 363                            "for CryptoAPI RSA method");
 364                 os_free(priv);
 365                 os_free(rsa_meth);
 366                 return -1;
 367         }
 368
 369         priv->cert = cryptoapi_find_cert(name, CERT_SYSTEM_STORE_CURRENT_USER);
 370         if (priv->cert == NULL) {
 371                 priv->cert = cryptoapi_find_cert(
 372                         name, CERT_SYSTEM_STORE_LOCAL_MACHINE);
 373         }
 374         if (priv->cert == NULL) {
 375                 wpa_printf(MSG_INFO, "CryptoAPI: Could not find certificate "
 376                            "'%s'", name);
 377                 goto err;
 378         }
 379
 380         cert = d2i_X509(NULL, (OPENSSL_d2i_TYPE) &priv->cert->pbCertEncoded,
 381                         priv->cert->cbCertEncoded);
 382         if (cert == NULL) {
 383                 wpa_printf(MSG_INFO, "CryptoAPI: Could not process X509 DER "
 384                            "encoding");
 385                 goto err;
 386         }
 387
 388         if (mingw_load_crypto_func())
 389                 goto err;
 390
 391         if (!CryptAcquireCertificatePrivateKey(priv->cert,
 392                                                CRYPT_ACQUIRE_COMPARE_KEY_FLAG,
 393                                                NULL, &priv->crypt_prov,
 394                                                &priv->key_spec,
 395                                                &priv->free_crypt_prov)) {
 396                 cryptoapi_error("Failed to acquire a private key for the "
 397                                 "certificate");
 398                 goto err;
 399         }
 400
 401         rsa_meth->name = "Microsoft CryptoAPI RSA Method";
 402         rsa_meth->rsa_pub_enc = cryptoapi_rsa_pub_enc;
 403         rsa_meth->rsa_pub_dec = cryptoapi_rsa_pub_dec;
 404         rsa_meth->rsa_priv_enc = cryptoapi_rsa_priv_enc;
 405         rsa_meth->rsa_priv_dec = cryptoapi_rsa_priv_dec;
 406         rsa_meth->finish = cryptoapi_finish;
 407         rsa_meth->flags = RSA_METHOD_FLAG_NO_CHECK;
 408         rsa_meth->app_data = (char *) priv;
 409
 410         rsa = RSA_new();
 411         if (rsa == NULL) {
 412                 SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_FILE,
 413                        ERR_R_MALLOC_FAILURE);
 414                 goto err;
 415         }
 416
 417         if (!SSL_use_certificate(ssl, cert)) {
 418                 RSA_free(rsa);
 419                 rsa = NULL;
 420                 goto err;
 421         }
 422         pub_rsa = cert->cert_info->key->pkey->pkey.rsa;
 423         X509_free(cert);
 424         cert = NULL;
 425
 426         rsa->n = BN_dup(pub_rsa->n);
 427         rsa->e = BN_dup(pub_rsa->e);
 428         if (!RSA_set_method(rsa, rsa_meth))
 429                 goto err;
 430
 431         if (!SSL_use_RSAPrivateKey(ssl, rsa))
 432                 goto err;
 433         RSA_free(rsa);
 434
 435         return 0;
 436
 437 err:
 438         if (cert)
 439                 X509_free(cert);
 440         if (rsa)
 441                 RSA_free(rsa);
 442         else {
 443                 os_free(rsa_meth);
 444                 cryptoapi_free_data(priv);
 445         }
 446         return -1;
 447 }
 448
 449
 450 static int tls_cryptoapi_ca_cert(SSL_CTX *ssl_ctx, SSL *ssl, const char *name)
 451 {
 452         HCERTSTORE cs;
 453         PCCERT_CONTEXT ctx = NULL;
 454         X509 *cert;
 455         char buf[128];
 456         const char *store;
 457 #ifdef UNICODE
 458         WCHAR *wstore;
 459 #endif /* UNICODE */
 460
 461         if (mingw_load_crypto_func())
 462                 return -1;
 463
 464         if (name == NULL || strncmp(name, "cert_store://", 13) != 0)
 465                 return -1;
 466
 467         store = name + 13;
 468 #ifdef UNICODE
 469         wstore = os_malloc((os_strlen(store) + 1) * sizeof(WCHAR));
 470         if (wstore == NULL)
 471                 return -1;
 472         wsprintf(wstore, L"%S", store);
 473         cs = CertOpenSystemStore(0, wstore);
 474         os_free(wstore);
 475 #else /* UNICODE */
 476         cs = CertOpenSystemStore(0, store);
 477 #endif /* UNICODE */
 478         if (cs == NULL) {
 479                 wpa_printf(MSG_DEBUG, "%s: failed to open system cert store "
 480                            "'%s': error=%d", __func__, store,
 481                            (int) GetLastError());
 482                 return -1;
 483         }
 484
 485         while ((ctx = CertEnumCertificatesInStore(cs, ctx))) {
 486                 cert = d2i_X509(NULL, (OPENSSL_d2i_TYPE) &ctx->pbCertEncoded,
 487                                 ctx->cbCertEncoded);
 488                 if (cert == NULL) {
 489                         wpa_printf(MSG_INFO, "CryptoAPI: Could not process "
 490                                    "X509 DER encoding for CA cert");
 491                         continue;
 492                 }
 493
 494                 X509_NAME_oneline(X509_get_subject_name(cert), buf,
 495                                   sizeof(buf));
 496                 wpa_printf(MSG_DEBUG, "OpenSSL: Loaded CA certificate for "
 497                            "system certificate store: subject='%s'", buf);
 498
 499                 if (!X509_STORE_add_cert(ssl_ctx->cert_store, cert)) {
 500                         tls_show_errors(MSG_WARNING, __func__,
 501                                         "Failed to add ca_cert to OpenSSL "
 502                                         "certificate store");
 503                 }
 504
 505                 X509_free(cert);
 506         }
 507
 508         if (!CertCloseStore(cs, 0)) {
 509                 wpa_printf(MSG_DEBUG, "%s: failed to close system cert store "
 510                            "'%s': error=%d", __func__, name + 13,
 511                            (int) GetLastError());
 512         }
 513
 514         return 0;
 515 }
 516
 517
 518 #else /* CONFIG_NATIVE_WINDOWS */
 519
 520 static int tls_cryptoapi_cert(SSL *ssl, const char *name)
 521 {
 522         return -1;
 523 }
 524
 525 #endif /* CONFIG_NATIVE_WINDOWS */
 526
 527
 528 static void ssl_info_cb(const SSL *ssl, int where, int ret)
 529 {
 530         const char *str;
 531         int w;
 532
 533         wpa_printf(MSG_DEBUG, "SSL: (where=0x%x ret=0x%x)", where, ret);
 534         w = where & ~SSL_ST_MASK;
 535         if (w & SSL_ST_CONNECT)
 536                 str = "SSL_connect";
 537         else if (w & SSL_ST_ACCEPT)
 538                 str = "SSL_accept";
 539         else
 540                 str = "undefined";
 541
 542         if (where & SSL_CB_LOOP) {
 543                 wpa_printf(MSG_DEBUG, "SSL: %s:%s",
 544                            str, SSL_state_string_long(ssl));
 545         } else if (where & SSL_CB_ALERT) {
 546                 wpa_printf(MSG_INFO, "SSL: SSL3 alert: %s:%s:%s",
 547                            where & SSL_CB_READ ?
 548                            "read (remote end reported an error)" :
 549                            "write (local SSL3 detected an error)",
 550                            SSL_alert_type_string_long(ret),
 551                            SSL_alert_desc_string_long(ret));
 552                 if ((ret >> 8) == SSL3_AL_FATAL) {
 553                         struct tls_connection *conn =
 554                                 SSL_get_app_data((SSL *) ssl);
 555                         if (where & SSL_CB_READ)
 556                                 conn->read_alerts++;
 557                         else
 558                                 conn->write_alerts++;
 559                 }
 560         } else if (where & SSL_CB_EXIT && ret <= 0) {
 561                 wpa_printf(MSG_DEBUG, "SSL: %s:%s in %s",
 562                            str, ret == 0 ? "failed" : "error",
 563                            SSL_state_string_long(ssl));
 564         }
 565 }
 566
 567
 568 #ifndef OPENSSL_NO_ENGINE
 569 /**
 570  * tls_engine_load_dynamic_generic - load any openssl engine
 571  * @pre: an array of commands and values that load an engine initialized
 572  *       in the engine specific function
 573  * @post: an array of commands and values that initialize an already loaded
 574  *        engine (or %NULL if not required)
 575  * @id: the engine id of the engine to load (only required if post is not %NULL
 576  *
 577  * This function is a generic function that loads any openssl engine.
 578  *
 579  * Returns: 0 on success, -1 on failure
 580  */
 581 static int tls_engine_load_dynamic_generic(const char *pre[],
 582                                            const char *post[], const char *id)
 583 {
 584         ENGINE *engine;
 585         const char *dynamic_id = "dynamic";
 586
 587         engine = ENGINE_by_id(id);
 588         if (engine) {
 589                 ENGINE_free(engine);
 590                 wpa_printf(MSG_DEBUG, "ENGINE: engine '%s' is already "
 591                            "available", id);
 592                 return 0;
 593         }
 594         ERR_clear_error();
 595
 596         engine = ENGINE_by_id(dynamic_id);
 597         if (engine == NULL) {
 598                 wpa_printf(MSG_INFO, "ENGINE: Can't find engine %s [%s]",
 599                            dynamic_id,
 600                            ERR_error_string(ERR_get_error(), NULL));
 601                 return -1;
 602         }
 603
 604         /* Perform the pre commands. This will load the engine. */
 605         while (pre && pre[0]) {
 606                 wpa_printf(MSG_DEBUG, "ENGINE: '%s' '%s'", pre[0], pre[1]);
 607                 if (ENGINE_ctrl_cmd_string(engine, pre[0], pre[1], 0) == 0) {
 608                         wpa_printf(MSG_INFO, "ENGINE: ctrl cmd_string failed: "
 609                                    "%s %s [%s]", pre[0], pre[1],
 610                                    ERR_error_string(ERR_get_error(), NULL));
 611                         ENGINE_free(engine);
 612                         return -1;
 613                 }
 614                 pre += 2;
 615         }
 616
 617         /*
 618          * Free the reference to the "dynamic" engine. The loaded engine can
 619          * now be looked up using ENGINE_by_id().
 620          */
 621         ENGINE_free(engine);
 622
 623         engine = ENGINE_by_id(id);
 624         if (engine == NULL) {
 625                 wpa_printf(MSG_INFO, "ENGINE: Can't find engine %s [%s]",
 626                            id, ERR_error_string(ERR_get_error(), NULL));
 627                 return -1;
 628         }
 629
 630         while (post && post[0]) {
 631                 wpa_printf(MSG_DEBUG, "ENGINE: '%s' '%s'", post[0], post[1]);
 632                 if (ENGINE_ctrl_cmd_string(engine, post[0], post[1], 0) == 0) {
 633                         wpa_printf(MSG_DEBUG, "ENGINE: ctrl cmd_string failed:"
 634                                 " %s %s [%s]", post[0], post[1],
 635                                    ERR_error_string(ERR_get_error(), NULL));
 636                         ENGINE_remove(engine);
 637                         ENGINE_free(engine);
 638                         return -1;
 639                 }
 640                 post += 2;
 641         }
 642         ENGINE_free(engine);
 643
 644         return 0;
 645 }
 646
 647
 648 /**
 649  * tls_engine_load_dynamic_pkcs11 - load the pkcs11 engine provided by opensc
 650  * @pkcs11_so_path: pksc11_so_path from the configuration
 651  * @pcks11_module_path: pkcs11_module_path from the configuration
 652  */
 653 static int tls_engine_load_dynamic_pkcs11(const char *pkcs11_so_path,
 654                                           const char *pkcs11_module_path)
 655 {
 656         char *engine_id = "pkcs11";
 657         const char *pre_cmd[] = {
 658                 "SO_PATH", NULL /* pkcs11_so_path */,
 659                 "ID", NULL /* engine_id */,
 660                 "LIST_ADD", "1",
 661                 /* "NO_VCHECK", "1", */
 662                 "LOAD", NULL,
 663                 NULL, NULL
 664         };
 665         const char *post_cmd[] = {
 666                 "MODULE_PATH", NULL /* pkcs11_module_path */,
 667                 NULL, NULL
 668         };
 669
 670         if (!pkcs11_so_path || !pkcs11_module_path)
 671                 return 0;
 672
 673         pre_cmd[1] = pkcs11_so_path;
 674         pre_cmd[3] = engine_id;
 675         post_cmd[1] = pkcs11_module_path;
 676
 677         wpa_printf(MSG_DEBUG, "ENGINE: Loading pkcs11 Engine from %s",
 678                    pkcs11_so_path);
 679
 680         return tls_engine_load_dynamic_generic(pre_cmd, post_cmd, engine_id);
 681 }
 682
 683
 684 /**
 685  * tls_engine_load_dynamic_opensc - load the opensc engine provided by opensc
 686  * @opensc_so_path: opensc_so_path from the configuration
 687  */
 688 static int tls_engine_load_dynamic_opensc(const char *opensc_so_path)
 689 {
 690         char *engine_id = "opensc";
 691         const char *pre_cmd[] = {
 692                 "SO_PATH", NULL /* opensc_so_path */,
 693                 "ID", NULL /* engine_id */,
 694                 "LIST_ADD", "1",
 695                 "LOAD", NULL,
 696                 NULL, NULL
 697         };
 698
 699         if (!opensc_so_path)
 700                 return 0;
 701
 702         pre_cmd[1] = opensc_so_path;
 703         pre_cmd[3] = engine_id;
 704
 705         wpa_printf(MSG_DEBUG, "ENGINE: Loading OpenSC Engine from %s",
 706                    opensc_so_path);
 707
 708         return tls_engine_load_dynamic_generic(pre_cmd, NULL, engine_id);
 709 }
 710 #endif /* OPENSSL_NO_ENGINE */
 711
 712
 713 void * tls_init(const struct tls_config *conf)
 714 {
 715         SSL_CTX *ssl;
 716
 717         if (tls_openssl_ref_count == 0) {
 718                 SSL_load_error_strings();
 719                 SSL_library_init();
 720                 /* TODO: if /dev/urandom is available, PRNG is seeded
 721                  * automatically. If this is not the case, random data should
 722                  * be added here. */
 723
 724 #ifdef PKCS12_FUNCS
 725                 PKCS12_PBE_add();
 726 #endif  /* PKCS12_FUNCS */
 727         }
 728         tls_openssl_ref_count++;
 729
 730         ssl = SSL_CTX_new(TLSv1_method());
 731         if (ssl == NULL)
 732                 return NULL;
 733
 734         SSL_CTX_set_info_callback(ssl, ssl_info_cb);
 735
 736 #ifndef OPENSSL_NO_ENGINE
 737         if (conf &&
 738             (conf->opensc_engine_path || conf->pkcs11_engine_path ||
 739              conf->pkcs11_module_path)) {
 740                 wpa_printf(MSG_DEBUG, "ENGINE: Loading dynamic engine");
 741                 ERR_load_ENGINE_strings();
 742                 ENGINE_load_dynamic();
 743
 744                 if (tls_engine_load_dynamic_opensc(conf->opensc_engine_path) ||
 745                     tls_engine_load_dynamic_pkcs11(conf->pkcs11_engine_path,
 746                                                    conf->pkcs11_module_path)) {
 747                         tls_deinit(ssl);
 748                         return NULL;
 749                 }
 750         }
 751 #endif /* OPENSSL_NO_ENGINE */
 752
 753         return ssl;
 754 }
 755
 756
 757 void tls_deinit(void *ssl_ctx)
 758 {
 759         SSL_CTX *ssl = ssl_ctx;
 760         SSL_CTX_free(ssl);
 761
 762         tls_openssl_ref_count--;
 763         if (tls_openssl_ref_count == 0) {
 764 #ifndef OPENSSL_NO_ENGINE
 765                 ENGINE_cleanup();
 766 #endif /* OPENSSL_NO_ENGINE */
 767                 ERR_free_strings();
 768                 EVP_cleanup();
 769         }
 770 }
 771
 772
 773 static int tls_engine_init(struct tls_connection *conn, const char *engine_id,
 774                            const char *pin, const char *key_id)
 775 {
 776 #ifndef OPENSSL_NO_ENGINE
 777         int ret = -1;
 778         if (engine_id == NULL) {
 779                 wpa_printf(MSG_ERROR, "ENGINE: Engine ID not set");
 780                 return -1;
 781         }
 782         if (pin == NULL) {
 783                 wpa_printf(MSG_ERROR, "ENGINE: Smartcard PIN not set");
 784                 return -1;
 785         }
 786         if (key_id == NULL) {
 787                 wpa_printf(MSG_ERROR, "ENGINE: Key Id not set");
 788                 return -1;
 789         }
 790
 791         ERR_clear_error();
 792         conn->engine = ENGINE_by_id(engine_id);
 793         if (!conn->engine) {
 794                 wpa_printf(MSG_ERROR, "ENGINE: engine %s not available [%s]",
 795                            engine_id, ERR_error_string(ERR_get_error(), NULL));
 796                 goto err;
 797         }
 798         if (ENGINE_init(conn->engine) != 1) {
 799                 wpa_printf(MSG_ERROR, "ENGINE: engine init failed "
 800                            "(engine: %s) [%s]", engine_id,
 801                            ERR_error_string(ERR_get_error(), NULL));
 802                 goto err;
 803         }
 804         wpa_printf(MSG_DEBUG, "ENGINE: engine initialized");
 805
 806         if (ENGINE_ctrl_cmd_string(conn->engine, "PIN", pin, 0) == 0) {
 807                 wpa_printf(MSG_ERROR, "ENGINE: cannot set pin [%s]",
 808                            ERR_error_string(ERR_get_error(), NULL));
 809                 goto err;
 810         }
 811         conn->private_key = ENGINE_load_private_key(conn->engine,
 812                                                     key_id, NULL, NULL);
 813         if (!conn->private_key) {
 814                 wpa_printf(MSG_ERROR, "ENGINE: cannot load private key with id"
 815                                 " '%s' [%s]", key_id,
 816                            ERR_error_string(ERR_get_error(), NULL));
 817                 ret = TLS_SET_PARAMS_ENGINE_PRV_INIT_FAILED;
 818                 goto err;
 819         }
 820         return 0;
 821
 822 err:
 823         if (conn->engine) {
 824                 ENGINE_free(conn->engine);
 825                 conn->engine = NULL;
 826         }
 827
 828         if (conn->private_key) {
 829                 EVP_PKEY_free(conn->private_key);
 830                 conn->private_key = NULL;
 831         }
 832
 833         return ret;
 834 #else /* OPENSSL_NO_ENGINE */
 835         return 0;
 836 #endif /* OPENSSL_NO_ENGINE */
 837 }
 838
 839
 840 static void tls_engine_deinit(struct tls_connection *conn)
 841 {
 842 #ifndef OPENSSL_NO_ENGINE
 843         wpa_printf(MSG_DEBUG, "ENGINE: engine deinit");
 844         if (conn->private_key) {
 845                 EVP_PKEY_free(conn->private_key);
 846                 conn->private_key = NULL;
 847         }
 848         if (conn->engine) {
 849                 ENGINE_finish(conn->engine);
 850                 conn->engine = NULL;
 851         }
 852 #endif /* OPENSSL_NO_ENGINE */
 853 }
 854
 855
 856 int tls_get_errors(void *ssl_ctx)
 857 {
 858         int count = 0;
 859         unsigned long err;
 860
 861         while ((err = ERR_get_error())) {
 862                 wpa_printf(MSG_INFO, "TLS - SSL error: %s",
 863                            ERR_error_string(err, NULL));
 864                 count++;
 865         }
 866
 867         return count;
 868 }
 869
 870 struct tls_connection * tls_connection_init(void *ssl_ctx)
 871 {
 872         SSL_CTX *ssl = ssl_ctx;
 873         struct tls_connection *conn;
 874         long options;
 875
 876         conn = os_zalloc(sizeof(*conn));
 877         if (conn == NULL)
 878                 return NULL;
 879         conn->ssl = SSL_new(ssl);
 880         if (conn->ssl == NULL) {
 881                 tls_show_errors(MSG_INFO, __func__,
 882                                 "Failed to initialize new SSL connection");
 883                 os_free(conn);
 884                 return NULL;
 885         }
 886
 887         SSL_set_app_data(conn->ssl, conn);
 888         options = SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 |
 889                 SSL_OP_SINGLE_DH_USE;
 890 #ifdef SSL_OP_NO_COMPRESSION
 891         options |= SSL_OP_NO_COMPRESSION;
 892 #endif /* SSL_OP_NO_COMPRESSION */
 893         SSL_set_options(conn->ssl, options);
 894
 895         conn->ssl_in = BIO_new(BIO_s_mem());
 896         if (!conn->ssl_in) {
 897                 tls_show_errors(MSG_INFO, __func__,
 898                                 "Failed to create a new BIO for ssl_in");
 899                 SSL_free(conn->ssl);
 900                 os_free(conn);
 901                 return NULL;
 902         }
 903
 904         conn->ssl_out = BIO_new(BIO_s_mem());
 905         if (!conn->ssl_out) {
 906                 tls_show_errors(MSG_INFO, __func__,
 907                                 "Failed to create a new BIO for ssl_out");
 908                 SSL_free(conn->ssl);
 909                 BIO_free(conn->ssl_in);
 910                 os_free(conn);
 911                 return NULL;
 912         }
 913
 914         SSL_set_bio(conn->ssl, conn->ssl_in, conn->ssl_out);
 915
 916         return conn;
 917 }
 918
 919
 920 void tls_connection_deinit(void *ssl_ctx, struct tls_connection *conn)
 921 {
 922         if (conn == NULL)
 923                 return;
 924         os_free(conn->pre_shared_secret);
 925         SSL_free(conn->ssl);
 926         tls_engine_deinit(conn);
 927         os_free(conn->subject_match);
 928         os_free(conn->altsubject_match);
 929         os_free(conn);
 930 }
 931
 932
 933 int tls_connection_established(void *ssl_ctx, struct tls_connection *conn)
 934 {
 935         return conn ? SSL_is_init_finished(conn->ssl) : 0;
 936 }
 937
 938
 939 int tls_connection_shutdown(void *ssl_ctx, struct tls_connection *conn)
 940 {
 941         if (conn == NULL)
 942                 return -1;
 943
 944         /* Shutdown previous TLS connection without notifying the peer
 945          * because the connection was already terminated in practice
 946          * and "close notify" shutdown alert would confuse AS. */
 947         SSL_set_quiet_shutdown(conn->ssl, 1);
 948         SSL_shutdown(conn->ssl);
 949         return 0;
 950 }
 951
 952
 953 static int tls_match_altsubject_component(X509 *cert, int type,
 954                                           const char *value, size_t len)
 955 {
 956         GENERAL_NAME *gen;
 957         void *ext;
 958         int i, found = 0;
 959
 960         ext = X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL);
 961
 962         for (i = 0; ext && i < sk_GENERAL_NAME_num(ext); i++) {
 963                 gen = sk_GENERAL_NAME_value(ext, i);
 964                 if (gen->type != type)
 965                         continue;
 966                 if (os_strlen((char *) gen->d.ia5->data) == len &&
 967                     os_memcmp(value, gen->d.ia5->data, len) == 0)
 968                         found++;
 969         }
 970
 971         return found;
 972 }
 973
 974
 975 static int tls_match_altsubject(X509 *cert, const char *match)
 976 {
 977         int type;
 978         const char *pos, *end;
 979         size_t len;
 980
 981         pos = match;
 982         do {
 983                 if (os_strncmp(pos, "EMAIL:", 6) == 0) {
 984                         type = GEN_EMAIL;
 985                         pos += 6;
 986                 } else if (os_strncmp(pos, "DNS:", 4) == 0) {
 987                         type = GEN_DNS;
 988                         pos += 4;
 989                 } else if (os_strncmp(pos, "URI:", 4) == 0) {
 990                         type = GEN_URI;
 991                         pos += 4;
 992                 } else {
 993                         wpa_printf(MSG_INFO, "TLS: Invalid altSubjectName "
 994                                    "match '%s'", pos);
 995                         return 0;
 996                 }
 997                 end = os_strchr(pos, ';');
 998                 while (end) {
 999                         if (os_strncmp(end + 1, "EMAIL:", 6) == 0 ||
1000                             os_strncmp(end + 1, "DNS:", 4) == 0 ||
1001                             os_strncmp(end + 1, "URI:", 4) == 0)
1002                                 break;
1003                         end = os_strchr(end + 1, ';');
1004                 }
1005                 if (end)
1006                         len = end - pos;
1007                 else
1008                         len = os_strlen(pos);
1009                 if (tls_match_altsubject_component(cert, type, pos, len) > 0)
1010                         return 1;
1011                 pos = end + 1;
1012         } while (end);
1013
1014         return 0;
1015 }
1016
1017
1018 static int tls_verify_cb(int preverify_ok, X509_STORE_CTX *x509_ctx)
1019 {
1020         char buf[256];
1021         X509 *err_cert;
1022         int err, depth;
1023         SSL *ssl;
1024         struct tls_connection *conn;
1025         char *match, *altmatch;
1026
1027         err_cert = X509_STORE_CTX_get_current_cert(x509_ctx);
1028         err = X509_STORE_CTX_get_error(x509_ctx);
1029         depth = X509_STORE_CTX_get_error_depth(x509_ctx);
1030         ssl = X509_STORE_CTX_get_ex_data(x509_ctx,
1031                                          SSL_get_ex_data_X509_STORE_CTX_idx());
1032         X509_NAME_oneline(X509_get_subject_name(err_cert), buf, sizeof(buf));
1033
1034         conn = SSL_get_app_data(ssl);
1035         match = conn ? conn->subject_match : NULL;
1036         altmatch = conn ? conn->altsubject_match : NULL;
1037
1038         if (!preverify_ok) {
1039                 wpa_printf(MSG_WARNING, "TLS: Certificate verification failed,"
1040                            " error %d (%s) depth %d for '%s'", err,
1041                            X509_verify_cert_error_string(err), depth, buf);
1042         } else {
1043                 wpa_printf(MSG_DEBUG, "TLS: tls_verify_cb - "
1044                            "preverify_ok=%d err=%d (%s) depth=%d buf='%s'",
1045                            preverify_ok, err,
1046                            X509_verify_cert_error_string(err), depth, buf);
1047                 if (depth == 0 && match && os_strstr(buf, match) == NULL) {
1048                         wpa_printf(MSG_WARNING, "TLS: Subject '%s' did not "
1049                                    "match with '%s'", buf, match);
1050                         preverify_ok = 0;
1051                 } else if (depth == 0 && altmatch &&
1052                            !tls_match_altsubject(err_cert, altmatch)) {
1053                         wpa_printf(MSG_WARNING, "TLS: altSubjectName match "
1054                                    "'%s' not found", altmatch);
1055                         preverify_ok = 0;
1056                 }
1057         }
1058
1059         return preverify_ok;
1060 }
1061
1062
1063 #ifndef OPENSSL_NO_STDIO
1064 static int tls_load_ca_der(void *_ssl_ctx, const char *ca_cert)
1065 {
1066         SSL_CTX *ssl_ctx = _ssl_ctx;
1067         X509_LOOKUP *lookup;
1068         int ret = 0;
1069
1070         lookup = X509_STORE_add_lookup(ssl_ctx->cert_store,
1071                                        X509_LOOKUP_file());
1072         if (lookup == NULL) {
1073                 tls_show_errors(MSG_WARNING, __func__,
1074                                 "Failed add lookup for X509 store");
1075                 return -1;
1076         }
1077
1078         if (!X509_LOOKUP_load_file(lookup, ca_cert, X509_FILETYPE_ASN1)) {
1079                 unsigned long err = ERR_peek_error();
1080                 tls_show_errors(MSG_WARNING, __func__,
1081                                 "Failed load CA in DER format");
1082                 if (ERR_GET_LIB(err) == ERR_LIB_X509 &&
1083                     ERR_GET_REASON(err) == X509_R_CERT_ALREADY_IN_HASH_TABLE) {
1084                         wpa_printf(MSG_DEBUG, "OpenSSL: %s - ignoring "
1085                                    "cert already in hash table error",
1086                                    __func__);
1087                 } else
1088                         ret = -1;
1089         }
1090
1091         return ret;
1092 }
1093 #endif /* OPENSSL_NO_STDIO */
1094
1095
1096 static int tls_connection_ca_cert(void *_ssl_ctx, struct tls_connection *conn,
1097                                   const char *ca_cert, const u8 *ca_cert_blob,
1098                                   size_t ca_cert_blob_len, const char *ca_path)
1099 {
1100         SSL_CTX *ssl_ctx = _ssl_ctx;
1101
1102         /*
1103          * Remove previously configured trusted CA certificates before adding
1104          * new ones.
1105          */
1106         X509_STORE_free(ssl_ctx->cert_store);
1107         ssl_ctx->cert_store = X509_STORE_new();
1108         if (ssl_ctx->cert_store == NULL) {
1109                 wpa_printf(MSG_DEBUG, "OpenSSL: %s - failed to allocate new "
1110                            "certificate store", __func__);
1111                 return -1;
1112         }
1113
1114         if (ca_cert_blob) {
1115                 X509 *cert = d2i_X509(NULL, (OPENSSL_d2i_TYPE) &ca_cert_blob,
1116                                       ca_cert_blob_len);
1117                 if (cert == NULL) {
1118                         tls_show_errors(MSG_WARNING, __func__,
1119                                         "Failed to parse ca_cert_blob");
1120                         return -1;
1121                 }
1122
1123                 if (!X509_STORE_add_cert(ssl_ctx->cert_store, cert)) {
1124                         unsigned long err = ERR_peek_error();
1125                         tls_show_errors(MSG_WARNING, __func__,
1126                                         "Failed to add ca_cert_blob to "
1127                                         "certificate store");
1128                         if (ERR_GET_LIB(err) == ERR_LIB_X509 &&
1129                             ERR_GET_REASON(err) ==
1130                             X509_R_CERT_ALREADY_IN_HASH_TABLE) {
1131                                 wpa_printf(MSG_DEBUG, "OpenSSL: %s - ignoring "
1132                                            "cert already in hash table error",
1133                                            __func__);
1134                         } else {
1135                                 X509_free(cert);
1136                                 return -1;
1137                         }
1138                 }
1139                 X509_free(cert);
1140                 wpa_printf(MSG_DEBUG, "OpenSSL: %s - added ca_cert_blob "
1141                            "to certificate store", __func__);
1142                 SSL_set_verify(conn->ssl, SSL_VERIFY_PEER, tls_verify_cb);
1143                 return 0;
1144         }
1145
1146 #ifdef CONFIG_NATIVE_WINDOWS
1147         if (ca_cert && tls_cryptoapi_ca_cert(ssl_ctx, conn->ssl, ca_cert) ==
1148             0) {
1149                 wpa_printf(MSG_DEBUG, "OpenSSL: Added CA certificates from "
1150                            "system certificate store");
1151                 SSL_set_verify(conn->ssl, SSL_VERIFY_PEER, tls_verify_cb);
1152                 return 0;
1153         }
1154 #endif /* CONFIG_NATIVE_WINDOWS */
1155
1156         if (ca_cert || ca_path) {
1157 #ifndef OPENSSL_NO_STDIO
1158                 if (SSL_CTX_load_verify_locations(ssl_ctx, ca_cert, ca_path) !=
1159                     1) {
1160                         tls_show_errors(MSG_WARNING, __func__,
1161                                         "Failed to load root certificates");
1162                         if (ca_cert &&
1163                             tls_load_ca_der(ssl_ctx, ca_cert) == 0) {
1164                                 wpa_printf(MSG_DEBUG, "OpenSSL: %s - loaded "
1165                                            "DER format CA certificate",
1166                                            __func__);
1167                         } else
1168                                 return -1;
1169                 } else {
1170                         wpa_printf(MSG_DEBUG, "TLS: Trusted root "
1171                                    "certificate(s) loaded");
1172                         tls_get_errors(ssl_ctx);
1173                 }
1174                 SSL_set_verify(conn->ssl, SSL_VERIFY_PEER, tls_verify_cb);
1175 #else /* OPENSSL_NO_STDIO */
1176                 wpa_printf(MSG_DEBUG, "OpenSSL: %s - OPENSSL_NO_STDIO",
1177                            __func__);
1178                 return -1;
1179 #endif /* OPENSSL_NO_STDIO */
1180         } else {
1181                 /* No ca_cert configured - do not try to verify server
1182                  * certificate */
1183                 SSL_set_verify(conn->ssl, SSL_VERIFY_NONE, NULL);
1184         }
1185
1186         return 0;
1187 }
1188
1189
1190 static int tls_global_ca_cert(SSL_CTX *ssl_ctx, const char *ca_cert)
1191 {
1192         if (ca_cert) {
1193                 if (SSL_CTX_load_verify_locations(ssl_ctx, ca_cert, NULL) != 1)
1194                 {
1195                         tls_show_errors(MSG_WARNING, __func__,
1196                                         "Failed to load root certificates");
1197                         return -1;
1198                 }
1199
1200                 wpa_printf(MSG_DEBUG, "TLS: Trusted root "
1201                            "certificate(s) loaded");
1202
1203 #ifndef OPENSSL_NO_STDIO
1204                 /* Add the same CAs to the client certificate requests */
1205                 SSL_CTX_set_client_CA_list(ssl_ctx,
1206                                            SSL_load_client_CA_file(ca_cert));
1207 #endif /* OPENSSL_NO_STDIO */
1208         }
1209
1210         return 0;
1211 }
1212
1213
1214 int tls_global_set_verify(void *ssl_ctx, int check_crl)
1215 {
1216         int flags;
1217
1218         if (check_crl) {
1219                 X509_STORE *cs = SSL_CTX_get_cert_store(ssl_ctx);
1220                 if (cs == NULL) {
1221                         tls_show_errors(MSG_INFO, __func__, "Failed to get "
1222                                         "certificate store when enabling "
1223                                         "check_crl");
1224                         return -1;
1225                 }
1226                 flags = X509_V_FLAG_CRL_CHECK;
1227                 if (check_crl == 2)
1228                         flags |= X509_V_FLAG_CRL_CHECK_ALL;
1229                 X509_STORE_set_flags(cs, flags);
1230         }
1231         return 0;
1232 }
1233
1234
1235 static int tls_connection_set_subject_match(struct tls_connection *conn,
1236                                             const char *subject_match,
1237                                             const char *altsubject_match)
1238 {
1239         os_free(conn->subject_match);
1240         conn->subject_match = NULL;
1241         if (subject_match) {
1242                 conn->subject_match = os_strdup(subject_match);
1243                 if (conn->subject_match == NULL)
1244                         return -1;
1245         }
1246
1247         os_free(conn->altsubject_match);
1248         conn->altsubject_match = NULL;
1249         if (altsubject_match) {
1250                 conn->altsubject_match = os_strdup(altsubject_match);
1251                 if (conn->altsubject_match == NULL)
1252                         return -1;
1253         }
1254
1255         return 0;
1256 }
1257
1258
1259 int tls_connection_set_verify(void *ssl_ctx, struct tls_connection *conn,
1260                               int verify_peer)
1261 {
1262         if (conn == NULL)
1263                 return -1;
1264
1265         if (verify_peer) {
1266                 SSL_set_verify(conn->ssl, SSL_VERIFY_PEER |
1267                                SSL_VERIFY_FAIL_IF_NO_PEER_CERT |
1268                                SSL_VERIFY_CLIENT_ONCE, tls_verify_cb);
1269         } else {
1270                 SSL_set_verify(conn->ssl, SSL_VERIFY_NONE, NULL);
1271         }
1272
1273         SSL_set_accept_state(conn->ssl);
1274
1275         return 0;
1276 }
1277
1278
1279 static int tls_connection_client_cert(struct tls_connection *conn,
1280                                       const char *client_cert,
1281                                       const u8 *client_cert_blob,
1282                                       size_t client_cert_blob_len)
1283 {
1284         if (client_cert == NULL && client_cert_blob == NULL)
1285                 return 0;
1286
1287         if (client_cert_blob &&
1288             SSL_use_certificate_ASN1(conn->ssl, (u8 *) client_cert_blob,
1289                                      client_cert_blob_len) == 1) {
1290                 wpa_printf(MSG_DEBUG, "OpenSSL: SSL_use_certificate_ASN1 --> "
1291                            "OK");
1292                 return 0;
1293         } else if (client_cert_blob) {
1294                 tls_show_errors(MSG_DEBUG, __func__,
1295                                 "SSL_use_certificate_ASN1 failed");
1296         }
1297
1298         if (client_cert == NULL)
1299                 return -1;
1300
1301 #ifndef OPENSSL_NO_STDIO
1302         if (SSL_use_certificate_file(conn->ssl, client_cert,
1303                                      SSL_FILETYPE_ASN1) == 1) {
1304                 wpa_printf(MSG_DEBUG, "OpenSSL: SSL_use_certificate_file (DER)"
1305                            " --> OK");
1306                 return 0;
1307         } else {
1308                 tls_show_errors(MSG_DEBUG, __func__,
1309                                 "SSL_use_certificate_file (DER) failed");
1310         }
1311
1312         if (SSL_use_certificate_file(conn->ssl, client_cert,
1313                                      SSL_FILETYPE_PEM) == 1) {
1314                 wpa_printf(MSG_DEBUG, "OpenSSL: SSL_use_certificate_file (PEM)"
1315                            " --> OK");
1316                 return 0;
1317         } else {
1318                 tls_show_errors(MSG_DEBUG, __func__,
1319                                 "SSL_use_certificate_file (PEM) failed");
1320         }
1321 #else /* OPENSSL_NO_STDIO */
1322         wpa_printf(MSG_DEBUG, "OpenSSL: %s - OPENSSL_NO_STDIO", __func__);
1323 #endif /* OPENSSL_NO_STDIO */
1324
1325         return -1;
1326 }
1327
1328
1329 static int tls_global_client_cert(SSL_CTX *ssl_ctx, const char *client_cert)
1330 {
1331 #ifndef OPENSSL_NO_STDIO
1332         if (client_cert == NULL)
1333                 return 0;
1334
1335         if (SSL_CTX_use_certificate_file(ssl_ctx, client_cert,
1336                                          SSL_FILETYPE_ASN1) != 1 &&
1337             SSL_CTX_use_certificate_file(ssl_ctx, client_cert,
1338                                          SSL_FILETYPE_PEM) != 1) {
1339                 tls_show_errors(MSG_INFO, __func__,
1340                                 "Failed to load client certificate");
1341                 return -1;
1342         }
1343         return 0;
1344 #else /* OPENSSL_NO_STDIO */
1345         if (client_cert == NULL)
1346                 return 0;
1347         wpa_printf(MSG_DEBUG, "OpenSSL: %s - OPENSSL_NO_STDIO", __func__);
1348         return -1;
1349 #endif /* OPENSSL_NO_STDIO */
1350 }
1351
1352
1353 static int tls_passwd_cb(char *buf, int size, int rwflag, void *password)
1354 {
1355         if (password == NULL) {
1356                 return 0;
1357         }
1358         os_strncpy(buf, (char *) password, size);
1359         buf[size - 1] = '\0';
1360         return os_strlen(buf);
1361 }
1362
1363
1364 #ifdef PKCS12_FUNCS
1365 static int tls_parse_pkcs12(SSL_CTX *ssl_ctx, SSL *ssl, PKCS12 *p12,
1366                             const char *passwd)
1367 {
1368         EVP_PKEY *pkey;
1369         X509 *cert;
1370         STACK_OF(X509) *certs;
1371         int res = 0;
1372         char buf[256];
1373
1374         pkey = NULL;
1375         cert = NULL;
1376         certs = NULL;
1377         if (!PKCS12_parse(p12, passwd, &pkey, &cert, &certs)) {
1378                 tls_show_errors(MSG_DEBUG, __func__,
1379                                 "Failed to parse PKCS12 file");
1380                 PKCS12_free(p12);
1381                 return -1;
1382         }
1383         wpa_printf(MSG_DEBUG, "TLS: Successfully parsed PKCS12 data");
1384
1385         if (cert) {
1386                 X509_NAME_oneline(X509_get_subject_name(cert), buf,
1387                                   sizeof(buf));
1388                 wpa_printf(MSG_DEBUG, "TLS: Got certificate from PKCS12: "
1389                            "subject='%s'", buf);
1390                 if (ssl) {
1391                         if (SSL_use_certificate(ssl, cert) != 1)
1392                                 res = -1;
1393                 } else {
1394                         if (SSL_CTX_use_certificate(ssl_ctx, cert) != 1)
1395                                 res = -1;
1396                 }
1397                 X509_free(cert);
1398         }
1399
1400         if (pkey) {
1401                 wpa_printf(MSG_DEBUG, "TLS: Got private key from PKCS12");
1402                 if (ssl) {
1403                         if (SSL_use_PrivateKey(ssl, pkey) != 1)
1404                                 res = -1;
1405                 } else {
1406                         if (SSL_CTX_use_PrivateKey(ssl_ctx, pkey) != 1)
1407                                 res = -1;
1408                 }
1409                 EVP_PKEY_free(pkey);
1410         }
1411
1412         if (certs) {
1413                 while ((cert = sk_X509_pop(certs)) != NULL) {
1414                         X509_NAME_oneline(X509_get_subject_name(cert), buf,
1415                                           sizeof(buf));
1416                         wpa_printf(MSG_DEBUG, "TLS: additional certificate"
1417                                    " from PKCS12: subject='%s'", buf);
1418                         /*
1419                          * There is no SSL equivalent for the chain cert - so
1420                          * always add it to the context...
1421                          */
1422                         if (SSL_CTX_add_extra_chain_cert(ssl_ctx, cert) != 1) {
1423                                 res = -1;
1424                                 break;
1425                         }
1426                 }
1427                 sk_X509_free(certs);
1428         }
1429
1430         PKCS12_free(p12);
1431
1432         if (res < 0)
1433                 tls_get_errors(ssl_ctx);
1434
1435         return res;
1436 }
1437 #endif  /* PKCS12_FUNCS */
1438
1439
1440 static int tls_read_pkcs12(SSL_CTX *ssl_ctx, SSL *ssl, const char *private_key,
1441                            const char *passwd)
1442 {
1443 #ifdef PKCS12_FUNCS
1444         FILE *f;
1445         PKCS12 *p12;
1446
1447         f = fopen(private_key, "rb");
1448         if (f == NULL)
1449                 return -1;
1450
1451         p12 = d2i_PKCS12_fp(f, NULL);
1452         fclose(f);
1453
1454         if (p12 == NULL) {
1455                 tls_show_errors(MSG_INFO, __func__,
1456                                 "Failed to use PKCS#12 file");
1457                 return -1;
1458         }
1459
1460         return tls_parse_pkcs12(ssl_ctx, ssl, p12, passwd);
1461
1462 #else /* PKCS12_FUNCS */
1463         wpa_printf(MSG_INFO, "TLS: PKCS12 support disabled - cannot read "
1464                    "p12/pfx files");
1465         return -1;
1466 #endif  /* PKCS12_FUNCS */
1467 }
1468
1469
1470 static int tls_read_pkcs12_blob(SSL_CTX *ssl_ctx, SSL *ssl,
1471                                 const u8 *blob, size_t len, const char *passwd)
1472 {
1473 #ifdef PKCS12_FUNCS
1474         PKCS12 *p12;
1475
1476         p12 = d2i_PKCS12(NULL, (OPENSSL_d2i_TYPE) &blob, len);
1477         if (p12 == NULL) {
1478                 tls_show_errors(MSG_INFO, __func__,
1479                                 "Failed to use PKCS#12 blob");
1480                 return -1;
1481         }
1482
1483         return tls_parse_pkcs12(ssl_ctx, ssl, p12, passwd);
1484
1485 #else /* PKCS12_FUNCS */
1486         wpa_printf(MSG_INFO, "TLS: PKCS12 support disabled - cannot parse "
1487                    "p12/pfx blobs");
1488         return -1;
1489 #endif  /* PKCS12_FUNCS */
1490 }
1491
1492
1493 static int tls_connection_engine_private_key(struct tls_connection *conn)
1494 {
1495 #ifndef OPENSSL_NO_ENGINE
1496         if (SSL_use_PrivateKey(conn->ssl, conn->private_key) != 1) {
1497                 tls_show_errors(MSG_ERROR, __func__,
1498                                 "ENGINE: cannot use private key for TLS");
1499                 return -1;
1500         }
1501         if (!SSL_check_private_key(conn->ssl)) {
1502                 tls_show_errors(MSG_INFO, __func__,
1503                                 "Private key failed verification");
1504                 return -1;
1505         }
1506         return 0;
1507 #else /* OPENSSL_NO_ENGINE */
1508         wpa_printf(MSG_ERROR, "SSL: Configuration uses engine, but "
1509                    "engine support was not compiled in");
1510         return -1;
1511 #endif /* OPENSSL_NO_ENGINE */
1512 }
1513
1514
1515 static int tls_connection_private_key(void *_ssl_ctx,
1516                                       struct tls_connection *conn,
1517                                       const char *private_key,
1518                                       const char *private_key_passwd,
1519                                       const u8 *private_key_blob,
1520                                       size_t private_key_blob_len)
1521 {
1522         SSL_CTX *ssl_ctx = _ssl_ctx;
1523         char *passwd;
1524         int ok;
1525
1526         if (private_key == NULL && private_key_blob == NULL)
1527                 return 0;
1528
1529         if (private_key_passwd) {
1530                 passwd = os_strdup(private_key_passwd);
1531                 if (passwd == NULL)
1532                         return -1;
1533         } else
1534                 passwd = NULL;
1535
1536         SSL_CTX_set_default_passwd_cb(ssl_ctx, tls_passwd_cb);
1537         SSL_CTX_set_default_passwd_cb_userdata(ssl_ctx, passwd);
1538
1539         ok = 0;
1540         while (private_key_blob) {
1541                 if (SSL_use_PrivateKey_ASN1(EVP_PKEY_RSA, conn->ssl,
1542                                             (u8 *) private_key_blob,
1543                                             private_key_blob_len) == 1) {
1544                         wpa_printf(MSG_DEBUG, "OpenSSL: SSL_use_PrivateKey_"
1545                                    "ASN1(EVP_PKEY_RSA) --> OK");
1546                         ok = 1;
1547                         break;
1548                 } else {
1549                         tls_show_errors(MSG_DEBUG, __func__,
1550                                         "SSL_use_PrivateKey_ASN1(EVP_PKEY_RSA)"
1551                                         " failed");
1552                 }
1553
1554                 if (SSL_use_PrivateKey_ASN1(EVP_PKEY_DSA, conn->ssl,
1555                                             (u8 *) private_key_blob,
1556                                             private_key_blob_len) == 1) {
1557                         wpa_printf(MSG_DEBUG, "OpenSSL: SSL_use_PrivateKey_"
1558                                    "ASN1(EVP_PKEY_DSA) --> OK");
1559                         ok = 1;
1560                         break;
1561                 } else {
1562                         tls_show_errors(MSG_DEBUG, __func__,
1563                                         "SSL_use_PrivateKey_ASN1(EVP_PKEY_DSA)"
1564                                         " failed");
1565                 }
1566
1567                 if (SSL_use_RSAPrivateKey_ASN1(conn->ssl,
1568                                                (u8 *) private_key_blob,
1569                                                private_key_blob_len) == 1) {
1570                         wpa_printf(MSG_DEBUG, "OpenSSL: "
1571                                    "SSL_use_RSAPrivateKey_ASN1 --> OK");
1572                         ok = 1;
1573                         break;
1574                 } else {
1575                         tls_show_errors(MSG_DEBUG, __func__,
1576                                         "SSL_use_RSAPrivateKey_ASN1 failed");
1577                 }
1578
1579                 if (tls_read_pkcs12_blob(ssl_ctx, conn->ssl, private_key_blob,
1580                                          private_key_blob_len, passwd) == 0) {
1581                         wpa_printf(MSG_DEBUG, "OpenSSL: PKCS#12 as blob --> "
1582                                    "OK");
1583                         ok = 1;
1584                         break;
1585                 }
1586
1587                 break;
1588         }
1589
1590         while (!ok && private_key) {
1591 #ifndef OPENSSL_NO_STDIO
1592                 if (SSL_use_PrivateKey_file(conn->ssl, private_key,
1593                                             SSL_FILETYPE_ASN1) == 1) {
1594                         wpa_printf(MSG_DEBUG, "OpenSSL: "
1595                                    "SSL_use_PrivateKey_File (DER) --> OK");
1596                         ok = 1;
1597                         break;
1598                 } else {
1599                         tls_show_errors(MSG_DEBUG, __func__,
1600                                         "SSL_use_PrivateKey_File (DER) "
1601                                         "failed");
1602                 }
1603
1604                 if (SSL_use_PrivateKey_file(conn->ssl, private_key,
1605                                             SSL_FILETYPE_PEM) == 1) {
1606                         wpa_printf(MSG_DEBUG, "OpenSSL: "
1607                                    "SSL_use_PrivateKey_File (PEM) --> OK");
1608                         ok = 1;
1609                         break;
1610                 } else {
1611                         tls_show_errors(MSG_DEBUG, __func__,
1612                                         "SSL_use_PrivateKey_File (PEM) "
1613                                         "failed");
1614                 }
1615 #else /* OPENSSL_NO_STDIO */
1616                 wpa_printf(MSG_DEBUG, "OpenSSL: %s - OPENSSL_NO_STDIO",
1617                            __func__);
1618 #endif /* OPENSSL_NO_STDIO */
1619
1620                 if (tls_read_pkcs12(ssl_ctx, conn->ssl, private_key, passwd)
1621                     == 0) {
1622                         wpa_printf(MSG_DEBUG, "OpenSSL: Reading PKCS#12 file "
1623                                    "--> OK");
1624                         ok = 1;
1625                         break;
1626                 }
1627
1628                 if (tls_cryptoapi_cert(conn->ssl, private_key) == 0) {
1629                         wpa_printf(MSG_DEBUG, "OpenSSL: Using CryptoAPI to "
1630                                    "access certificate store --> OK");
1631                         ok = 1;
1632                         break;
1633                 }
1634
1635                 break;
1636         }
1637
1638         if (!ok) {
1639                 wpa_printf(MSG_INFO, "OpenSSL: Failed to load private key");
1640                 os_free(passwd);
1641                 ERR_clear_error();
1642                 return -1;
1643         }
1644         ERR_clear_error();
1645         SSL_CTX_set_default_passwd_cb(ssl_ctx, NULL);
1646         os_free(passwd);
1647
1648         if (!SSL_check_private_key(conn->ssl)) {
1649                 tls_show_errors(MSG_INFO, __func__, "Private key failed "
1650                                 "verification");
1651                 return -1;
1652         }
1653
1654         wpa_printf(MSG_DEBUG, "SSL: Private key loaded successfully");
1655         return 0;
1656 }
1657
1658
1659 static int tls_global_private_key(SSL_CTX *ssl_ctx, const char *private_key,
1660                                   const char *private_key_passwd)
1661 {
1662         char *passwd;
1663
1664         if (private_key == NULL)
1665                 return 0;
1666
1667         if (private_key_passwd) {
1668                 passwd = os_strdup(private_key_passwd);
1669                 if (passwd == NULL)
1670                         return -1;
1671         } else
1672                 passwd = NULL;
1673
1674         SSL_CTX_set_default_passwd_cb(ssl_ctx, tls_passwd_cb);
1675         SSL_CTX_set_default_passwd_cb_userdata(ssl_ctx, passwd);
1676         if (
1677 #ifndef OPENSSL_NO_STDIO
1678             SSL_CTX_use_PrivateKey_file(ssl_ctx, private_key,
1679                                         SSL_FILETYPE_ASN1) != 1 &&
1680             SSL_CTX_use_PrivateKey_file(ssl_ctx, private_key,
1681                                         SSL_FILETYPE_PEM) != 1 &&
1682 #endif /* OPENSSL_NO_STDIO */
1683             tls_read_pkcs12(ssl_ctx, NULL, private_key, passwd)) {
1684                 tls_show_errors(MSG_INFO, __func__,
1685                                 "Failed to load private key");
1686                 os_free(passwd);
1687                 ERR_clear_error();
1688                 return -1;
1689         }
1690         os_free(passwd);
1691         ERR_clear_error();
1692         SSL_CTX_set_default_passwd_cb(ssl_ctx, NULL);
1693
1694         if (!SSL_CTX_check_private_key(ssl_ctx)) {
1695                 tls_show_errors(MSG_INFO, __func__,
1696                                 "Private key failed verification");
1697                 return -1;
1698         }
1699
1700         return 0;
1701 }
1702
1703
1704 static int tls_connection_dh(struct tls_connection *conn, const char *dh_file)
1705 {
1706 #ifdef OPENSSL_NO_DH
1707         if (dh_file == NULL)
1708                 return 0;
1709         wpa_printf(MSG_ERROR, "TLS: openssl does not include DH support, but "
1710                    "dh_file specified");
1711         return -1;
1712 #else /* OPENSSL_NO_DH */
1713         DH *dh;
1714         BIO *bio;
1715
1716         /* TODO: add support for dh_blob */
1717         if (dh_file == NULL)
1718                 return 0;
1719         if (conn == NULL)
1720                 return -1;
1721
1722         bio = BIO_new_file(dh_file, "r");
1723         if (bio == NULL) {
1724                 wpa_printf(MSG_INFO, "TLS: Failed to open DH file '%s': %s",
1725                            dh_file, ERR_error_string(ERR_get_error(), NULL));
1726                 return -1;
1727         }
1728         dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
1729         BIO_free(bio);
1730 #ifndef OPENSSL_NO_DSA
1731         while (dh == NULL) {
1732                 DSA *dsa;
1733                 wpa_printf(MSG_DEBUG, "TLS: Failed to parse DH file '%s': %s -"
1734                            " trying to parse as DSA params", dh_file,
1735                            ERR_error_string(ERR_get_error(), NULL));
1736                 bio = BIO_new_file(dh_file, "r");
1737                 if (bio == NULL)
1738                         break;
1739                 dsa = PEM_read_bio_DSAparams(bio, NULL, NULL, NULL);
1740                 BIO_free(bio);
1741                 if (!dsa) {
1742                         wpa_printf(MSG_DEBUG, "TLS: Failed to parse DSA file "
1743                                    "'%s': %s", dh_file,
1744                                    ERR_error_string(ERR_get_error(), NULL));
1745                         break;
1746                 }
1747
1748                 wpa_printf(MSG_DEBUG, "TLS: DH file in DSA param format");
1749                 dh = DSA_dup_DH(dsa);
1750                 DSA_free(dsa);
1751                 if (dh == NULL) {
1752                         wpa_printf(MSG_INFO, "TLS: Failed to convert DSA "
1753                                    "params into DH params");
1754                         break;
1755                 }
1756                 break;
1757         }
1758 #endif /* !OPENSSL_NO_DSA */
1759         if (dh == NULL) {
1760                 wpa_printf(MSG_INFO, "TLS: Failed to read/parse DH/DSA file "
1761                            "'%s'", dh_file);
1762                 return -1;
1763         }
1764
1765         if (SSL_set_tmp_dh(conn->ssl, dh) != 1) {
1766                 wpa_printf(MSG_INFO, "TLS: Failed to set DH params from '%s': "
1767                            "%s", dh_file,
1768                            ERR_error_string(ERR_get_error(), NULL));
1769                 DH_free(dh);
1770                 return -1;
1771         }
1772         DH_free(dh);
1773         return 0;
1774 #endif /* OPENSSL_NO_DH */
1775 }
1776
1777
1778 int tls_connection_get_keys(void *ssl_ctx, struct tls_connection *conn,
1779                             struct tls_keys *keys)
1780 {
1781         SSL *ssl;
1782
1783         if (conn == NULL || keys == NULL)
1784                 return -1;
1785         ssl = conn->ssl;
1786         if (ssl == NULL || ssl->s3 == NULL || ssl->session == NULL)
1787                 return -1;
1788
1789         os_memset(keys, 0, sizeof(*keys));
1790         keys->master_key = ssl->session->master_key;
1791         keys->master_key_len = ssl->session->master_key_length;
1792         keys->client_random = ssl->s3->client_random;
1793         keys->client_random_len = SSL3_RANDOM_SIZE;
1794         keys->server_random = ssl->s3->server_random;
1795         keys->server_random_len = SSL3_RANDOM_SIZE;
1796
1797         return 0;
1798 }
1799
1800
1801 int tls_connection_prf(void *tls_ctx, struct tls_connection *conn,
1802                        const char *label, int server_random_first,
1803                        u8 *out, size_t out_len)
1804 {
1805         return -1;
1806 }
1807
1808
1809 u8 * tls_connection_handshake(void *ssl_ctx, struct tls_connection *conn,
1810                               const u8 *in_data, size_t in_len,
1811                               size_t *out_len, u8 **appl_data,
1812                               size_t *appl_data_len)
1813 {
1814         int res;
1815         u8 *out_data;
1816
1817         if (appl_data)
1818                 *appl_data = NULL;
1819
1820         /*
1821          * Give TLS handshake data from the server (if available) to OpenSSL
1822          * for processing.
1823          */
1824         if (in_data &&
1825             BIO_write(conn->ssl_in, in_data, in_len) < 0) {
1826                 tls_show_errors(MSG_INFO, __func__,
1827                                 "Handshake failed - BIO_write");
1828                 return NULL;
1829         }
1830
1831         /* Initiate TLS handshake or continue the existing handshake */
1832         res = SSL_connect(conn->ssl);
1833         if (res != 1) {
1834                 int err = SSL_get_error(conn->ssl, res);
1835                 if (err == SSL_ERROR_WANT_READ)
1836                         wpa_printf(MSG_DEBUG, "SSL: SSL_connect - want "
1837                                    "more data");
1838                 else if (err == SSL_ERROR_WANT_WRITE)
1839                         wpa_printf(MSG_DEBUG, "SSL: SSL_connect - want to "
1840                                    "write");
1841                 else {
1842                         tls_show_errors(MSG_INFO, __func__, "SSL_connect");
1843                         conn->failed++;
1844                 }
1845         }
1846
1847         /* Get the TLS handshake data to be sent to the server */
1848         res = BIO_ctrl_pending(conn->ssl_out);
1849         wpa_printf(MSG_DEBUG, "SSL: %d bytes pending from ssl_out", res);
1850         out_data = os_malloc(res == 0 ? 1 : res);
1851         if (out_data == NULL) {
1852                 wpa_printf(MSG_DEBUG, "SSL: Failed to allocate memory for "
1853                            "handshake output (%d bytes)", res);
1854                 if (BIO_reset(conn->ssl_out) < 0) {
1855                         tls_show_errors(MSG_INFO, __func__,
1856                                         "BIO_reset failed");
1857                 }
1858                 *out_len = 0;
1859                 return NULL;
1860         }
1861         res = res == 0 ? 0 : BIO_read(conn->ssl_out, out_data, res);
1862         if (res < 0) {
1863                 tls_show_errors(MSG_INFO, __func__,
1864                                 "Handshake failed - BIO_read");
1865                 if (BIO_reset(conn->ssl_out) < 0) {
1866                         tls_show_errors(MSG_INFO, __func__,
1867                                         "BIO_reset failed");
1868                 }
1869                 *out_len = 0;
1870                 return NULL;
1871         }
1872         *out_len = res;
1873
1874         if (SSL_is_init_finished(conn->ssl) && appl_data) {
1875                 *appl_data = os_malloc(in_len);
1876                 if (*appl_data) {
1877                         res = SSL_read(conn->ssl, *appl_data, in_len);
1878                         if (res < 0) {
1879                                 tls_show_errors(MSG_INFO, __func__,
1880                                                 "Failed to read possible "
1881                                                 "Application Data");
1882                                 os_free(*appl_data);
1883                                 *appl_data = NULL;
1884                         } else {
1885                                 *appl_data_len = res;
1886                                 wpa_hexdump_key(MSG_MSGDUMP, "SSL: Application"
1887                                                 " Data in Finish message",
1888                                                 *appl_data, *appl_data_len);
1889                         }
1890                 }
1891         }
1892
1893         return out_data;
1894 }
1895
1896
1897 u8 * tls_connection_server_handshake(void *ssl_ctx,
1898                                      struct tls_connection *conn,
1899                                      const u8 *in_data, size_t in_len,
1900                                      size_t *out_len)
1901 {
1902         int res;
1903         u8 *out_data;
1904         char buf[10];
1905
1906         if (in_data &&
1907             BIO_write(conn->ssl_in, in_data, in_len) < 0) {
1908                 tls_show_errors(MSG_INFO, __func__,
1909                                 "Handshake failed - BIO_write");
1910                 return NULL;
1911         }
1912
1913         res = SSL_read(conn->ssl, buf, sizeof(buf));
1914         if (res >= 0) {
1915                 wpa_printf(MSG_DEBUG, "SSL: Unexpected data from SSL_read "
1916                            "(res=%d)", res);
1917         }
1918
1919         res = BIO_ctrl_pending(conn->ssl_out);
1920         wpa_printf(MSG_DEBUG, "SSL: %d bytes pending from ssl_out", res);
1921         out_data = os_malloc(res == 0 ? 1 : res);
1922         if (out_data == NULL) {
1923                 wpa_printf(MSG_DEBUG, "SSL: Failed to allocate memory for "
1924                            "handshake output (%d bytes)", res);
1925                 if (BIO_reset(conn->ssl_out) < 0) {
1926                         tls_show_errors(MSG_INFO, __func__,
1927                                         "BIO_reset failed");
1928                 }
1929                 *out_len = 0;
1930                 return NULL;
1931         }
1932         res = res == 0 ? 0 : BIO_read(conn->ssl_out, out_data, res);
1933         if (res < 0) {
1934                 tls_show_errors(MSG_INFO, __func__,
1935                                 "Handshake failed - BIO_read");
1936                 if (BIO_reset(conn->ssl_out) < 0) {
1937                         tls_show_errors(MSG_INFO, __func__,
1938                                         "BIO_reset failed");
1939                 }
1940                 *out_len = 0;
1941                 return NULL;
1942         }
1943         *out_len = res;
1944         return out_data;
1945 }
1946
1947
1948 int tls_connection_encrypt(void *ssl_ctx, struct tls_connection *conn,
1949                            const u8 *in_data, size_t in_len,
1950                            u8 *out_data, size_t out_len)
1951 {
1952         int res;
1953
1954         if (conn == NULL)
1955                 return -1;
1956
1957         /* Give plaintext data for OpenSSL to encrypt into the TLS tunnel. */
1958         if ((res = BIO_reset(conn->ssl_in)) < 0 ||
1959             (res = BIO_reset(conn->ssl_out)) < 0) {
1960                 tls_show_errors(MSG_INFO, __func__, "BIO_reset failed");
1961                 return res;
1962         }
1963         res = SSL_write(conn->ssl, in_data, in_len);
1964         if (res < 0) {
1965                 tls_show_errors(MSG_INFO, __func__,
1966                                 "Encryption failed - SSL_write");
1967                 return res;
1968         }
1969
1970         /* Read encrypted data to be sent to the server */
1971         res = BIO_read(conn->ssl_out, out_data, out_len);
1972         if (res < 0) {
1973                 tls_show_errors(MSG_INFO, __func__,
1974                                 "Encryption failed - BIO_read");
1975                 return res;
1976         }
1977
1978         return res;
1979 }
1980
1981
1982 int tls_connection_decrypt(void *ssl_ctx, struct tls_connection *conn,
1983                            const u8 *in_data, size_t in_len,
1984                            u8 *out_data, size_t out_len)
1985 {
1986         int res;
1987
1988         /* Give encrypted data from TLS tunnel for OpenSSL to decrypt. */
1989         res = BIO_write(conn->ssl_in, in_data, in_len);
1990         if (res < 0) {
1991                 tls_show_errors(MSG_INFO, __func__,
1992                                 "Decryption failed - BIO_write");
1993                 return res;
1994         }
1995         if (BIO_reset(conn->ssl_out) < 0) {
1996                 tls_show_errors(MSG_INFO, __func__, "BIO_reset failed");
1997                 return res;
1998         }
1999
2000         /* Read decrypted data for further processing */
2001         res = SSL_read(conn->ssl, out_data, out_len);
2002         if (res < 0) {
2003                 tls_show_errors(MSG_INFO, __func__,
2004                                 "Decryption failed - SSL_read");
2005                 return res;
2006         }
2007
2008         return res;
2009 }
2010
2011
2012 int tls_connection_resumed(void *ssl_ctx, struct tls_connection *conn)
2013 {
2014         return conn ? conn->ssl->hit : 0;
2015 }
2016
2017
2018 #if defined(EAP_FAST) || defined(EAP_FAST_DYNAMIC)
2019 /* Pre-shared secred requires a patch to openssl, so this function is
2020  * commented out unless explicitly needed for EAP-FAST in order to be able to
2021  * build this file with unmodified openssl. */
2022
2023 static int tls_sess_sec_cb(SSL *s, void *secret, int *secret_len,
2024                            STACK_OF(SSL_CIPHER) *peer_ciphers,
2025                            SSL_CIPHER **cipher, void *arg)
2026 {
2027         struct tls_connection *conn = arg;
2028
2029         if (conn == NULL || conn->pre_shared_secret == 0)
2030                 return 0;
2031
2032         os_memcpy(secret, conn->pre_shared_secret,
2033                   conn->pre_shared_secret_len);
2034         *secret_len = conn->pre_shared_secret_len;
2035
2036         return 1;
2037 }
2038
2039
2040 int tls_connection_set_master_key(void *ssl_ctx, struct tls_connection *conn,
2041                                   const u8 *key, size_t key_len)
2042 {
2043         if (conn == NULL || key_len > SSL_MAX_MASTER_KEY_LENGTH)
2044                 return -1;
2045
2046         os_free(conn->pre_shared_secret);
2047         conn->pre_shared_secret = NULL;
2048         conn->pre_shared_secret_len = 0;
2049
2050         if (key) {
2051                 conn->pre_shared_secret = os_malloc(key_len);
2052                 if (conn->pre_shared_secret) {
2053                         os_memcpy(conn->pre_shared_secret, key, key_len);
2054                         conn->pre_shared_secret_len = key_len;
2055                 }
2056                 if (SSL_set_session_secret_cb(conn->ssl, tls_sess_sec_cb,
2057                                               conn) != 1)
2058                         return -1;
2059         } else {
2060                 if (SSL_set_session_secret_cb(conn->ssl, NULL, NULL) != 1)
2061                         return -1;
2062         }
2063
2064         return 0;
2065 }
2066 #endif /* EAP_FAST || EAP_FAST_DYNAMIC */
2067
2068
2069 int tls_connection_set_cipher_list(void *tls_ctx, struct tls_connection *conn,
2070                                    u8 *ciphers)
2071 {
2072         char buf[100], *pos, *end;
2073         u8 *c;
2074         int ret;
2075
2076         if (conn == NULL || conn->ssl == NULL || ciphers == NULL)
2077                 return -1;
2078
2079         buf[0] = '\0';
2080         pos = buf;
2081         end = pos + sizeof(buf);
2082
2083         c = ciphers;
2084         while (*c != TLS_CIPHER_NONE) {
2085                 const char *suite;
2086
2087                 switch (*c) {
2088                 case TLS_CIPHER_RC4_SHA:
2089                         suite = "RC4-SHA";
2090                         break;
2091                 case TLS_CIPHER_AES128_SHA:
2092                         suite = "AES128-SHA";
2093                         break;
2094                 case TLS_CIPHER_RSA_DHE_AES128_SHA:
2095                         suite = "DHE-RSA-AES128-SHA";
2096                         break;
2097                 case TLS_CIPHER_ANON_DH_AES128_SHA:
2098                         suite = "ADH-AES128-SHA";
2099                         break;
2100                 default:
2101                         wpa_printf(MSG_DEBUG, "TLS: Unsupported "
2102                                    "cipher selection: %d", *c);
2103                         return -1;
2104                 }
2105                 ret = os_snprintf(pos, end - pos, ":%s", suite);
2106                 if (ret < 0 || ret >= end - pos)
2107                         break;
2108                 pos += ret;
2109
2110                 c++;
2111         }
2112
2113         wpa_printf(MSG_DEBUG, "OpenSSL: cipher suites: %s", buf + 1);
2114
2115         if (SSL_set_cipher_list(conn->ssl, buf + 1) != 1) {
2116                 tls_show_errors(MSG_INFO, __func__,
2117                                 "Cipher suite configuration failed");
2118                 return -1;
2119         }
2120
2121         return 0;
2122 }
2123
2124
2125 int tls_get_cipher(void *ssl_ctx, struct tls_connection *conn,
2126                    char *buf, size_t buflen)
2127 {
2128         const char *name;
2129         if (conn == NULL || conn->ssl == NULL)
2130                 return -1;
2131
2132         name = SSL_get_cipher(conn->ssl);
2133         if (name == NULL)
2134                 return -1;
2135
2136         os_snprintf(buf, buflen, "%s", name);
2137         buf[buflen - 1] = '\0';
2138         return 0;
2139 }
2140
2141
2142 int tls_connection_enable_workaround(void *ssl_ctx,
2143                                      struct tls_connection *conn)
2144 {
2145         SSL_set_options(conn->ssl, SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS);
2146
2147         return 0;
2148 }
2149
2150
2151 #if defined(EAP_FAST) || defined(EAP_FAST_DYNAMIC)
2152 /* ClientHello TLS extensions require a patch to openssl, so this function is
2153  * commented out unless explicitly needed for EAP-FAST in order to be able to
2154  * build this file with unmodified openssl. */
2155 int tls_connection_client_hello_ext(void *ssl_ctx, struct tls_connection *conn,
2156                                     int ext_type, const u8 *data,
2157                                     size_t data_len)
2158 {
2159         if (conn == NULL || conn->ssl == NULL)
2160                 return -1;
2161
2162         if (SSL_set_hello_extension(conn->ssl, ext_type, (void *) data,
2163                                     data_len) != 1)
2164                 return -1;
2165
2166         return 0;
2167 }
2168 #endif /* EAP_FAST || EAP_FAST_DYNAMIC */
2169
2170
2171 int tls_connection_get_failed(void *ssl_ctx, struct tls_connection *conn)
2172 {
2173         if (conn == NULL)
2174                 return -1;
2175         return conn->failed;
2176 }
2177
2178
2179 int tls_connection_get_read_alerts(void *ssl_ctx, struct tls_connection *conn)
2180 {
2181         if (conn == NULL)
2182                 return -1;
2183         return conn->read_alerts;
2184 }
2185
2186
2187 int tls_connection_get_write_alerts(void *ssl_ctx, struct tls_connection *conn)
2188 {
2189         if (conn == NULL)
2190                 return -1;
2191         return conn->write_alerts;
2192 }
2193
2194
2195 int tls_connection_set_params(void *tls_ctx, struct tls_connection *conn,
2196                               const struct tls_connection_params *params)
2197 {
2198         int ret;
2199         unsigned long err;
2200
2201         if (conn == NULL)
2202                 return -1;
2203
2204         while ((err = ERR_get_error())) {
2205                 wpa_printf(MSG_INFO, "%s: Clearing pending SSL error: %s",
2206                            __func__, ERR_error_string(err, NULL));
2207         }
2208
2209         if (tls_connection_set_subject_match(conn,
2210                                              params->subject_match,
2211                                              params->altsubject_match))
2212                 return -1;
2213         if (tls_connection_ca_cert(tls_ctx, conn, params->ca_cert,
2214                                    params->ca_cert_blob,
2215                                    params->ca_cert_blob_len,
2216                                    params->ca_path))
2217                 return -1;
2218         if (tls_connection_client_cert(conn, params->client_cert,
2219                                        params->client_cert_blob,
2220                                        params->client_cert_blob_len))
2221                 return -1;
2222
2223         if (params->engine) {
2224                 wpa_printf(MSG_DEBUG, "SSL: Initializing TLS engine");
2225                 ret = tls_engine_init(conn, params->engine_id, params->pin,
2226                                       params->key_id);
2227                 if (ret)
2228                         return ret;
2229                 if (tls_connection_engine_private_key(conn))
2230                         return TLS_SET_PARAMS_ENGINE_PRV_VERIFY_FAILED;
2231         } else if (tls_connection_private_key(tls_ctx, conn,
2232                                               params->private_key,
2233                                               params->private_key_passwd,
2234                                               params->private_key_blob,
2235                                               params->private_key_blob_len)) {
2236                 wpa_printf(MSG_INFO, "TLS: Failed to load private key '%s'",
2237                            params->private_key);
2238                 return -1;
2239         }
2240
2241         if (tls_connection_dh(conn, params->dh_file)) {
2242                 wpa_printf(MSG_INFO, "TLS: Failed to load DH file '%s'",
2243                            params->dh_file);
2244                 return -1;
2245         }
2246
2247         tls_get_errors(tls_ctx);
2248
2249         return 0;
2250 }
2251
2252
2253 int tls_global_set_params(void *tls_ctx,
2254                           const struct tls_connection_params *params)
2255 {
2256         SSL_CTX *ssl_ctx = tls_ctx;
2257         unsigned long err;
2258
2259         while ((err = ERR_get_error())) {
2260                 wpa_printf(MSG_INFO, "%s: Clearing pending SSL error: %s",
2261                            __func__, ERR_error_string(err, NULL));
2262         }
2263
2264         if (tls_global_ca_cert(ssl_ctx, params->ca_cert))
2265                 return -1;
2266
2267         if (tls_global_client_cert(ssl_ctx, params->client_cert))
2268                 return -1;
2269
2270         if (tls_global_private_key(ssl_ctx, params->private_key,
2271                                    params->private_key_passwd))
2272                 return -1;
2273
2274         return 0;
2275 }
2276
2277
2278 int tls_connection_get_keyblock_size(void *tls_ctx,
2279                                      struct tls_connection *conn)
2280 {
2281         const EVP_CIPHER *c;
2282         const EVP_MD *h;
2283
2284         if (conn == NULL || conn->ssl == NULL ||
2285             conn->ssl->enc_read_ctx == NULL ||
2286             conn->ssl->enc_read_ctx->cipher == NULL ||
2287             conn->ssl->read_hash == NULL)
2288                 return -1;
2289
2290         c = conn->ssl->enc_read_ctx->cipher;
2291 #if OPENSSL_VERSION_NUMBER >= 0x00909000L
2292         h = EVP_MD_CTX_md(conn->ssl->read_hash);
2293 #else
2294         h = conn->ssl->read_hash;
2295 #endif
2296
2297         return 2 * (EVP_CIPHER_key_length(c) +
2298                     EVP_MD_size(h) +
2299                     EVP_CIPHER_iv_length(c));
2300 }
2301
2302
2303 unsigned int tls_capabilities(void *tls_ctx)
2304 {
2305         return 0;
2306 }
2307
2308
2309 int tls_connection_set_ia(void *tls_ctx, struct tls_connection *conn,
2310                           int tls_ia)
2311 {
2312         return -1;
2313 }
2314
2315
2316 int tls_connection_ia_send_phase_finished(void *tls_ctx,
2317                                           struct tls_connection *conn,
2318                                           int final,
2319                                           u8 *out_data, size_t out_len)
2320 {
2321         return -1;
2322 }
2323
2324
2325 int tls_connection_ia_final_phase_finished(void *tls_ctx,
2326                                            struct tls_connection *conn)
2327 {
2328         return -1;
2329 }
2330
2331
2332 int tls_connection_ia_permute_inner_secret(void *tls_ctx,
2333                                            struct tls_connection *conn,
2334                                            const u8 *key, size_t key_len)
2335 {
2336         return -1;
2337 }