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