]> git.ipfire.org Git - thirdparty/hostap.git/blame - src/crypto/tls_openssl.c
projects / thirdparty / hostap.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
OpenSSL: Always accept pinned certificates
[thirdparty/hostap.git] / src / crypto / tls_openssl.c
CommitLineData
6fc6879b 1/*
81c85c06 2 * SSL/TLS interface functions for OpenSSL
080585c0 3 * Copyright (c) 2004-2013, Jouni Malinen <j@w1.fi>
6fc6879b 4 *
0f3d578e
JM		 5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
6fc6879b
JM		 7 */
8
9#include "includes.h"
10
11#ifndef CONFIG_SMARTCARD
12#ifndef OPENSSL_NO_ENGINE
1176ab6d 13#ifndef ANDROID
6fc6879b
JM		 14#define OPENSSL_NO_ENGINE
15#endif
16#endif
1176ab6d 17#endif
6fc6879b
JM		 18
19#include <openssl/ssl.h>
20#include <openssl/err.h>
21#include <openssl/pkcs12.h>
22#include <openssl/x509v3.h>
23#ifndef OPENSSL_NO_ENGINE
24#include <openssl/engine.h>
25#endif /* OPENSSL_NO_ENGINE */
26
27#include "common.h"
00468b46 28#include "crypto.h"
6fc6879b
JM		 29#include "tls.h"
30
7c0e1e27
PS		 31#if defined(SSL_CTX_get_app_data) && defined(SSL_CTX_set_app_data)
32#define OPENSSL_SUPPORTS_CTX_APP_DATA
33#endif
34
a8572960
AL		 35#if OPENSSL_VERSION_NUMBER < 0x10000000L
36/* ERR_remove_thread_state replaces ERR_remove_state and the latter is
37 * deprecated. However, OpenSSL 0.9.8 doesn't include
38 * ERR_remove_thread_state. */
39#define ERR_remove_thread_state(tid) ERR_remove_state(0)
40#endif
41
a8572960
AL		 42#if defined(OPENSSL_IS_BORINGSSL)
43/* stack_index_t is the return type of OpenSSL's sk_XXX_num() functions. */
44typedef size_t stack_index_t;
45#else
46typedef int stack_index_t;
0cf03892
JM		 47#endif
48
080585c0
JM		 49#ifdef SSL_set_tlsext_status_type
50#ifndef OPENSSL_NO_TLSEXT
51#define HAVE_OCSP
52#include <openssl/ocsp.h>
53#endif /* OPENSSL_NO_TLSEXT */
54#endif /* SSL_set_tlsext_status_type */
55
1d415f1f
KR		 56#ifdef ANDROID
57#include <openssl/pem.h>
58#include <keystore/keystore_get.h>
59
60static BIO * BIO_from_keystore(const char *key)
61{
62 BIO *bio = NULL;
63 uint8_t *value = NULL;
64 int length = keystore_get(key, strlen(key), &value);
65 if (length != -1 && (bio = BIO_new(BIO_s_mem())) != NULL)
66 BIO_write(bio, value, length);
67 free(value);
68 return bio;
69}
70#endif /* ANDROID */
71
6fc6879b
JM		 72static int tls_openssl_ref_count = 0;
73
7c0e1e27 74struct tls_context {
00468b46
JM		 75 void (*event_cb)(void *ctx, enum tls_event ev,
76 union tls_event_data *data);
77 void *cb_ctx;
1b414f59 78 int cert_in_cb;
080585c0 79 char *ocsp_stapling_response;
00468b46
JM		 80};
81
7c0e1e27 82static struct tls_context *tls_global = NULL;
00468b46
JM		 83
84
6fc6879b 85struct tls_connection {
7c0e1e27 86 struct tls_context *context;
68ae4773 87 SSL_CTX *ssl_ctx;
6fc6879b
JM		 88 SSL *ssl;
89 BIO *ssl_in, *ssl_out;
90#ifndef OPENSSL_NO_ENGINE
91 ENGINE *engine; /* functional reference to the engine */
92 EVP_PKEY *private_key; /* the private key if using engine */
93#endif /* OPENSSL_NO_ENGINE */
cebee30f 94 char *subject_match, *altsubject_match, *suffix_match, *domain_match;
6fc6879b
JM		 95 int read_alerts, write_alerts, failed;
96
97 tls_session_ticket_cb session_ticket_cb;
98 void *session_ticket_cb_ctx;
99
100 /* SessionTicket received from OpenSSL hello_extension_cb (server) */
101 u8 *session_ticket;
102 size_t session_ticket_len;
00468b46 103
8d6399e4
JM		 104 unsigned int ca_cert_verify:1;
105 unsigned int cert_probe:1;
106 unsigned int server_cert_only:1;
bb52293e 107 unsigned int invalid_hb_used:1;
00468b46
JM		 108
109 u8 srv_cert_hash[32];
235279e7
JM		 110
111 unsigned int flags;
080585c0
JM		 112
113 X509 *peer_cert;
114 X509 *peer_issuer;
6bf61fb2 115 X509 *peer_issuer_issuer;
6fc6879b
JM		 116};
117
118
7c0e1e27
PS		 119static struct tls_context * tls_context_new(const struct tls_config *conf)
120{
121 struct tls_context *context = os_zalloc(sizeof(*context));
122 if (context == NULL)
123 return NULL;
124 if (conf) {
125 context->event_cb = conf->event_cb;
126 context->cb_ctx = conf->cb_ctx;
127 context->cert_in_cb = conf->cert_in_cb;
128 }
129 return context;
130}
131
132
6fc6879b
JM		 133#ifdef CONFIG_NO_STDOUT_DEBUG
134
135static void _tls_show_errors(void)
136{
137 unsigned long err;
138
139 while ((err = ERR_get_error())) {
140 /* Just ignore the errors, since stdout is disabled */
141 }
142}
143#define tls_show_errors(l, f, t) _tls_show_errors()
144
145#else /* CONFIG_NO_STDOUT_DEBUG */
146
147static void tls_show_errors(int level, const char *func, const char *txt)
148{
149 unsigned long err;
150
151 wpa_printf(level, "OpenSSL: %s - %s %s",
152 func, txt, ERR_error_string(ERR_get_error(), NULL));
153
154 while ((err = ERR_get_error())) {
155 wpa_printf(MSG_INFO, "OpenSSL: pending error: %s",
156 ERR_error_string(err, NULL));
157 }
158}
159
160#endif /* CONFIG_NO_STDOUT_DEBUG */
161
162
163#ifdef CONFIG_NATIVE_WINDOWS
164
165/* Windows CryptoAPI and access to certificate stores */
166#include <wincrypt.h>
167
168#ifdef __MINGW32_VERSION
169/*
170 * MinGW does not yet include all the needed definitions for CryptoAPI, so
171 * define here whatever extra is needed.
172 */
6fc6879b
JM		 173#define CERT_SYSTEM_STORE_CURRENT_USER (1 << 16)
174#define CERT_STORE_READONLY_FLAG 0x00008000
175#define CERT_STORE_OPEN_EXISTING_FLAG 0x00004000
6fc6879b
JM		 176
177#endif /* __MINGW32_VERSION */
178
179
180struct cryptoapi_rsa_data {
181 const CERT_CONTEXT *cert;
182 HCRYPTPROV crypt_prov;
183 DWORD key_spec;
184 BOOL free_crypt_prov;
185};
186
187
188static void cryptoapi_error(const char *msg)
189{
190 wpa_printf(MSG_INFO, "CryptoAPI: %s; err=%u",
191 msg, (unsigned int) GetLastError());
192}
193
194
195static int cryptoapi_rsa_pub_enc(int flen, const unsigned char *from,
196 unsigned char *to, RSA *rsa, int padding)
197{
198 wpa_printf(MSG_DEBUG, "%s - not implemented", __func__);
199 return 0;
200}
201
202
203static int cryptoapi_rsa_pub_dec(int flen, const unsigned char *from,
204 unsigned char *to, RSA *rsa, int padding)
205{
206 wpa_printf(MSG_DEBUG, "%s - not implemented", __func__);
207 return 0;
208}
209
210
211static int cryptoapi_rsa_priv_enc(int flen, const unsigned char *from,
212 unsigned char *to, RSA *rsa, int padding)
213{
214 struct cryptoapi_rsa_data *priv =
215 (struct cryptoapi_rsa_data *) rsa->meth->app_data;
216 HCRYPTHASH hash;
217 DWORD hash_size, len, i;
218 unsigned char *buf = NULL;
219 int ret = 0;
220
221 if (priv == NULL) {
222 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,
223 ERR_R_PASSED_NULL_PARAMETER);
224 return 0;
225 }
226
227 if (padding != RSA_PKCS1_PADDING) {
228 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,
229 RSA_R_UNKNOWN_PADDING_TYPE);
230 return 0;
231 }
232
233 if (flen != 16 /* MD5 */ + 20 /* SHA-1 */) {
234 wpa_printf(MSG_INFO, "%s - only MD5-SHA1 hash supported",
235 __func__);
236 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,
237 RSA_R_INVALID_MESSAGE_LENGTH);
238 return 0;
239 }
240
241 if (!CryptCreateHash(priv->crypt_prov, CALG_SSL3_SHAMD5, 0, 0, &hash))
242 {
243 cryptoapi_error("CryptCreateHash failed");
244 return 0;
245 }
246
247 len = sizeof(hash_size);
248 if (!CryptGetHashParam(hash, HP_HASHSIZE, (BYTE *) &hash_size, &len,
249 0)) {
250 cryptoapi_error("CryptGetHashParam failed");
251 goto err;
252 }
253
254 if ((int) hash_size != flen) {
255 wpa_printf(MSG_INFO, "CryptoAPI: Invalid hash size (%u != %d)",
256 (unsigned) hash_size, flen);
257 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT,
258 RSA_R_INVALID_MESSAGE_LENGTH);
259 goto err;
260 }
261 if (!CryptSetHashParam(hash, HP_HASHVAL, (BYTE * ) from, 0)) {
262 cryptoapi_error("CryptSetHashParam failed");
263 goto err;
264 }
265
266 len = RSA_size(rsa);
267 buf = os_malloc(len);
268 if (buf == NULL) {
269 RSAerr(RSA_F_RSA_EAY_PRIVATE_ENCRYPT, ERR_R_MALLOC_FAILURE);
270 goto err;
271 }
272
273 if (!CryptSignHash(hash, priv->key_spec, NULL, 0, buf, &len)) {
274 cryptoapi_error("CryptSignHash failed");
275 goto err;
276 }
277
278 for (i = 0; i < len; i++)
279 to[i] = buf[len - i - 1];
280 ret = len;
281
282err:
283 os_free(buf);
284 CryptDestroyHash(hash);
285
286 return ret;
287}
288
289
290static int cryptoapi_rsa_priv_dec(int flen, const unsigned char *from,
291 unsigned char *to, RSA *rsa, int padding)
292{
293 wpa_printf(MSG_DEBUG, "%s - not implemented", __func__);
294 return 0;
295}
296
297
298static void cryptoapi_free_data(struct cryptoapi_rsa_data *priv)
299{
300 if (priv == NULL)
301 return;
302 if (priv->crypt_prov && priv->free_crypt_prov)
303 CryptReleaseContext(priv->crypt_prov, 0);
304 if (priv->cert)
305 CertFreeCertificateContext(priv->cert);
306 os_free(priv);
307}
308
309
310static int cryptoapi_finish(RSA *rsa)
311{
312 cryptoapi_free_data((struct cryptoapi_rsa_data *) rsa->meth->app_data);
313 os_free((void *) rsa->meth);
314 rsa->meth = NULL;
315 return 1;
316}
317
318
319static const CERT_CONTEXT * cryptoapi_find_cert(const char *name, DWORD store)
320{
321 HCERTSTORE cs;
322 const CERT_CONTEXT *ret = NULL;
323
324 cs = CertOpenStore((LPCSTR) CERT_STORE_PROV_SYSTEM, 0, 0,
325 store | CERT_STORE_OPEN_EXISTING_FLAG |
326 CERT_STORE_READONLY_FLAG, L"MY");
327 if (cs == NULL) {
328 cryptoapi_error("Failed to open 'My system store'");
329 return NULL;
330 }
331
332 if (strncmp(name, "cert://", 7) == 0) {
333 unsigned short wbuf[255];
334 MultiByteToWideChar(CP_ACP, 0, name + 7, -1, wbuf, 255);
335 ret = CertFindCertificateInStore(cs, X509_ASN_ENCODING |
336 PKCS_7_ASN_ENCODING,
337 0, CERT_FIND_SUBJECT_STR,
338 wbuf, NULL);
339 } else if (strncmp(name, "hash://", 7) == 0) {
340 CRYPT_HASH_BLOB blob;
341 int len;
342 const char *hash = name + 7;
343 unsigned char *buf;
344
345 len = os_strlen(hash) / 2;
346 buf = os_malloc(len);
347 if (buf && hexstr2bin(hash, buf, len) == 0) {
348 blob.cbData = len;
349 blob.pbData = buf;
350 ret = CertFindCertificateInStore(cs,
351 X509_ASN_ENCODING |
352 PKCS_7_ASN_ENCODING,
353 0, CERT_FIND_HASH,
354 &blob, NULL);
355 }
356 os_free(buf);
357 }
358
359 CertCloseStore(cs, 0);
360
361 return ret;
362}
363
364
365static int tls_cryptoapi_cert(SSL *ssl, const char *name)
366{
367 X509 *cert = NULL;
368 RSA *rsa = NULL, *pub_rsa;
369 struct cryptoapi_rsa_data *priv;
370 RSA_METHOD *rsa_meth;
371
372 if (name == NULL ||
373 (strncmp(name, "cert://", 7) != 0 &&
374 strncmp(name, "hash://", 7) != 0))
375 return -1;
376
377 priv = os_zalloc(sizeof(*priv));
378 rsa_meth = os_zalloc(sizeof(*rsa_meth));
379 if (priv == NULL || rsa_meth == NULL) {
380 wpa_printf(MSG_WARNING, "CryptoAPI: Failed to allocate memory "
381 "for CryptoAPI RSA method");
382 os_free(priv);
383 os_free(rsa_meth);
384 return -1;
385 }
386
387 priv->cert = cryptoapi_find_cert(name, CERT_SYSTEM_STORE_CURRENT_USER);
388 if (priv->cert == NULL) {
389 priv->cert = cryptoapi_find_cert(
390 name, CERT_SYSTEM_STORE_LOCAL_MACHINE);
391 }
392 if (priv->cert == NULL) {
393 wpa_printf(MSG_INFO, "CryptoAPI: Could not find certificate "
394 "'%s'", name);
395 goto err;
396 }
397
fee31f76
JM		 398 cert = d2i_X509(NULL,
399 (const unsigned char **) &priv->cert->pbCertEncoded,
6fc6879b
JM		 400 priv->cert->cbCertEncoded);
401 if (cert == NULL) {
402 wpa_printf(MSG_INFO, "CryptoAPI: Could not process X509 DER "
403 "encoding");
404 goto err;
405 }
406
6fc6879b
JM		 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
453err:
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
466static 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
6fc6879b
JM		 477 if (name == NULL || strncmp(name, "cert_store://", 13) != 0)
478 return -1;
479
480 store = name + 13;
481#ifdef UNICODE
482 wstore = os_malloc((os_strlen(store) + 1) * sizeof(WCHAR));
483 if (wstore == NULL)
484 return -1;
485 wsprintf(wstore, L"%S", store);
486 cs = CertOpenSystemStore(0, wstore);
487 os_free(wstore);
488#else /* UNICODE */
489 cs = CertOpenSystemStore(0, store);
490#endif /* UNICODE */
491 if (cs == NULL) {
492 wpa_printf(MSG_DEBUG, "%s: failed to open system cert store "
493 "'%s': error=%d", __func__, store,
494 (int) GetLastError());
495 return -1;
496 }
497
498 while ((ctx = CertEnumCertificatesInStore(cs, ctx))) {
fee31f76
JM		 499 cert = d2i_X509(NULL,
500 (const unsigned char **) &ctx->pbCertEncoded,
6fc6879b
JM		 501 ctx->cbCertEncoded);
502 if (cert == NULL) {
503 wpa_printf(MSG_INFO, "CryptoAPI: Could not process "
504 "X509 DER encoding for CA cert");
505 continue;
506 }
507
508 X509_NAME_oneline(X509_get_subject_name(cert), buf,
509 sizeof(buf));
510 wpa_printf(MSG_DEBUG, "OpenSSL: Loaded CA certificate for "
511 "system certificate store: subject='%s'", buf);
512
513 if (!X509_STORE_add_cert(ssl_ctx->cert_store, cert)) {
514 tls_show_errors(MSG_WARNING, __func__,
515 "Failed to add ca_cert to OpenSSL "
516 "certificate store");
517 }
518
519 X509_free(cert);
520 }
521
522 if (!CertCloseStore(cs, 0)) {
523 wpa_printf(MSG_DEBUG, "%s: failed to close system cert store "
524 "'%s': error=%d", __func__, name + 13,
525 (int) GetLastError());
526 }
527
528 return 0;
529}
530
531
532#else /* CONFIG_NATIVE_WINDOWS */
533
534static int tls_cryptoapi_cert(SSL *ssl, const char *name)
535{
536 return -1;
537}
538
539#endif /* CONFIG_NATIVE_WINDOWS */
540
541
542static void ssl_info_cb(const SSL *ssl, int where, int ret)
543{
544 const char *str;
545 int w;
546
547 wpa_printf(MSG_DEBUG, "SSL: (where=0x%x ret=0x%x)", where, ret);
548 w = where & ~SSL_ST_MASK;
549 if (w & SSL_ST_CONNECT)
550 str = "SSL_connect";
551 else if (w & SSL_ST_ACCEPT)
552 str = "SSL_accept";
553 else
554 str = "undefined";
555
556 if (where & SSL_CB_LOOP) {
557 wpa_printf(MSG_DEBUG, "SSL: %s:%s",
558 str, SSL_state_string_long(ssl));
559 } else if (where & SSL_CB_ALERT) {
7c0e1e27 560 struct tls_connection *conn = SSL_get_app_data((SSL *) ssl);
6fc6879b
JM		 561 wpa_printf(MSG_INFO, "SSL: SSL3 alert: %s:%s:%s",
562 where & SSL_CB_READ ?
563 "read (remote end reported an error)" :
564 "write (local SSL3 detected an error)",
565 SSL_alert_type_string_long(ret),
566 SSL_alert_desc_string_long(ret));
567 if ((ret >> 8) == SSL3_AL_FATAL) {
6fc6879b
JM		 568 if (where & SSL_CB_READ)
569 conn->read_alerts++;
570 else
571 conn->write_alerts++;
572 }
7c0e1e27 573 if (conn->context->event_cb != NULL) {
dd7fec1f 574 union tls_event_data ev;
7c0e1e27 575 struct tls_context *context = conn->context;
dd7fec1f
PS		 576 os_memset(&ev, 0, sizeof(ev));
577 ev.alert.is_local = !(where & SSL_CB_READ);
578 ev.alert.type = SSL_alert_type_string_long(ret);
579 ev.alert.description = SSL_alert_desc_string_long(ret);
7c0e1e27 580 context->event_cb(context->cb_ctx, TLS_ALERT, &ev);
dd7fec1f 581 }
6fc6879b
JM		 582 } else if (where & SSL_CB_EXIT && ret <= 0) {
583 wpa_printf(MSG_DEBUG, "SSL: %s:%s in %s",
584 str, ret == 0 ? "failed" : "error",
585 SSL_state_string_long(ssl));
586 }
587}
588
589
590#ifndef OPENSSL_NO_ENGINE
591/**
592 * tls_engine_load_dynamic_generic - load any openssl engine
593 * @pre: an array of commands and values that load an engine initialized
594 * in the engine specific function
595 * @post: an array of commands and values that initialize an already loaded
596 * engine (or %NULL if not required)
597 * @id: the engine id of the engine to load (only required if post is not %NULL
598 *
599 * This function is a generic function that loads any openssl engine.
600 *
601 * Returns: 0 on success, -1 on failure
602 */
603static int tls_engine_load_dynamic_generic(const char *pre[],
604 const char *post[], const char *id)
605{
606 ENGINE *engine;
607 const char *dynamic_id = "dynamic";
608
609 engine = ENGINE_by_id(id);
610 if (engine) {
611 ENGINE_free(engine);
612 wpa_printf(MSG_DEBUG, "ENGINE: engine '%s' is already "
613 "available", id);
614 return 0;
615 }
616 ERR_clear_error();
617
618 engine = ENGINE_by_id(dynamic_id);
619 if (engine == NULL) {
620 wpa_printf(MSG_INFO, "ENGINE: Can't find engine %s [%s]",
621 dynamic_id,
622 ERR_error_string(ERR_get_error(), NULL));
623 return -1;
624 }
625
626 /* Perform the pre commands. This will load the engine. */
627 while (pre && pre[0]) {
628 wpa_printf(MSG_DEBUG, "ENGINE: '%s' '%s'", pre[0], pre[1]);
629 if (ENGINE_ctrl_cmd_string(engine, pre[0], pre[1], 0) == 0) {
630 wpa_printf(MSG_INFO, "ENGINE: ctrl cmd_string failed: "
631 "%s %s [%s]", pre[0], pre[1],
632 ERR_error_string(ERR_get_error(), NULL));
633 ENGINE_free(engine);
634 return -1;
635 }
636 pre += 2;
637 }
638
639 /*
640 * Free the reference to the "dynamic" engine. The loaded engine can
641 * now be looked up using ENGINE_by_id().
642 */
643 ENGINE_free(engine);
644
645 engine = ENGINE_by_id(id);
646 if (engine == NULL) {
647 wpa_printf(MSG_INFO, "ENGINE: Can't find engine %s [%s]",
648 id, ERR_error_string(ERR_get_error(), NULL));
649 return -1;
650 }
651
652 while (post && post[0]) {
653 wpa_printf(MSG_DEBUG, "ENGINE: '%s' '%s'", post[0], post[1]);
654 if (ENGINE_ctrl_cmd_string(engine, post[0], post[1], 0) == 0) {
655 wpa_printf(MSG_DEBUG, "ENGINE: ctrl cmd_string failed:"
656 " %s %s [%s]", post[0], post[1],
657 ERR_error_string(ERR_get_error(), NULL));
658 ENGINE_remove(engine);
659 ENGINE_free(engine);
660 return -1;
661 }
662 post += 2;
663 }
664 ENGINE_free(engine);
665
666 return 0;
667}
668
669
670/**
671 * tls_engine_load_dynamic_pkcs11 - load the pkcs11 engine provided by opensc
672 * @pkcs11_so_path: pksc11_so_path from the configuration
673 * @pcks11_module_path: pkcs11_module_path from the configuration
674 */
675static int tls_engine_load_dynamic_pkcs11(const char *pkcs11_so_path,
676 const char *pkcs11_module_path)
677{
678 char *engine_id = "pkcs11";
679 const char *pre_cmd[] = {
680 "SO_PATH", NULL /* pkcs11_so_path */,
681 "ID", NULL /* engine_id */,
682 "LIST_ADD", "1",
683 /* "NO_VCHECK", "1", */
684 "LOAD", NULL,
685 NULL, NULL
686 };
687 const char *post_cmd[] = {
688 "MODULE_PATH", NULL /* pkcs11_module_path */,
689 NULL, NULL
690 };
691
5c8ab0d4 692 if (!pkcs11_so_path)
6fc6879b
JM		 693 return 0;
694
695 pre_cmd[1] = pkcs11_so_path;
696 pre_cmd[3] = engine_id;
5c8ab0d4
DW		 697 if (pkcs11_module_path)
698 post_cmd[1] = pkcs11_module_path;
699 else
700 post_cmd[0] = NULL;
6fc6879b
JM		 701
702 wpa_printf(MSG_DEBUG, "ENGINE: Loading pkcs11 Engine from %s",
703 pkcs11_so_path);
704
705 return tls_engine_load_dynamic_generic(pre_cmd, post_cmd, engine_id);
706}
707
708
709/**
710 * tls_engine_load_dynamic_opensc - load the opensc engine provided by opensc
711 * @opensc_so_path: opensc_so_path from the configuration
712 */
713static int tls_engine_load_dynamic_opensc(const char *opensc_so_path)
714{
715 char *engine_id = "opensc";
716 const char *pre_cmd[] = {
717 "SO_PATH", NULL /* opensc_so_path */,
718 "ID", NULL /* engine_id */,
719 "LIST_ADD", "1",
720 "LOAD", NULL,
721 NULL, NULL
722 };
723
724 if (!opensc_so_path)
725 return 0;
726
727 pre_cmd[1] = opensc_so_path;
728 pre_cmd[3] = engine_id;
729
730 wpa_printf(MSG_DEBUG, "ENGINE: Loading OpenSC Engine from %s",
731 opensc_so_path);
732
733 return tls_engine_load_dynamic_generic(pre_cmd, NULL, engine_id);
734}
735#endif /* OPENSSL_NO_ENGINE */
736
737
738void * tls_init(const struct tls_config *conf)
739{
740 SSL_CTX *ssl;
7c0e1e27 741 struct tls_context *context;
b7328434 742 const char *ciphers;
6fc6879b
JM		 743
744 if (tls_openssl_ref_count == 0) {
7c0e1e27
PS		 745 tls_global = context = tls_context_new(conf);
746 if (context == NULL)
00468b46 747 return NULL;
76f04b38
JM		 748#ifdef CONFIG_FIPS
749#ifdef OPENSSL_FIPS
cf123d7f 750 if (conf && conf->fips_mode) {
76f04b38
JM		 751 if (!FIPS_mode_set(1)) {
752 wpa_printf(MSG_ERROR, "Failed to enable FIPS "
753 "mode");
754 ERR_load_crypto_strings();
755 ERR_print_errors_fp(stderr);
b36540db
JM		 756 os_free(tls_global);
757 tls_global = NULL;
76f04b38
JM		 758 return NULL;
759 } else
760 wpa_printf(MSG_INFO, "Running in FIPS mode");
761 }
762#else /* OPENSSL_FIPS */
cf123d7f 763 if (conf && conf->fips_mode) {
76f04b38
JM		 764 wpa_printf(MSG_ERROR, "FIPS mode requested, but not "
765 "supported");
b36540db
JM		 766 os_free(tls_global);
767 tls_global = NULL;
76f04b38
JM		 768 return NULL;
769 }
770#endif /* OPENSSL_FIPS */
771#endif /* CONFIG_FIPS */
6fc6879b
JM		 772 SSL_load_error_strings();
773 SSL_library_init();
fee31f76 774#ifndef OPENSSL_NO_SHA256
e1ffdfc1
JM		 775 EVP_add_digest(EVP_sha256());
776#endif /* OPENSSL_NO_SHA256 */
6fc6879b
JM		 777 /* TODO: if /dev/urandom is available, PRNG is seeded
778 * automatically. If this is not the case, random data should
779 * be added here. */
780
781#ifdef PKCS12_FUNCS
1056dad7
JM		 782#ifndef OPENSSL_NO_RC2
783 /*
784 * 40-bit RC2 is commonly used in PKCS#12 files, so enable it.
785 * This is enabled by PKCS12_PBE_add() in OpenSSL 0.9.8
786 * versions, but it looks like OpenSSL 1.0.0 does not do that
787 * anymore.
788 */
789 EVP_add_cipher(EVP_rc2_40_cbc());
790#endif /* OPENSSL_NO_RC2 */
6fc6879b
JM		 791 PKCS12_PBE_add();
792#endif /* PKCS12_FUNCS */
7c0e1e27 793 } else {
7c0e1e27
PS		 794#ifdef OPENSSL_SUPPORTS_CTX_APP_DATA
795 /* Newer OpenSSL can store app-data per-SSL */
796 context = tls_context_new(conf);
797 if (context == NULL)
798 return NULL;
a5802c06
JM		 799#else /* OPENSSL_SUPPORTS_CTX_APP_DATA */
800 context = tls_global;
7c0e1e27 801#endif /* OPENSSL_SUPPORTS_CTX_APP_DATA */
6fc6879b
JM		 802 }
803 tls_openssl_ref_count++;
804
35efa247 805 ssl = SSL_CTX_new(SSLv23_method());
7c0e1e27
PS		 806 if (ssl == NULL) {
807 tls_openssl_ref_count--;
a288da61
JM		 808#ifdef OPENSSL_SUPPORTS_CTX_APP_DATA
809 if (context != tls_global)
810 os_free(context);
811#endif /* OPENSSL_SUPPORTS_CTX_APP_DATA */
7c0e1e27
PS		 812 if (tls_openssl_ref_count == 0) {
813 os_free(tls_global);
814 tls_global = NULL;
7c0e1e27 815 }
6fc6879b 816 return NULL;
7c0e1e27 817 }
6fc6879b 818
35efa247
JM		 819 SSL_CTX_set_options(ssl, SSL_OP_NO_SSLv2);
820 SSL_CTX_set_options(ssl, SSL_OP_NO_SSLv3);
821
6fc6879b 822 SSL_CTX_set_info_callback(ssl, ssl_info_cb);
7c0e1e27
PS		 823#ifdef OPENSSL_SUPPORTS_CTX_APP_DATA
824 SSL_CTX_set_app_data(ssl, context);
825#endif /* OPENSSL_SUPPORTS_CTX_APP_DATA */
6fc6879b
JM		 826
827#ifndef OPENSSL_NO_ENGINE
ddda6276
DW		 828 wpa_printf(MSG_DEBUG, "ENGINE: Loading dynamic engine");
829 ERR_load_ENGINE_strings();
830 ENGINE_load_dynamic();
831
6fc6879b
JM		 832 if (conf &&
833 (conf->opensc_engine_path || conf->pkcs11_engine_path ||
834 conf->pkcs11_module_path)) {
6fc6879b
JM		 835 if (tls_engine_load_dynamic_opensc(conf->opensc_engine_path) ||
836 tls_engine_load_dynamic_pkcs11(conf->pkcs11_engine_path,
837 conf->pkcs11_module_path)) {
838 tls_deinit(ssl);
839 return NULL;
840 }
841 }
842#endif /* OPENSSL_NO_ENGINE */
843
b7328434
JM		 844 if (conf && conf->openssl_ciphers)
845 ciphers = conf->openssl_ciphers;
846 else
847 ciphers = "DEFAULT:!EXP:!LOW";
848 if (SSL_CTX_set_cipher_list(ssl, ciphers) != 1) {
849 wpa_printf(MSG_ERROR,
850 "OpenSSL: Failed to set cipher string '%s'",
851 ciphers);
852 tls_deinit(ssl);
853 return NULL;
854 }
855
6fc6879b
JM		 856 return ssl;
857}
858
859
860void tls_deinit(void *ssl_ctx)
861{
862 SSL_CTX *ssl = ssl_ctx;
7c0e1e27
PS		 863#ifdef OPENSSL_SUPPORTS_CTX_APP_DATA
864 struct tls_context *context = SSL_CTX_get_app_data(ssl);
865 if (context != tls_global)
866 os_free(context);
867#endif /* OPENSSL_SUPPORTS_CTX_APP_DATA */
6fc6879b
JM		 868 SSL_CTX_free(ssl);
869
870 tls_openssl_ref_count--;
871 if (tls_openssl_ref_count == 0) {
872#ifndef OPENSSL_NO_ENGINE
873 ENGINE_cleanup();
874#endif /* OPENSSL_NO_ENGINE */
875 CRYPTO_cleanup_all_ex_data();
a8572960 876 ERR_remove_thread_state(NULL);
6fc6879b
JM		 877 ERR_free_strings();
878 EVP_cleanup();
080585c0
JM		 879 os_free(tls_global->ocsp_stapling_response);
880 tls_global->ocsp_stapling_response = NULL;
00468b46
JM		 881 os_free(tls_global);
882 tls_global = NULL;
6fc6879b
JM		 883 }
884}
885
886
887static int tls_engine_init(struct tls_connection *conn, const char *engine_id,
e59c91af
DS		 888 const char *pin, const char *key_id,
889 const char *cert_id, const char *ca_cert_id)
6fc6879b
JM		 890{
891#ifndef OPENSSL_NO_ENGINE
892 int ret = -1;
893 if (engine_id == NULL) {
894 wpa_printf(MSG_ERROR, "ENGINE: Engine ID not set");
895 return -1;
896 }
6fc6879b
JM		 897
898 ERR_clear_error();
1176ab6d
KR		 899#ifdef ANDROID
900 ENGINE_load_dynamic();
901#endif
6fc6879b
JM		 902 conn->engine = ENGINE_by_id(engine_id);
903 if (!conn->engine) {
904 wpa_printf(MSG_ERROR, "ENGINE: engine %s not available [%s]",
905 engine_id, ERR_error_string(ERR_get_error(), NULL));
906 goto err;
907 }
908 if (ENGINE_init(conn->engine) != 1) {
909 wpa_printf(MSG_ERROR, "ENGINE: engine init failed "
910 "(engine: %s) [%s]", engine_id,
911 ERR_error_string(ERR_get_error(), NULL));
912 goto err;
913 }
914 wpa_printf(MSG_DEBUG, "ENGINE: engine initialized");
915
1176ab6d 916#ifndef ANDROID
a642a52b 917 if (pin && ENGINE_ctrl_cmd_string(conn->engine, "PIN", pin, 0) == 0) {
6fc6879b
JM		 918 wpa_printf(MSG_ERROR, "ENGINE: cannot set pin [%s]",
919 ERR_error_string(ERR_get_error(), NULL));
920 goto err;
921 }
1176ab6d 922#endif
3d268b8d 923 if (key_id) {
a642a52b
DW		 924 /*
925 * Ensure that the ENGINE does not attempt to use the OpenSSL
926 * UI system to obtain a PIN, if we didn't provide one.
927 */
928 struct {
929 const void *password;
930 const char *prompt_info;
931 } key_cb = { "", NULL };
932
3d268b8d
DW		 933 /* load private key first in-case PIN is required for cert */
934 conn->private_key = ENGINE_load_private_key(conn->engine,
a642a52b
DW		 935 key_id, NULL,
936 &key_cb);
3d268b8d
DW		 937 if (!conn->private_key) {
938 wpa_printf(MSG_ERROR,
939 "ENGINE: cannot load private key with id '%s' [%s]",
940 key_id,
941 ERR_error_string(ERR_get_error(), NULL));
942 ret = TLS_SET_PARAMS_ENGINE_PRV_INIT_FAILED;
943 goto err;
944 }
6fc6879b 945 }
e59c91af
DS		 946
947 /* handle a certificate and/or CA certificate */
948 if (cert_id || ca_cert_id) {
949 const char *cmd_name = "LOAD_CERT_CTRL";
950
951 /* test if the engine supports a LOAD_CERT_CTRL */
952 if (!ENGINE_ctrl(conn->engine, ENGINE_CTRL_GET_CMD_FROM_NAME,
953 0, (void *)cmd_name, NULL)) {
954 wpa_printf(MSG_ERROR, "ENGINE: engine does not support"
955 " loading certificates");
956 ret = TLS_SET_PARAMS_ENGINE_PRV_INIT_FAILED;
957 goto err;
958 }
959 }
960
6fc6879b
JM		 961 return 0;
962
963err:
964 if (conn->engine) {
965 ENGINE_free(conn->engine);
966 conn->engine = NULL;
967 }
968
969 if (conn->private_key) {
970 EVP_PKEY_free(conn->private_key);
971 conn->private_key = NULL;
972 }
973
974 return ret;
975#else /* OPENSSL_NO_ENGINE */
976 return 0;
977#endif /* OPENSSL_NO_ENGINE */
978}
979
980
981static void tls_engine_deinit(struct tls_connection *conn)
982{
983#ifndef OPENSSL_NO_ENGINE
984 wpa_printf(MSG_DEBUG, "ENGINE: engine deinit");
985 if (conn->private_key) {
986 EVP_PKEY_free(conn->private_key);
987 conn->private_key = NULL;
988 }
989 if (conn->engine) {
990 ENGINE_finish(conn->engine);
991 conn->engine = NULL;
992 }
993#endif /* OPENSSL_NO_ENGINE */
994}
995
996
997int tls_get_errors(void *ssl_ctx)
998{
999 int count = 0;
1000 unsigned long err;
1001
1002 while ((err = ERR_get_error())) {
1003 wpa_printf(MSG_INFO, "TLS - SSL error: %s",
1004 ERR_error_string(err, NULL));
1005 count++;
1006 }
1007
1008 return count;
1009}
1010
bb52293e
JM		 1011
1012static void tls_msg_cb(int write_p, int version, int content_type,
1013 const void *buf, size_t len, SSL *ssl, void *arg)
1014{
1015 struct tls_connection *conn = arg;
1016 const u8 *pos = buf;
1017
1018 wpa_printf(MSG_DEBUG, "OpenSSL: %s ver=0x%x content_type=%d",
1019 write_p ? "TX" : "RX", version, content_type);
1020 wpa_hexdump_key(MSG_MSGDUMP, "OpenSSL: Message", buf, len);
1021 if (content_type == 24 && len >= 3 && pos[0] == 1) {
1022 size_t payload_len = WPA_GET_BE16(pos + 1);
1023 if (payload_len + 3 > len) {
1024 wpa_printf(MSG_ERROR, "OpenSSL: Heartbeat attack detected");
1025 conn->invalid_hb_used = 1;
1026 }
1027 }
1028}
1029
1030
6a31a31d 1031struct tls_connection * tls_connection_init(void *ssl_ctx)
6fc6879b 1032{
6a31a31d
JM		 1033 SSL_CTX *ssl = ssl_ctx;
1034 struct tls_connection *conn;
fca25ef4 1035 long options;
7c0e1e27 1036#ifdef OPENSSL_SUPPORTS_CTX_APP_DATA
6a31a31d 1037 struct tls_context *context = SSL_CTX_get_app_data(ssl);
a5802c06
JM		 1038#else /* OPENSSL_SUPPORTS_CTX_APP_DATA */
1039 struct tls_context *context = tls_global;
7c0e1e27 1040#endif /* OPENSSL_SUPPORTS_CTX_APP_DATA */
6fc6879b 1041
6a31a31d
JM		 1042 conn = os_zalloc(sizeof(*conn));
1043 if (conn == NULL)
1044 return NULL;
68ae4773 1045 conn->ssl_ctx = ssl_ctx;
6a31a31d
JM		 1046 conn->ssl = SSL_new(ssl);
1047 if (conn->ssl == NULL) {
6fc6879b
JM		 1048 tls_show_errors(MSG_INFO, __func__,
1049 "Failed to initialize new SSL connection");
6a31a31d
JM		 1050 os_free(conn);
1051 return NULL;
6fc6879b
JM		 1052 }
1053
6a31a31d
JM		 1054 conn->context = context;
1055 SSL_set_app_data(conn->ssl, conn);
1056 SSL_set_msg_callback(conn->ssl, tls_msg_cb);
1057 SSL_set_msg_callback_arg(conn->ssl, conn);
fca25ef4
JM		 1058 options = SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 |
1059 SSL_OP_SINGLE_DH_USE;
1060#ifdef SSL_OP_NO_COMPRESSION
1061 options |= SSL_OP_NO_COMPRESSION;
1062#endif /* SSL_OP_NO_COMPRESSION */
6a31a31d 1063 SSL_set_options(conn->ssl, options);
6fc6879b 1064
6a31a31d
JM		 1065 conn->ssl_in = BIO_new(BIO_s_mem());
1066 if (!conn->ssl_in) {
6fc6879b
JM		 1067 tls_show_errors(MSG_INFO, __func__,
1068 "Failed to create a new BIO for ssl_in");
6a31a31d
JM		 1069 SSL_free(conn->ssl);
1070 os_free(conn);
1071 return NULL;
6fc6879b
JM		 1072 }
1073
6a31a31d
JM		 1074 conn->ssl_out = BIO_new(BIO_s_mem());
1075 if (!conn->ssl_out) {
6fc6879b
JM		 1076 tls_show_errors(MSG_INFO, __func__,
1077 "Failed to create a new BIO for ssl_out");
1078 SSL_free(conn->ssl);
6a31a31d 1079 BIO_free(conn->ssl_in);
6fc6879b
JM		 1080 os_free(conn);
1081 return NULL;
1082 }
1083
6a31a31d
JM		 1084 SSL_set_bio(conn->ssl, conn->ssl_in, conn->ssl_out);
1085
6fc6879b
JM		 1086 return conn;
1087}
1088
1089
1090void tls_connection_deinit(void *ssl_ctx, struct tls_connection *conn)
1091{
1092 if (conn == NULL)
1093 return;
1094 SSL_free(conn->ssl);
1095 tls_engine_deinit(conn);
1096 os_free(conn->subject_match);
1097 os_free(conn->altsubject_match);
01f809c7 1098 os_free(conn->suffix_match);
cebee30f 1099 os_free(conn->domain_match);
6fc6879b
JM		 1100 os_free(conn->session_ticket);
1101 os_free(conn);
1102}
1103
1104
1105int tls_connection_established(void *ssl_ctx, struct tls_connection *conn)
1106{
1107 return conn ? SSL_is_init_finished(conn->ssl) : 0;
1108}
1109
1110
1111int tls_connection_shutdown(void *ssl_ctx, struct tls_connection *conn)
1112{
1113 if (conn == NULL)
1114 return -1;
1115
1116 /* Shutdown previous TLS connection without notifying the peer
1117 * because the connection was already terminated in practice
1118 * and "close notify" shutdown alert would confuse AS. */
1119 SSL_set_quiet_shutdown(conn->ssl, 1);
1120 SSL_shutdown(conn->ssl);
1121 return 0;
1122}
1123
1124
1125static int tls_match_altsubject_component(X509 *cert, int type,
1126 const char *value, size_t len)
1127{
1128 GENERAL_NAME *gen;
1129 void *ext;
a8572960
AL		 1130 int found = 0;
1131 stack_index_t i;
6fc6879b
JM		 1132
1133 ext = X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL);
1134
1135 for (i = 0; ext && i < sk_GENERAL_NAME_num(ext); i++) {
1136 gen = sk_GENERAL_NAME_value(ext, i);
1137 if (gen->type != type)
1138 continue;
1139 if (os_strlen((char *) gen->d.ia5->data) == len &&
1140 os_memcmp(value, gen->d.ia5->data, len) == 0)
1141 found++;
1142 }
1143
1144 return found;
1145}
1146
1147
1148static int tls_match_altsubject(X509 *cert, const char *match)
1149{
1150 int type;
1151 const char *pos, *end;
1152 size_t len;
1153
1154 pos = match;
1155 do {
1156 if (os_strncmp(pos, "EMAIL:", 6) == 0) {
1157 type = GEN_EMAIL;
1158 pos += 6;
1159 } else if (os_strncmp(pos, "DNS:", 4) == 0) {
1160 type = GEN_DNS;
1161 pos += 4;
1162 } else if (os_strncmp(pos, "URI:", 4) == 0) {
1163 type = GEN_URI;
1164 pos += 4;
1165 } else {
1166 wpa_printf(MSG_INFO, "TLS: Invalid altSubjectName "
1167 "match '%s'", pos);
1168 return 0;
1169 }
1170 end = os_strchr(pos, ';');
1171 while (end) {
1172 if (os_strncmp(end + 1, "EMAIL:", 6) == 0 ||
1173 os_strncmp(end + 1, "DNS:", 4) == 0 ||
1174 os_strncmp(end + 1, "URI:", 4) == 0)
1175 break;
1176 end = os_strchr(end + 1, ';');
1177 }
1178 if (end)
1179 len = end - pos;
1180 else
1181 len = os_strlen(pos);
1182 if (tls_match_altsubject_component(cert, type, pos, len) > 0)
1183 return 1;
1184 pos = end + 1;
1185 } while (end);
1186
1187 return 0;
1188}
1189
1190
461e3ebe 1191#ifndef CONFIG_NATIVE_WINDOWS
cebee30f
JM		 1192static int domain_suffix_match(const u8 *val, size_t len, const char *match,
1193 int full)
01f809c7
JM		 1194{
1195 size_t i, match_len;
1196
1197 /* Check for embedded nuls that could mess up suffix matching */
1198 for (i = 0; i < len; i++) {
1199 if (val[i] == '\0') {
1200 wpa_printf(MSG_DEBUG, "TLS: Embedded null in a string - reject");
1201 return 0;
1202 }
1203 }
1204
1205 match_len = os_strlen(match);
cebee30f 1206 if (match_len > len || (full && match_len != len))
01f809c7
JM		 1207 return 0;
1208
1209 if (os_strncasecmp((const char *) val + len - match_len, match,
1210 match_len) != 0)
1211 return 0; /* no match */
1212
1213 if (match_len == len)
1214 return 1; /* exact match */
1215
1216 if (val[len - match_len - 1] == '.')
1217 return 1; /* full label match completes suffix match */
1218
1219 wpa_printf(MSG_DEBUG, "TLS: Reject due to incomplete label match");
1220 return 0;
1221}
461e3ebe 1222#endif /* CONFIG_NATIVE_WINDOWS */
01f809c7
JM		 1223
1224
cebee30f 1225static int tls_match_suffix(X509 *cert, const char *match, int full)
01f809c7 1226{
461e3ebe
JM		 1227#ifdef CONFIG_NATIVE_WINDOWS
1228 /* wincrypt.h has conflicting X509_NAME definition */
1229 return -1;
1230#else /* CONFIG_NATIVE_WINDOWS */
01f809c7
JM		 1231 GENERAL_NAME *gen;
1232 void *ext;
1233 int i;
98a1571d 1234 stack_index_t j;
01f809c7
JM		 1235 int dns_name = 0;
1236 X509_NAME *name;
1237
cebee30f
JM		 1238 wpa_printf(MSG_DEBUG, "TLS: Match domain against %s%s",
1239 full ? "": "suffix ", match);
01f809c7
JM		 1240
1241 ext = X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL);
1242
98a1571d
JM		 1243 for (j = 0; ext && j < sk_GENERAL_NAME_num(ext); j++) {
1244 gen = sk_GENERAL_NAME_value(ext, j);
01f809c7
JM		 1245 if (gen->type != GEN_DNS)
1246 continue;
1247 dns_name++;
1248 wpa_hexdump_ascii(MSG_DEBUG, "TLS: Certificate dNSName",
1249 gen->d.dNSName->data,
1250 gen->d.dNSName->length);
1251 if (domain_suffix_match(gen->d.dNSName->data,
cebee30f
JM		 1252 gen->d.dNSName->length, match, full) ==
1253 1) {
1254 wpa_printf(MSG_DEBUG, "TLS: %s in dNSName found",
1255 full ? "Match" : "Suffix match");
01f809c7
JM		 1256 return 1;
1257 }
1258 }
1259
1260 if (dns_name) {
1261 wpa_printf(MSG_DEBUG, "TLS: None of the dNSName(s) matched");
1262 return 0;
1263 }
1264
1265 name = X509_get_subject_name(cert);
1266 i = -1;
1267 for (;;) {
1268 X509_NAME_ENTRY *e;
1269 ASN1_STRING *cn;
1270
1271 i = X509_NAME_get_index_by_NID(name, NID_commonName, i);
1272 if (i == -1)
1273 break;
1274 e = X509_NAME_get_entry(name, i);
1275 if (e == NULL)
1276 continue;
1277 cn = X509_NAME_ENTRY_get_data(e);
1278 if (cn == NULL)
1279 continue;
1280 wpa_hexdump_ascii(MSG_DEBUG, "TLS: Certificate commonName",
1281 cn->data, cn->length);
cebee30f
JM		 1282 if (domain_suffix_match(cn->data, cn->length, match, full) == 1)
1283 {
1284 wpa_printf(MSG_DEBUG, "TLS: %s in commonName found",
1285 full ? "Match" : "Suffix match");
01f809c7
JM		 1286 return 1;
1287 }
1288 }
1289
cebee30f
JM		 1290 wpa_printf(MSG_DEBUG, "TLS: No CommonName %smatch found",
1291 full ? "": "suffix ");
01f809c7 1292 return 0;
461e3ebe 1293#endif /* CONFIG_NATIVE_WINDOWS */
01f809c7
JM		 1294}
1295
1296
00468b46
JM		 1297static enum tls_fail_reason openssl_tls_fail_reason(int err)
1298{
1299 switch (err) {
1300 case X509_V_ERR_CERT_REVOKED:
1301 return TLS_FAIL_REVOKED;
1302 case X509_V_ERR_CERT_NOT_YET_VALID:
1303 case X509_V_ERR_CRL_NOT_YET_VALID:
1304 return TLS_FAIL_NOT_YET_VALID;
1305 case X509_V_ERR_CERT_HAS_EXPIRED:
1306 case X509_V_ERR_CRL_HAS_EXPIRED:
1307 return TLS_FAIL_EXPIRED;
1308 case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT:
1309 case X509_V_ERR_UNABLE_TO_GET_CRL:
1310 case X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER:
1311 case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
1312 case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
1313 case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
1314 case X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE:
1315 case X509_V_ERR_CERT_CHAIN_TOO_LONG:
1316 case X509_V_ERR_PATH_LENGTH_EXCEEDED:
1317 case X509_V_ERR_INVALID_CA:
1318 return TLS_FAIL_UNTRUSTED;
1319 case X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE:
1320 case X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE:
1321 case X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY:
1322 case X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD:
1323 case X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD:
1324 case X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD:
1325 case X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD:
1326 case X509_V_ERR_CERT_UNTRUSTED:
1327 case X509_V_ERR_CERT_REJECTED:
1328 return TLS_FAIL_BAD_CERTIFICATE;
1329 default:
1330 return TLS_FAIL_UNSPECIFIED;
1331 }
1332}
1333
1334
1335static struct wpabuf * get_x509_cert(X509 *cert)
1336{
1337 struct wpabuf *buf;
1338 u8 *tmp;
1339
1340 int cert_len = i2d_X509(cert, NULL);
1341 if (cert_len <= 0)
1342 return NULL;
1343
1344 buf = wpabuf_alloc(cert_len);
1345 if (buf == NULL)
1346 return NULL;
1347
1348 tmp = wpabuf_put(buf, cert_len);
1349 i2d_X509(cert, &tmp);
1350 return buf;
1351}
1352
1353
1354static void openssl_tls_fail_event(struct tls_connection *conn,
1355 X509 *err_cert, int err, int depth,
1356 const char *subject, const char *err_str,
1357 enum tls_fail_reason reason)
1358{
1359 union tls_event_data ev;
1360 struct wpabuf *cert = NULL;
7c0e1e27 1361 struct tls_context *context = conn->context;
00468b46 1362
7c0e1e27 1363 if (context->event_cb == NULL)
00468b46
JM		 1364 return;
1365
1366 cert = get_x509_cert(err_cert);
1367 os_memset(&ev, 0, sizeof(ev));
1368 ev.cert_fail.reason = reason != TLS_FAIL_UNSPECIFIED ?
1369 reason : openssl_tls_fail_reason(err);
1370 ev.cert_fail.depth = depth;
1371 ev.cert_fail.subject = subject;
1372 ev.cert_fail.reason_txt = err_str;
1373 ev.cert_fail.cert = cert;
7c0e1e27 1374 context->event_cb(context->cb_ctx, TLS_CERT_CHAIN_FAILURE, &ev);
00468b46
JM		 1375 wpabuf_free(cert);
1376}
1377
1378
1379static void openssl_tls_cert_event(struct tls_connection *conn,
1380 X509 *err_cert, int depth,
1381 const char *subject)
1382{
1383 struct wpabuf *cert = NULL;
1384 union tls_event_data ev;
7c0e1e27 1385 struct tls_context *context = conn->context;
d07d3fbd
JM		 1386 char *altsubject[TLS_MAX_ALT_SUBJECT];
1387 int alt, num_altsubject = 0;
1388 GENERAL_NAME *gen;
1389 void *ext;
1390 stack_index_t i;
00468b46
JM		 1391#ifdef CONFIG_SHA256
1392 u8 hash[32];
1393#endif /* CONFIG_SHA256 */
1394
7c0e1e27 1395 if (context->event_cb == NULL)
00468b46
JM		 1396 return;
1397
1398 os_memset(&ev, 0, sizeof(ev));
7c0e1e27 1399 if (conn->cert_probe || context->cert_in_cb) {
00468b46
JM		 1400 cert = get_x509_cert(err_cert);
1401 ev.peer_cert.cert = cert;
1402 }
1403#ifdef CONFIG_SHA256
1404 if (cert) {
1405 const u8 *addr[1];
1406 size_t len[1];
1407 addr[0] = wpabuf_head(cert);
1408 len[0] = wpabuf_len(cert);
1409 if (sha256_vector(1, addr, len, hash) == 0) {
1410 ev.peer_cert.hash = hash;
1411 ev.peer_cert.hash_len = sizeof(hash);
1412 }
1413 }
1414#endif /* CONFIG_SHA256 */
1415 ev.peer_cert.depth = depth;
1416 ev.peer_cert.subject = subject;
d07d3fbd
JM		 1417
1418 ext = X509_get_ext_d2i(err_cert, NID_subject_alt_name, NULL, NULL);
1419 for (i = 0; ext && i < sk_GENERAL_NAME_num(ext); i++) {
1420 char *pos;
1421
1422 if (num_altsubject == TLS_MAX_ALT_SUBJECT)
1423 break;
1424 gen = sk_GENERAL_NAME_value(ext, i);
1425 if (gen->type != GEN_EMAIL &&
1426 gen->type != GEN_DNS &&
1427 gen->type != GEN_URI)
1428 continue;
1429
1430 pos = os_malloc(10 + gen->d.ia5->length + 1);
1431 if (pos == NULL)
1432 break;
1433 altsubject[num_altsubject++] = pos;
1434
1435 switch (gen->type) {
1436 case GEN_EMAIL:
1437 os_memcpy(pos, "EMAIL:", 6);
1438 pos += 6;
1439 break;
1440 case GEN_DNS:
1441 os_memcpy(pos, "DNS:", 4);
1442 pos += 4;
1443 break;
1444 case GEN_URI:
1445 os_memcpy(pos, "URI:", 4);
1446 pos += 4;
1447 break;
1448 }
1449
1450 os_memcpy(pos, gen->d.ia5->data, gen->d.ia5->length);
1451 pos += gen->d.ia5->length;
1452 *pos = '\0';
1453 }
1454
1455 for (alt = 0; alt < num_altsubject; alt++)
1456 ev.peer_cert.altsubject[alt] = altsubject[alt];
1457 ev.peer_cert.num_altsubject = num_altsubject;
1458
7c0e1e27 1459 context->event_cb(context->cb_ctx, TLS_PEER_CERTIFICATE, &ev);
00468b46 1460 wpabuf_free(cert);
d07d3fbd
JM		 1461 for (alt = 0; alt < num_altsubject; alt++)
1462 os_free(altsubject[alt]);
00468b46
JM		 1463}
1464
1465
6fc6879b
JM		 1466static int tls_verify_cb(int preverify_ok, X509_STORE_CTX *x509_ctx)
1467{
1468 char buf[256];
1469 X509 *err_cert;
1470 int err, depth;
1471 SSL *ssl;
1472 struct tls_connection *conn;
7c0e1e27 1473 struct tls_context *context;
cebee30f 1474 char *match, *altmatch, *suffix_match, *domain_match;
00468b46 1475 const char *err_str;
6fc6879b
JM		 1476
1477 err_cert = X509_STORE_CTX_get_current_cert(x509_ctx);
97efe70b
EL		 1478 if (!err_cert)
1479 return 0;
1480
6fc6879b
JM		 1481 err = X509_STORE_CTX_get_error(x509_ctx);
1482 depth = X509_STORE_CTX_get_error_depth(x509_ctx);
1483 ssl = X509_STORE_CTX_get_ex_data(x509_ctx,
1484 SSL_get_ex_data_X509_STORE_CTX_idx());
1485 X509_NAME_oneline(X509_get_subject_name(err_cert), buf, sizeof(buf));
1486
1487 conn = SSL_get_app_data(ssl);
0bdaa741
JM		 1488 if (conn == NULL)
1489 return 0;
080585c0
JM		 1490
1491 if (depth == 0)
1492 conn->peer_cert = err_cert;
1493 else if (depth == 1)
1494 conn->peer_issuer = err_cert;
6bf61fb2
JM		 1495 else if (depth == 2)
1496 conn->peer_issuer_issuer = err_cert;
080585c0 1497
7c0e1e27 1498 context = conn->context;
0bdaa741
JM		 1499 match = conn->subject_match;
1500 altmatch = conn->altsubject_match;
01f809c7 1501 suffix_match = conn->suffix_match;
cebee30f 1502 domain_match = conn->domain_match;
6fc6879b 1503
00468b46
JM		 1504 if (!preverify_ok && !conn->ca_cert_verify)
1505 preverify_ok = 1;
1506 if (!preverify_ok && depth > 0 && conn->server_cert_only)
1507 preverify_ok = 1;
235279e7
JM		 1508 if (!preverify_ok && (conn->flags & TLS_CONN_DISABLE_TIME_CHECKS) &&
1509 (err == X509_V_ERR_CERT_HAS_EXPIRED ||
1510 err == X509_V_ERR_CERT_NOT_YET_VALID)) {
1511 wpa_printf(MSG_DEBUG, "OpenSSL: Ignore certificate validity "
1512 "time mismatch");
1513 preverify_ok = 1;
1514 }
00468b46
JM		 1515
1516 err_str = X509_verify_cert_error_string(err);
1517
1518#ifdef CONFIG_SHA256
00033a09
RA		 1519 /*
1520 * Do not require preverify_ok so we can explicity allow otherwise
1521 * invalid pinned server certificates.
1522 */
1523 if (depth == 0 && conn->server_cert_only) {
00468b46
JM		 1524 struct wpabuf *cert;
1525 cert = get_x509_cert(err_cert);
1526 if (!cert) {
1527 wpa_printf(MSG_DEBUG, "OpenSSL: Could not fetch "
1528 "server certificate data");
6fc6879b 1529 preverify_ok = 0;
00468b46
JM		 1530 } else {
1531 u8 hash[32];
1532 const u8 *addr[1];
1533 size_t len[1];
1534 addr[0] = wpabuf_head(cert);
1535 len[0] = wpabuf_len(cert);
1536 if (sha256_vector(1, addr, len, hash) < 0 ||
1537 os_memcmp(conn->srv_cert_hash, hash, 32) != 0) {
1538 err_str = "Server certificate mismatch";
1539 err = X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN;
1540 preverify_ok = 0;
00033a09
RA		 1541 } else if (!preverify_ok) {
1542 /*
1543 * Certificate matches pinned certificate, allow
1544 * regardless of other problems.
1545 */
1546 wpa_printf(MSG_DEBUG,
1547 "OpenSSL: Ignore validation issues for a pinned server certificate");
1548 preverify_ok = 1;
00468b46
JM		 1549 }
1550 wpabuf_free(cert);
6fc6879b
JM		 1551 }
1552 }
00468b46
JM		 1553#endif /* CONFIG_SHA256 */
1554
1555 if (!preverify_ok) {
1556 wpa_printf(MSG_WARNING, "TLS: Certificate verification failed,"
1557 " error %d (%s) depth %d for '%s'", err, err_str,
1558 depth, buf);
1559 openssl_tls_fail_event(conn, err_cert, err, depth, buf,
1560 err_str, TLS_FAIL_UNSPECIFIED);
1561 return preverify_ok;
1562 }
1563
1564 wpa_printf(MSG_DEBUG, "TLS: tls_verify_cb - preverify_ok=%d "
1565 "err=%d (%s) ca_cert_verify=%d depth=%d buf='%s'",
1566 preverify_ok, err, err_str,
1567 conn->ca_cert_verify, depth, buf);
1568 if (depth == 0 && match && os_strstr(buf, match) == NULL) {
1569 wpa_printf(MSG_WARNING, "TLS: Subject '%s' did not "
1570 "match with '%s'", buf, match);
1571 preverify_ok = 0;
1572 openssl_tls_fail_event(conn, err_cert, err, depth, buf,
1573 "Subject mismatch",
1574 TLS_FAIL_SUBJECT_MISMATCH);
1575 } else if (depth == 0 && altmatch &&
1576 !tls_match_altsubject(err_cert, altmatch)) {
1577 wpa_printf(MSG_WARNING, "TLS: altSubjectName match "
1578 "'%s' not found", altmatch);
1579 preverify_ok = 0;
1580 openssl_tls_fail_event(conn, err_cert, err, depth, buf,
1581 "AltSubject mismatch",
1582 TLS_FAIL_ALTSUBJECT_MISMATCH);
01f809c7 1583 } else if (depth == 0 && suffix_match &&
cebee30f 1584 !tls_match_suffix(err_cert, suffix_match, 0)) {
01f809c7
JM		 1585 wpa_printf(MSG_WARNING, "TLS: Domain suffix match '%s' not found",
1586 suffix_match);
1587 preverify_ok = 0;
1588 openssl_tls_fail_event(conn, err_cert, err, depth, buf,
1589 "Domain suffix mismatch",
1590 TLS_FAIL_DOMAIN_SUFFIX_MISMATCH);
cebee30f
JM		 1591 } else if (depth == 0 && domain_match &&
1592 !tls_match_suffix(err_cert, domain_match, 1)) {
1593 wpa_printf(MSG_WARNING, "TLS: Domain match '%s' not found",
1594 domain_match);
1595 preverify_ok = 0;
1596 openssl_tls_fail_event(conn, err_cert, err, depth, buf,
1597 "Domain mismatch",
1598 TLS_FAIL_DOMAIN_MISMATCH);
00468b46
JM		 1599 } else
1600 openssl_tls_cert_event(conn, err_cert, depth, buf);
1601
1602 if (conn->cert_probe && preverify_ok && depth == 0) {
1603 wpa_printf(MSG_DEBUG, "OpenSSL: Reject server certificate "
1604 "on probe-only run");
1605 preverify_ok = 0;
1606 openssl_tls_fail_event(conn, err_cert, err, depth, buf,
1607 "Server certificate chain probe",
1608 TLS_FAIL_SERVER_CHAIN_PROBE);
1609 }
6fc6879b 1610
7c0e1e27
PS		 1611 if (preverify_ok && context->event_cb != NULL)
1612 context->event_cb(context->cb_ctx,
1613 TLS_CERT_CHAIN_SUCCESS, NULL);
dd7fec1f 1614
6fc6879b
JM		 1615 return preverify_ok;
1616}
1617
1618
1619#ifndef OPENSSL_NO_STDIO
1620static int tls_load_ca_der(void *_ssl_ctx, const char *ca_cert)
1621{
1622 SSL_CTX *ssl_ctx = _ssl_ctx;
1623 X509_LOOKUP *lookup;
1624 int ret = 0;
1625
68ae4773 1626 lookup = X509_STORE_add_lookup(SSL_CTX_get_cert_store(ssl_ctx),
6fc6879b
JM		 1627 X509_LOOKUP_file());
1628 if (lookup == NULL) {
1629 tls_show_errors(MSG_WARNING, __func__,
1630 "Failed add lookup for X509 store");
1631 return -1;
1632 }
1633
1634 if (!X509_LOOKUP_load_file(lookup, ca_cert, X509_FILETYPE_ASN1)) {
1635 unsigned long err = ERR_peek_error();
1636 tls_show_errors(MSG_WARNING, __func__,
1637 "Failed load CA in DER format");
1638 if (ERR_GET_LIB(err) == ERR_LIB_X509 &&
1639 ERR_GET_REASON(err) == X509_R_CERT_ALREADY_IN_HASH_TABLE) {
1640 wpa_printf(MSG_DEBUG, "OpenSSL: %s - ignoring "
1641 "cert already in hash table error",
1642 __func__);
1643 } else
1644 ret = -1;
1645 }
1646
1647 return ret;
1648}
1649#endif /* OPENSSL_NO_STDIO */
1650
1651
1652static int tls_connection_ca_cert(void *_ssl_ctx, struct tls_connection *conn,
1653 const char *ca_cert, const u8 *ca_cert_blob,
1654 size_t ca_cert_blob_len, const char *ca_path)
1655{
1656 SSL_CTX *ssl_ctx = _ssl_ctx;
68ae4773 1657 X509_STORE *store;
6fc6879b
JM		 1658
1659 /*
1660 * Remove previously configured trusted CA certificates before adding
1661 * new ones.
1662 */
68ae4773
JM		 1663 store = X509_STORE_new();
1664 if (store == NULL) {
6fc6879b
JM		 1665 wpa_printf(MSG_DEBUG, "OpenSSL: %s - failed to allocate new "
1666 "certificate store", __func__);
1667 return -1;
1668 }
68ae4773 1669 SSL_CTX_set_cert_store(ssl_ctx, store);
6fc6879b 1670
00468b46
JM		 1671 SSL_set_verify(conn->ssl, SSL_VERIFY_PEER, tls_verify_cb);
1672 conn->ca_cert_verify = 1;
1673
1674 if (ca_cert && os_strncmp(ca_cert, "probe://", 8) == 0) {
1675 wpa_printf(MSG_DEBUG, "OpenSSL: Probe for server certificate "
1676 "chain");
1677 conn->cert_probe = 1;
1678 conn->ca_cert_verify = 0;
1679 return 0;
1680 }
1681
1682 if (ca_cert && os_strncmp(ca_cert, "hash://", 7) == 0) {
1683#ifdef CONFIG_SHA256
1684 const char *pos = ca_cert + 7;
1685 if (os_strncmp(pos, "server/sha256/", 14) != 0) {
1686 wpa_printf(MSG_DEBUG, "OpenSSL: Unsupported ca_cert "
1687 "hash value '%s'", ca_cert);
1688 return -1;
1689 }
1690 pos += 14;
1691 if (os_strlen(pos) != 32 * 2) {
1692 wpa_printf(MSG_DEBUG, "OpenSSL: Unexpected SHA256 "
1693 "hash length in ca_cert '%s'", ca_cert);
1694 return -1;
1695 }
1696 if (hexstr2bin(pos, conn->srv_cert_hash, 32) < 0) {
1697 wpa_printf(MSG_DEBUG, "OpenSSL: Invalid SHA256 hash "
1698 "value in ca_cert '%s'", ca_cert);
1699 return -1;
1700 }
1701 conn->server_cert_only = 1;
1702 wpa_printf(MSG_DEBUG, "OpenSSL: Checking only server "
1703 "certificate match");
1704 return 0;
1705#else /* CONFIG_SHA256 */
1706 wpa_printf(MSG_INFO, "No SHA256 included in the build - "
1707 "cannot validate server certificate hash");
1708 return -1;
1709#endif /* CONFIG_SHA256 */
1710 }
1711
6fc6879b 1712 if (ca_cert_blob) {
fee31f76
JM		 1713 X509 *cert = d2i_X509(NULL,
1714 (const unsigned char **) &ca_cert_blob,
6fc6879b
JM		 1715 ca_cert_blob_len);
1716 if (cert == NULL) {
1717 tls_show_errors(MSG_WARNING, __func__,
1718 "Failed to parse ca_cert_blob");
1719 return -1;
1720 }
1721
68ae4773
JM		 1722 if (!X509_STORE_add_cert(SSL_CTX_get_cert_store(ssl_ctx),
1723 cert)) {
6fc6879b
JM		 1724 unsigned long err = ERR_peek_error();
1725 tls_show_errors(MSG_WARNING, __func__,
1726 "Failed to add ca_cert_blob to "
1727 "certificate store");
1728 if (ERR_GET_LIB(err) == ERR_LIB_X509 &&
1729 ERR_GET_REASON(err) ==
1730 X509_R_CERT_ALREADY_IN_HASH_TABLE) {
1731 wpa_printf(MSG_DEBUG, "OpenSSL: %s - ignoring "
1732 "cert already in hash table error",
1733 __func__);
1734 } else {
1735 X509_free(cert);
1736 return -1;
1737 }
1738 }
1739 X509_free(cert);
1740 wpa_printf(MSG_DEBUG, "OpenSSL: %s - added ca_cert_blob "
1741 "to certificate store", __func__);
6fc6879b
JM		 1742 return 0;
1743 }
1744
2a0cd067
DS		 1745#ifdef ANDROID
1746 if (ca_cert && os_strncmp("keystore://", ca_cert, 11) == 0) {
1747 BIO *bio = BIO_from_keystore(&ca_cert[11]);
1748 STACK_OF(X509_INFO) *stack = NULL;
a8572960 1749 stack_index_t i;
2a0cd067
DS		 1750
1751 if (bio) {
1752 stack = PEM_X509_INFO_read_bio(bio, NULL, NULL, NULL);
1753 BIO_free(bio);
1754 }
1755 if (!stack)
1756 return -1;
1757
1758 for (i = 0; i < sk_X509_INFO_num(stack); ++i) {
1759 X509_INFO *info = sk_X509_INFO_value(stack, i);
1760 if (info->x509) {
1761 X509_STORE_add_cert(ssl_ctx->cert_store,
1762 info->x509);
1763 }
1764 if (info->crl) {
1765 X509_STORE_add_crl(ssl_ctx->cert_store,
1766 info->crl);
1767 }
1768 }
1769 sk_X509_INFO_pop_free(stack, X509_INFO_free);
1770 SSL_set_verify(conn->ssl, SSL_VERIFY_PEER, tls_verify_cb);
1771 return 0;
1772 }
1773#endif /* ANDROID */
1774
6fc6879b
JM		 1775#ifdef CONFIG_NATIVE_WINDOWS
1776 if (ca_cert && tls_cryptoapi_ca_cert(ssl_ctx, conn->ssl, ca_cert) ==
1777 0) {
1778 wpa_printf(MSG_DEBUG, "OpenSSL: Added CA certificates from "
1779 "system certificate store");
6fc6879b
JM		 1780 return 0;
1781 }
1782#endif /* CONFIG_NATIVE_WINDOWS */
1783
1784 if (ca_cert || ca_path) {
1785#ifndef OPENSSL_NO_STDIO
1786 if (SSL_CTX_load_verify_locations(ssl_ctx, ca_cert, ca_path) !=
1787 1) {
1788 tls_show_errors(MSG_WARNING, __func__,
1789 "Failed to load root certificates");
1790 if (ca_cert &&
1791 tls_load_ca_der(ssl_ctx, ca_cert) == 0) {
1792 wpa_printf(MSG_DEBUG, "OpenSSL: %s - loaded "
1793 "DER format CA certificate",
1794 __func__);
1795 } else
1796 return -1;
1797 } else {
1798 wpa_printf(MSG_DEBUG, "TLS: Trusted root "
1799 "certificate(s) loaded");
1800 tls_get_errors(ssl_ctx);
1801 }
6fc6879b
JM		 1802#else /* OPENSSL_NO_STDIO */
1803 wpa_printf(MSG_DEBUG, "OpenSSL: %s - OPENSSL_NO_STDIO",
1804 __func__);
1805 return -1;
1806#endif /* OPENSSL_NO_STDIO */
1807 } else {
1808 /* No ca_cert configured - do not try to verify server
1809 * certificate */
00468b46 1810 conn->ca_cert_verify = 0;
6fc6879b
JM		 1811 }
1812
1813 return 0;
1814}
1815
1816
1817static int tls_global_ca_cert(SSL_CTX *ssl_ctx, const char *ca_cert)
1818{
1819 if (ca_cert) {
1820 if (SSL_CTX_load_verify_locations(ssl_ctx, ca_cert, NULL) != 1)
1821 {
1822 tls_show_errors(MSG_WARNING, __func__,
1823 "Failed to load root certificates");
1824 return -1;
1825 }
1826
1827 wpa_printf(MSG_DEBUG, "TLS: Trusted root "
1828 "certificate(s) loaded");
1829
1830#ifndef OPENSSL_NO_STDIO
1831 /* Add the same CAs to the client certificate requests */
1832 SSL_CTX_set_client_CA_list(ssl_ctx,
1833 SSL_load_client_CA_file(ca_cert));
1834#endif /* OPENSSL_NO_STDIO */
1835 }
1836
1837 return 0;
1838}
1839
1840
1841int tls_global_set_verify(void *ssl_ctx, int check_crl)
1842{
1843 int flags;
1844
1845 if (check_crl) {
1846 X509_STORE *cs = SSL_CTX_get_cert_store(ssl_ctx);
1847 if (cs == NULL) {
1848 tls_show_errors(MSG_INFO, __func__, "Failed to get "
1849 "certificate store when enabling "
1850 "check_crl");
1851 return -1;
1852 }
1853 flags = X509_V_FLAG_CRL_CHECK;
1854 if (check_crl == 2)
1855 flags |= X509_V_FLAG_CRL_CHECK_ALL;
1856 X509_STORE_set_flags(cs, flags);
1857 }
1858 return 0;
1859}
1860
1861
1862static int tls_connection_set_subject_match(struct tls_connection *conn,
1863 const char *subject_match,
01f809c7 1864 const char *altsubject_match,
cebee30f
JM		 1865 const char *suffix_match,
1866 const char *domain_match)
6fc6879b
JM		 1867{
1868 os_free(conn->subject_match);
1869 conn->subject_match = NULL;
1870 if (subject_match) {
1871 conn->subject_match = os_strdup(subject_match);
1872 if (conn->subject_match == NULL)
1873 return -1;
1874 }
1875
1876 os_free(conn->altsubject_match);
1877 conn->altsubject_match = NULL;
1878 if (altsubject_match) {
1879 conn->altsubject_match = os_strdup(altsubject_match);
1880 if (conn->altsubject_match == NULL)
1881 return -1;
1882 }
1883
01f809c7
JM		 1884 os_free(conn->suffix_match);
1885 conn->suffix_match = NULL;
1886 if (suffix_match) {
1887 conn->suffix_match = os_strdup(suffix_match);
1888 if (conn->suffix_match == NULL)
1889 return -1;
1890 }
1891
cebee30f
JM		 1892 os_free(conn->domain_match);
1893 conn->domain_match = NULL;
1894 if (domain_match) {
1895 conn->domain_match = os_strdup(domain_match);
1896 if (conn->domain_match == NULL)
1897 return -1;
1898 }
1899
6fc6879b
JM		 1900 return 0;
1901}
1902
1903
1904int tls_connection_set_verify(void *ssl_ctx, struct tls_connection *conn,
1905 int verify_peer)
1906{
bf206cad
JM		 1907 static int counter = 0;
1908
6fc6879b
JM		 1909 if (conn == NULL)
1910 return -1;
1911
1912 if (verify_peer) {
00468b46 1913 conn->ca_cert_verify = 1;
6fc6879b
JM		 1914 SSL_set_verify(conn->ssl, SSL_VERIFY_PEER |
1915 SSL_VERIFY_FAIL_IF_NO_PEER_CERT |
1916 SSL_VERIFY_CLIENT_ONCE, tls_verify_cb);
1917 } else {
00468b46 1918 conn->ca_cert_verify = 0;
6fc6879b
JM		 1919 SSL_set_verify(conn->ssl, SSL_VERIFY_NONE, NULL);
1920 }
1921
1922 SSL_set_accept_state(conn->ssl);
1923
bf206cad
JM		 1924 /*
1925 * Set session id context in order to avoid fatal errors when client
1926 * tries to resume a session. However, set the context to a unique
1927 * value in order to effectively disable session resumption for now
1928 * since not all areas of the server code are ready for it (e.g.,
1929 * EAP-TTLS needs special handling for Phase 2 after abbreviated TLS
1930 * handshake).
1931 */
1932 counter++;
1933 SSL_set_session_id_context(conn->ssl,
1934 (const unsigned char *) &counter,
1935 sizeof(counter));
1936
6fc6879b
JM		 1937 return 0;
1938}
1939
1940
1941static int tls_connection_client_cert(struct tls_connection *conn,
1942 const char *client_cert,
1943 const u8 *client_cert_blob,
1944 size_t client_cert_blob_len)
1945{
1946 if (client_cert == NULL && client_cert_blob == NULL)
1947 return 0;
1948
1949 if (client_cert_blob &&
1950 SSL_use_certificate_ASN1(conn->ssl, (u8 *) client_cert_blob,
1951 client_cert_blob_len) == 1) {
1952 wpa_printf(MSG_DEBUG, "OpenSSL: SSL_use_certificate_ASN1 --> "
1953 "OK");
1954 return 0;
1955 } else if (client_cert_blob) {
1956 tls_show_errors(MSG_DEBUG, __func__,
1957 "SSL_use_certificate_ASN1 failed");
1958 }
1959
1960 if (client_cert == NULL)
1961 return -1;
1962
2a0cd067
DS		 1963#ifdef ANDROID
1964 if (os_strncmp("keystore://", client_cert, 11) == 0) {
1965 BIO *bio = BIO_from_keystore(&client_cert[11]);
1966 X509 *x509 = NULL;
1967 int ret = -1;
1968 if (bio) {
1969 x509 = PEM_read_bio_X509(bio, NULL, NULL, NULL);
1970 BIO_free(bio);
1971 }
1972 if (x509) {
1973 if (SSL_use_certificate(conn->ssl, x509) == 1)
1974 ret = 0;
1975 X509_free(x509);
1976 }
1977 return ret;
1978 }
1979#endif /* ANDROID */
1980
6fc6879b
JM		 1981#ifndef OPENSSL_NO_STDIO
1982 if (SSL_use_certificate_file(conn->ssl, client_cert,
1983 SSL_FILETYPE_ASN1) == 1) {
1984 wpa_printf(MSG_DEBUG, "OpenSSL: SSL_use_certificate_file (DER)"
1985 " --> OK");
1986 return 0;
6fc6879b
JM		 1987 }
1988
1989 if (SSL_use_certificate_file(conn->ssl, client_cert,
1990 SSL_FILETYPE_PEM) == 1) {
effab86f 1991 ERR_clear_error();
6fc6879b
JM		 1992 wpa_printf(MSG_DEBUG, "OpenSSL: SSL_use_certificate_file (PEM)"
1993 " --> OK");
1994 return 0;
6fc6879b 1995 }
effab86f
JM		 1996
1997 tls_show_errors(MSG_DEBUG, __func__,
1998 "SSL_use_certificate_file failed");
6fc6879b
JM		 1999#else /* OPENSSL_NO_STDIO */
2000 wpa_printf(MSG_DEBUG, "OpenSSL: %s - OPENSSL_NO_STDIO", __func__);
2001#endif /* OPENSSL_NO_STDIO */
2002
2003 return -1;
2004}
2005
2006
2007static int tls_global_client_cert(SSL_CTX *ssl_ctx, const char *client_cert)
2008{
2009#ifndef OPENSSL_NO_STDIO
2010 if (client_cert == NULL)
2011 return 0;
2012
2013 if (SSL_CTX_use_certificate_file(ssl_ctx, client_cert,
2014 SSL_FILETYPE_ASN1) != 1 &&
65897747 2015 SSL_CTX_use_certificate_chain_file(ssl_ctx, client_cert) != 1 &&
6fc6879b
JM		 2016 SSL_CTX_use_certificate_file(ssl_ctx, client_cert,
2017 SSL_FILETYPE_PEM) != 1) {
2018 tls_show_errors(MSG_INFO, __func__,
2019 "Failed to load client certificate");
2020 return -1;
2021 }
2022 return 0;
2023#else /* OPENSSL_NO_STDIO */
2024 if (client_cert == NULL)
2025 return 0;
2026 wpa_printf(MSG_DEBUG, "OpenSSL: %s - OPENSSL_NO_STDIO", __func__);
2027 return -1;
2028#endif /* OPENSSL_NO_STDIO */
2029}
2030
2031
2032static int tls_passwd_cb(char *buf, int size, int rwflag, void *password)
2033{
2034 if (password == NULL) {
2035 return 0;
2036 }
2037 os_strlcpy(buf, (char *) password, size);
2038 return os_strlen(buf);
2039}
2040
2041
2042#ifdef PKCS12_FUNCS
2043static int tls_parse_pkcs12(SSL_CTX *ssl_ctx, SSL *ssl, PKCS12 *p12,
2044 const char *passwd)
2045{
2046 EVP_PKEY *pkey;
2047 X509 *cert;
2048 STACK_OF(X509) *certs;
2049 int res = 0;
2050 char buf[256];
2051
2052 pkey = NULL;
2053 cert = NULL;
2054 certs = NULL;
2055 if (!PKCS12_parse(p12, passwd, &pkey, &cert, &certs)) {
2056 tls_show_errors(MSG_DEBUG, __func__,
2057 "Failed to parse PKCS12 file");
2058 PKCS12_free(p12);
2059 return -1;
2060 }
2061 wpa_printf(MSG_DEBUG, "TLS: Successfully parsed PKCS12 data");
2062
2063 if (cert) {
2064 X509_NAME_oneline(X509_get_subject_name(cert), buf,
2065 sizeof(buf));
2066 wpa_printf(MSG_DEBUG, "TLS: Got certificate from PKCS12: "
2067 "subject='%s'", buf);
2068 if (ssl) {
2069 if (SSL_use_certificate(ssl, cert) != 1)
2070 res = -1;
2071 } else {
2072 if (SSL_CTX_use_certificate(ssl_ctx, cert) != 1)
2073 res = -1;
2074 }
2075 X509_free(cert);
2076 }
2077
2078 if (pkey) {
2079 wpa_printf(MSG_DEBUG, "TLS: Got private key from PKCS12");
2080 if (ssl) {
2081 if (SSL_use_PrivateKey(ssl, pkey) != 1)
2082 res = -1;
2083 } else {
2084 if (SSL_CTX_use_PrivateKey(ssl_ctx, pkey) != 1)
2085 res = -1;
2086 }
2087 EVP_PKEY_free(pkey);
2088 }
2089
2090 if (certs) {
2091 while ((cert = sk_X509_pop(certs)) != NULL) {
2092 X509_NAME_oneline(X509_get_subject_name(cert), buf,
2093 sizeof(buf));
2094 wpa_printf(MSG_DEBUG, "TLS: additional certificate"
2095 " from PKCS12: subject='%s'", buf);
2096 /*
2097 * There is no SSL equivalent for the chain cert - so
2098 * always add it to the context...
2099 */
2100 if (SSL_CTX_add_extra_chain_cert(ssl_ctx, cert) != 1) {
2101 res = -1;
2102 break;
2103 }
2104 }
2105 sk_X509_free(certs);
2106 }
2107
2108 PKCS12_free(p12);
2109
2110 if (res < 0)
2111 tls_get_errors(ssl_ctx);
2112
2113 return res;
2114}
2115#endif /* PKCS12_FUNCS */
2116
2117
2118static int tls_read_pkcs12(SSL_CTX *ssl_ctx, SSL *ssl, const char *private_key,
2119 const char *passwd)
2120{
2121#ifdef PKCS12_FUNCS
2122 FILE *f;
2123 PKCS12 *p12;
2124
2125 f = fopen(private_key, "rb");
2126 if (f == NULL)
2127 return -1;
2128
2129 p12 = d2i_PKCS12_fp(f, NULL);
2130 fclose(f);
2131
2132 if (p12 == NULL) {
2133 tls_show_errors(MSG_INFO, __func__,
2134 "Failed to use PKCS#12 file");
2135 return -1;
2136 }
2137
2138 return tls_parse_pkcs12(ssl_ctx, ssl, p12, passwd);
2139
2140#else /* PKCS12_FUNCS */
2141 wpa_printf(MSG_INFO, "TLS: PKCS12 support disabled - cannot read "
2142 "p12/pfx files");
2143 return -1;
2144#endif /* PKCS12_FUNCS */
2145}
2146
2147
2148static int tls_read_pkcs12_blob(SSL_CTX *ssl_ctx, SSL *ssl,
2149 const u8 *blob, size_t len, const char *passwd)
2150{
2151#ifdef PKCS12_FUNCS
2152 PKCS12 *p12;
2153
fee31f76 2154 p12 = d2i_PKCS12(NULL, (const unsigned char **) &blob, len);
6fc6879b
JM		 2155 if (p12 == NULL) {
2156 tls_show_errors(MSG_INFO, __func__,
2157 "Failed to use PKCS#12 blob");
2158 return -1;
2159 }
2160
2161 return tls_parse_pkcs12(ssl_ctx, ssl, p12, passwd);
2162
2163#else /* PKCS12_FUNCS */
2164 wpa_printf(MSG_INFO, "TLS: PKCS12 support disabled - cannot parse "
2165 "p12/pfx blobs");
2166 return -1;
2167#endif /* PKCS12_FUNCS */
2168}
2169
2170
e572cb63 2171#ifndef OPENSSL_NO_ENGINE
e59c91af
DS		 2172static int tls_engine_get_cert(struct tls_connection *conn,
2173 const char *cert_id,
2174 X509 **cert)
2175{
e59c91af
DS		 2176 /* this runs after the private key is loaded so no PIN is required */
2177 struct {
2178 const char *cert_id;
2179 X509 *cert;
2180 } params;
2181 params.cert_id = cert_id;
2182 params.cert = NULL;
2183
2184 if (!ENGINE_ctrl_cmd(conn->engine, "LOAD_CERT_CTRL",
2185 0, &params, NULL, 1)) {
2186 wpa_printf(MSG_ERROR, "ENGINE: cannot load client cert with id"
2187 " '%s' [%s]", cert_id,
2188 ERR_error_string(ERR_get_error(), NULL));
2189 return TLS_SET_PARAMS_ENGINE_PRV_INIT_FAILED;
2190 }
2191 if (!params.cert) {
2192 wpa_printf(MSG_ERROR, "ENGINE: did not properly cert with id"
2193 " '%s'", cert_id);
2194 return TLS_SET_PARAMS_ENGINE_PRV_INIT_FAILED;
2195 }
2196 *cert = params.cert;
2197 return 0;
e59c91af 2198}
e572cb63 2199#endif /* OPENSSL_NO_ENGINE */
e59c91af
DS		 2200
2201
2202static int tls_connection_engine_client_cert(struct tls_connection *conn,
2203 const char *cert_id)
2204{
2205#ifndef OPENSSL_NO_ENGINE
2206 X509 *cert;
2207
2208 if (tls_engine_get_cert(conn, cert_id, &cert))
2209 return -1;
2210
2211 if (!SSL_use_certificate(conn->ssl, cert)) {
2212 tls_show_errors(MSG_ERROR, __func__,
2213 "SSL_use_certificate failed");
2214 X509_free(cert);
2215 return -1;
2216 }
2217 X509_free(cert);
2218 wpa_printf(MSG_DEBUG, "ENGINE: SSL_use_certificate --> "
2219 "OK");
2220 return 0;
2221
2222#else /* OPENSSL_NO_ENGINE */
2223 return -1;
2224#endif /* OPENSSL_NO_ENGINE */
2225}
2226
2227
2228static int tls_connection_engine_ca_cert(void *_ssl_ctx,
2229 struct tls_connection *conn,
2230 const char *ca_cert_id)
2231{
2232#ifndef OPENSSL_NO_ENGINE
2233 X509 *cert;
2234 SSL_CTX *ssl_ctx = _ssl_ctx;
68ae4773 2235 X509_STORE *store;
e59c91af
DS		 2236
2237 if (tls_engine_get_cert(conn, ca_cert_id, &cert))
2238 return -1;
2239
2240 /* start off the same as tls_connection_ca_cert */
68ae4773
JM		 2241 store = X509_STORE_new();
2242 if (store == NULL) {
e59c91af
DS		 2243 wpa_printf(MSG_DEBUG, "OpenSSL: %s - failed to allocate new "
2244 "certificate store", __func__);
2245 X509_free(cert);
2246 return -1;
2247 }
68ae4773
JM		 2248 SSL_CTX_set_cert_store(ssl_ctx, store);
2249 if (!X509_STORE_add_cert(store, cert)) {
e59c91af
DS		 2250 unsigned long err = ERR_peek_error();
2251 tls_show_errors(MSG_WARNING, __func__,
2252 "Failed to add CA certificate from engine "
2253 "to certificate store");
2254 if (ERR_GET_LIB(err) == ERR_LIB_X509 &&
2255 ERR_GET_REASON(err) == X509_R_CERT_ALREADY_IN_HASH_TABLE) {
2256 wpa_printf(MSG_DEBUG, "OpenSSL: %s - ignoring cert"
2257 " already in hash table error",
2258 __func__);
2259 } else {
2260 X509_free(cert);
2261 return -1;
2262 }
2263 }
2264 X509_free(cert);
2265 wpa_printf(MSG_DEBUG, "OpenSSL: %s - added CA certificate from engine "
2266 "to certificate store", __func__);
2267 SSL_set_verify(conn->ssl, SSL_VERIFY_PEER, tls_verify_cb);
d8858cad
CW		 2268 conn->ca_cert_verify = 1;
2269
e59c91af
DS		 2270 return 0;
2271
2272#else /* OPENSSL_NO_ENGINE */
2273 return -1;
2274#endif /* OPENSSL_NO_ENGINE */
2275}
2276
2277
6fc6879b
JM		 2278static int tls_connection_engine_private_key(struct tls_connection *conn)
2279{
2280#ifndef OPENSSL_NO_ENGINE
2281 if (SSL_use_PrivateKey(conn->ssl, conn->private_key) != 1) {
2282 tls_show_errors(MSG_ERROR, __func__,
2283 "ENGINE: cannot use private key for TLS");
2284 return -1;
2285 }
2286 if (!SSL_check_private_key(conn->ssl)) {
2287 tls_show_errors(MSG_INFO, __func__,
2288 "Private key failed verification");
2289 return -1;
2290 }
2291 return 0;
2292#else /* OPENSSL_NO_ENGINE */
2293 wpa_printf(MSG_ERROR, "SSL: Configuration uses engine, but "
2294 "engine support was not compiled in");
2295 return -1;
2296#endif /* OPENSSL_NO_ENGINE */
2297}
2298
2299
2300static int tls_connection_private_key(void *_ssl_ctx,
2301 struct tls_connection *conn,
2302 const char *private_key,
2303 const char *private_key_passwd,
2304 const u8 *private_key_blob,
2305 size_t private_key_blob_len)
2306{
2307 SSL_CTX *ssl_ctx = _ssl_ctx;
2308 char *passwd;
2309 int ok;
2310
2311 if (private_key == NULL && private_key_blob == NULL)
2312 return 0;
2313
2314 if (private_key_passwd) {
2315 passwd = os_strdup(private_key_passwd);
2316 if (passwd == NULL)
2317 return -1;
2318 } else
2319 passwd = NULL;
2320
2321 SSL_CTX_set_default_passwd_cb(ssl_ctx, tls_passwd_cb);
2322 SSL_CTX_set_default_passwd_cb_userdata(ssl_ctx, passwd);
2323
2324 ok = 0;
2325 while (private_key_blob) {
2326 if (SSL_use_PrivateKey_ASN1(EVP_PKEY_RSA, conn->ssl,
2327 (u8 *) private_key_blob,
2328 private_key_blob_len) == 1) {
2329 wpa_printf(MSG_DEBUG, "OpenSSL: SSL_use_PrivateKey_"
2330 "ASN1(EVP_PKEY_RSA) --> OK");
2331 ok = 1;
2332 break;
6fc6879b
JM		 2333 }
2334
2335 if (SSL_use_PrivateKey_ASN1(EVP_PKEY_DSA, conn->ssl,
2336 (u8 *) private_key_blob,
2337 private_key_blob_len) == 1) {
2338 wpa_printf(MSG_DEBUG, "OpenSSL: SSL_use_PrivateKey_"
2339 "ASN1(EVP_PKEY_DSA) --> OK");
2340 ok = 1;
2341 break;
6fc6879b
JM		 2342 }
2343
2344 if (SSL_use_RSAPrivateKey_ASN1(conn->ssl,
2345 (u8 *) private_key_blob,
2346 private_key_blob_len) == 1) {
2347 wpa_printf(MSG_DEBUG, "OpenSSL: "
2348 "SSL_use_RSAPrivateKey_ASN1 --> OK");
2349 ok = 1;
2350 break;
6fc6879b
JM		 2351 }
2352
2353 if (tls_read_pkcs12_blob(ssl_ctx, conn->ssl, private_key_blob,
2354 private_key_blob_len, passwd) == 0) {
2355 wpa_printf(MSG_DEBUG, "OpenSSL: PKCS#12 as blob --> "
2356 "OK");
2357 ok = 1;
2358 break;
2359 }
2360
2361 break;
2362 }
2363
2364 while (!ok && private_key) {
2365#ifndef OPENSSL_NO_STDIO
2366 if (SSL_use_PrivateKey_file(conn->ssl, private_key,
2367 SSL_FILETYPE_ASN1) == 1) {
2368 wpa_printf(MSG_DEBUG, "OpenSSL: "
2369 "SSL_use_PrivateKey_File (DER) --> OK");
2370 ok = 1;
2371 break;
6fc6879b
JM		 2372 }
2373
2374 if (SSL_use_PrivateKey_file(conn->ssl, private_key,
2375 SSL_FILETYPE_PEM) == 1) {
2376 wpa_printf(MSG_DEBUG, "OpenSSL: "
2377 "SSL_use_PrivateKey_File (PEM) --> OK");
2378 ok = 1;
2379 break;
6fc6879b
JM		 2380 }
2381#else /* OPENSSL_NO_STDIO */
2382 wpa_printf(MSG_DEBUG, "OpenSSL: %s - OPENSSL_NO_STDIO",
2383 __func__);
2384#endif /* OPENSSL_NO_STDIO */
2385
2386 if (tls_read_pkcs12(ssl_ctx, conn->ssl, private_key, passwd)
2387 == 0) {
2388 wpa_printf(MSG_DEBUG, "OpenSSL: Reading PKCS#12 file "
2389 "--> OK");
2390 ok = 1;
2391 break;
2392 }
2393
2394 if (tls_cryptoapi_cert(conn->ssl, private_key) == 0) {
2395 wpa_printf(MSG_DEBUG, "OpenSSL: Using CryptoAPI to "
2396 "access certificate store --> OK");
2397 ok = 1;
2398 break;
2399 }
2400
2401 break;
2402 }
2403
2404 if (!ok) {
effab86f
JM		 2405 tls_show_errors(MSG_INFO, __func__,
2406 "Failed to load private key");
6fc6879b 2407 os_free(passwd);
6fc6879b
JM		 2408 return -1;
2409 }
2410 ERR_clear_error();
2411 SSL_CTX_set_default_passwd_cb(ssl_ctx, NULL);
2412 os_free(passwd);
55651a4b 2413
6fc6879b
JM		 2414 if (!SSL_check_private_key(conn->ssl)) {
2415 tls_show_errors(MSG_INFO, __func__, "Private key failed "
2416 "verification");
2417 return -1;
2418 }
2419
2420 wpa_printf(MSG_DEBUG, "SSL: Private key loaded successfully");
2421 return 0;
2422}
2423
2424
2425static int tls_global_private_key(SSL_CTX *ssl_ctx, const char *private_key,
2426 const char *private_key_passwd)
2427{
2428 char *passwd;
2429
2430 if (private_key == NULL)
2431 return 0;
2432
2433 if (private_key_passwd) {
2434 passwd = os_strdup(private_key_passwd);
2435 if (passwd == NULL)
2436 return -1;
2437 } else
2438 passwd = NULL;
2439
2440 SSL_CTX_set_default_passwd_cb(ssl_ctx, tls_passwd_cb);
2441 SSL_CTX_set_default_passwd_cb_userdata(ssl_ctx, passwd);
2442 if (
2443#ifndef OPENSSL_NO_STDIO
2444 SSL_CTX_use_PrivateKey_file(ssl_ctx, private_key,
2445 SSL_FILETYPE_ASN1) != 1 &&
2446 SSL_CTX_use_PrivateKey_file(ssl_ctx, private_key,
2447 SSL_FILETYPE_PEM) != 1 &&
2448#endif /* OPENSSL_NO_STDIO */
2449 tls_read_pkcs12(ssl_ctx, NULL, private_key, passwd)) {
2450 tls_show_errors(MSG_INFO, __func__,
2451 "Failed to load private key");
2452 os_free(passwd);
2453 ERR_clear_error();
2454 return -1;
2455 }
2456 os_free(passwd);
2457 ERR_clear_error();
2458 SSL_CTX_set_default_passwd_cb(ssl_ctx, NULL);
55651a4b 2459
6fc6879b
JM		 2460 if (!SSL_CTX_check_private_key(ssl_ctx)) {
2461 tls_show_errors(MSG_INFO, __func__,
2462 "Private key failed verification");
2463 return -1;
2464 }
2465
2466 return 0;
2467}
2468
2469
2470static int tls_connection_dh(struct tls_connection *conn, const char *dh_file)
2471{
2472#ifdef OPENSSL_NO_DH
2473 if (dh_file == NULL)
2474 return 0;
2475 wpa_printf(MSG_ERROR, "TLS: openssl does not include DH support, but "
2476 "dh_file specified");
2477 return -1;
2478#else /* OPENSSL_NO_DH */
2479 DH *dh;
2480 BIO *bio;
2481
2482 /* TODO: add support for dh_blob */
2483 if (dh_file == NULL)
2484 return 0;
2485 if (conn == NULL)
2486 return -1;
2487
2488 bio = BIO_new_file(dh_file, "r");
2489 if (bio == NULL) {
2490 wpa_printf(MSG_INFO, "TLS: Failed to open DH file '%s': %s",
2491 dh_file, ERR_error_string(ERR_get_error(), NULL));
2492 return -1;
2493 }
2494 dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
2495 BIO_free(bio);
2496#ifndef OPENSSL_NO_DSA
2497 while (dh == NULL) {
2498 DSA *dsa;
2499 wpa_printf(MSG_DEBUG, "TLS: Failed to parse DH file '%s': %s -"
2500 " trying to parse as DSA params", dh_file,
2501 ERR_error_string(ERR_get_error(), NULL));
2502 bio = BIO_new_file(dh_file, "r");
2503 if (bio == NULL)
2504 break;
2505 dsa = PEM_read_bio_DSAparams(bio, NULL, NULL, NULL);
2506 BIO_free(bio);
2507 if (!dsa) {
2508 wpa_printf(MSG_DEBUG, "TLS: Failed to parse DSA file "
2509 "'%s': %s", dh_file,
2510 ERR_error_string(ERR_get_error(), NULL));
2511 break;
2512 }
2513
2514 wpa_printf(MSG_DEBUG, "TLS: DH file in DSA param format");
2515 dh = DSA_dup_DH(dsa);
2516 DSA_free(dsa);
2517 if (dh == NULL) {
2518 wpa_printf(MSG_INFO, "TLS: Failed to convert DSA "
2519 "params into DH params");
2520 break;
2521 }
2522 break;
2523 }
2524#endif /* !OPENSSL_NO_DSA */
2525 if (dh == NULL) {
2526 wpa_printf(MSG_INFO, "TLS: Failed to read/parse DH/DSA file "
2527 "'%s'", dh_file);
2528 return -1;
2529 }
2530
2531 if (SSL_set_tmp_dh(conn->ssl, dh) != 1) {
2532 wpa_printf(MSG_INFO, "TLS: Failed to set DH params from '%s': "
2533 "%s", dh_file,
2534 ERR_error_string(ERR_get_error(), NULL));
2535 DH_free(dh);
2536 return -1;
2537 }
2538 DH_free(dh);
2539 return 0;
2540#endif /* OPENSSL_NO_DH */
2541}
2542
2543
2544static int tls_global_dh(SSL_CTX *ssl_ctx, const char *dh_file)
2545{
2546#ifdef OPENSSL_NO_DH
2547 if (dh_file == NULL)
2548 return 0;
2549 wpa_printf(MSG_ERROR, "TLS: openssl does not include DH support, but "
2550 "dh_file specified");
2551 return -1;
2552#else /* OPENSSL_NO_DH */
2553 DH *dh;
2554 BIO *bio;
2555
2556 /* TODO: add support for dh_blob */
2557 if (dh_file == NULL)
2558 return 0;
2559 if (ssl_ctx == NULL)
2560 return -1;
2561
2562 bio = BIO_new_file(dh_file, "r");
2563 if (bio == NULL) {
2564 wpa_printf(MSG_INFO, "TLS: Failed to open DH file '%s': %s",
2565 dh_file, ERR_error_string(ERR_get_error(), NULL));
2566 return -1;
2567 }
2568 dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
2569 BIO_free(bio);
2570#ifndef OPENSSL_NO_DSA
2571 while (dh == NULL) {
2572 DSA *dsa;
2573 wpa_printf(MSG_DEBUG, "TLS: Failed to parse DH file '%s': %s -"
2574 " trying to parse as DSA params", dh_file,
2575 ERR_error_string(ERR_get_error(), NULL));
2576 bio = BIO_new_file(dh_file, "r");
2577 if (bio == NULL)
2578 break;
2579 dsa = PEM_read_bio_DSAparams(bio, NULL, NULL, NULL);
2580 BIO_free(bio);
2581 if (!dsa) {
2582 wpa_printf(MSG_DEBUG, "TLS: Failed to parse DSA file "
2583 "'%s': %s", dh_file,
2584 ERR_error_string(ERR_get_error(), NULL));
2585 break;
2586 }
2587
2588 wpa_printf(MSG_DEBUG, "TLS: DH file in DSA param format");
2589 dh = DSA_dup_DH(dsa);
2590 DSA_free(dsa);
2591 if (dh == NULL) {
2592 wpa_printf(MSG_INFO, "TLS: Failed to convert DSA "
2593 "params into DH params");
2594 break;
2595 }
2596 break;
2597 }
2598#endif /* !OPENSSL_NO_DSA */
2599 if (dh == NULL) {
2600 wpa_printf(MSG_INFO, "TLS: Failed to read/parse DH/DSA file "
2601 "'%s'", dh_file);
2602 return -1;
2603 }
2604
2605 if (SSL_CTX_set_tmp_dh(ssl_ctx, dh) != 1) {
2606 wpa_printf(MSG_INFO, "TLS: Failed to set DH params from '%s': "
2607 "%s", dh_file,
2608 ERR_error_string(ERR_get_error(), NULL));
2609 DH_free(dh);
2610 return -1;
2611 }
2612 DH_free(dh);
2613 return 0;
2614#endif /* OPENSSL_NO_DH */
2615}
2616
2617
2618int tls_connection_get_keys(void *ssl_ctx, struct tls_connection *conn,
2619 struct tls_keys *keys)
2620{
c9e08af2
JM		 2621#ifdef CONFIG_FIPS
2622 wpa_printf(MSG_ERROR, "OpenSSL: TLS keys cannot be exported in FIPS "
2623 "mode");
2624 return -1;
2625#else /* CONFIG_FIPS */
6fc6879b
JM		 2626 SSL *ssl;
2627
2628 if (conn == NULL || keys == NULL)
2629 return -1;
2630 ssl = conn->ssl;
2631 if (ssl == NULL || ssl->s3 == NULL || ssl->session == NULL)
2632 return -1;
2633
2634 os_memset(keys, 0, sizeof(*keys));
2635 keys->master_key = ssl->session->master_key;
2636 keys->master_key_len = ssl->session->master_key_length;
2637 keys->client_random = ssl->s3->client_random;
2638 keys->client_random_len = SSL3_RANDOM_SIZE;
2639 keys->server_random = ssl->s3->server_random;
2640 keys->server_random_len = SSL3_RANDOM_SIZE;
2641
2642 return 0;
c9e08af2 2643#endif /* CONFIG_FIPS */
6fc6879b
JM		 2644}
2645
2646
2647int tls_connection_prf(void *tls_ctx, struct tls_connection *conn,
2648 const char *label, int server_random_first,
2649 u8 *out, size_t out_len)
2650{
68770ccd
JM		 2651#if OPENSSL_VERSION_NUMBER >= 0x10001000L
2652 SSL *ssl;
2653 if (conn == NULL)
2654 return -1;
2655 if (server_random_first)
2656 return -1;
2657 ssl = conn->ssl;
2658 if (SSL_export_keying_material(ssl, out, out_len, label,
2659 os_strlen(label), NULL, 0, 0) == 1) {
2660 wpa_printf(MSG_DEBUG, "OpenSSL: Using internal PRF");
2661 return 0;
2662 }
2663#endif
6fc6879b
JM		 2664 return -1;
2665}
2666
2667
81c85c06
JM		 2668static struct wpabuf *
2669openssl_handshake(struct tls_connection *conn, const struct wpabuf *in_data,
2670 int server)
6fc6879b
JM		 2671{
2672 int res;
81c85c06 2673 struct wpabuf *out_data;
6fc6879b
JM		 2674
2675 /*
2676 * Give TLS handshake data from the server (if available) to OpenSSL
2677 * for processing.
2678 */
2679 if (in_data &&
81c85c06
JM		 2680 BIO_write(conn->ssl_in, wpabuf_head(in_data), wpabuf_len(in_data))
2681 < 0) {
6fc6879b
JM		 2682 tls_show_errors(MSG_INFO, __func__,
2683 "Handshake failed - BIO_write");
2684 return NULL;
2685 }
2686
2687 /* Initiate TLS handshake or continue the existing handshake */
81c85c06
JM		 2688 if (server)
2689 res = SSL_accept(conn->ssl);
2690 else
2691 res = SSL_connect(conn->ssl);
6fc6879b
JM		 2692 if (res != 1) {
2693 int err = SSL_get_error(conn->ssl, res);
2694 if (err == SSL_ERROR_WANT_READ)
2695 wpa_printf(MSG_DEBUG, "SSL: SSL_connect - want "
2696 "more data");
2697 else if (err == SSL_ERROR_WANT_WRITE)
2698 wpa_printf(MSG_DEBUG, "SSL: SSL_connect - want to "
2699 "write");
2700 else {
2701 tls_show_errors(MSG_INFO, __func__, "SSL_connect");
2702 conn->failed++;
2703 }
2704 }
2705
2706 /* Get the TLS handshake data to be sent to the server */
2707 res = BIO_ctrl_pending(conn->ssl_out);
2708 wpa_printf(MSG_DEBUG, "SSL: %d bytes pending from ssl_out", res);
81c85c06 2709 out_data = wpabuf_alloc(res);
6fc6879b
JM		 2710 if (out_data == NULL) {
2711 wpa_printf(MSG_DEBUG, "SSL: Failed to allocate memory for "
2712 "handshake output (%d bytes)", res);
2713 if (BIO_reset(conn->ssl_out) < 0) {
2714 tls_show_errors(MSG_INFO, __func__,
2715 "BIO_reset failed");
2716 }
6fc6879b
JM		 2717 return NULL;
2718 }
81c85c06
JM		 2719 res = res == 0 ? 0 : BIO_read(conn->ssl_out, wpabuf_mhead(out_data),
2720 res);
6fc6879b
JM		 2721 if (res < 0) {
2722 tls_show_errors(MSG_INFO, __func__,
2723 "Handshake failed - BIO_read");
2724 if (BIO_reset(conn->ssl_out) < 0) {
2725 tls_show_errors(MSG_INFO, __func__,
2726 "BIO_reset failed");
2727 }
81c85c06 2728 wpabuf_free(out_data);
6fc6879b
JM		 2729 return NULL;
2730 }
81c85c06 2731 wpabuf_put(out_data, res);
6fc6879b
JM		 2732
2733 return out_data;
2734}
2735
2736
81c85c06
JM		 2737static struct wpabuf *
2738openssl_get_appl_data(struct tls_connection *conn, size_t max_len)
6fc6879b 2739{
81c85c06 2740 struct wpabuf *appl_data;
6fc6879b 2741 int res;
6fc6879b 2742
81c85c06
JM		 2743 appl_data = wpabuf_alloc(max_len + 100);
2744 if (appl_data == NULL)
6fc6879b 2745 return NULL;
6fc6879b 2746
81c85c06
JM		 2747 res = SSL_read(conn->ssl, wpabuf_mhead(appl_data),
2748 wpabuf_size(appl_data));
2749 if (res < 0) {
bf206cad 2750 int err = SSL_get_error(conn->ssl, res);
81c85c06
JM		 2751 if (err == SSL_ERROR_WANT_READ ||
2752 err == SSL_ERROR_WANT_WRITE) {
2753 wpa_printf(MSG_DEBUG, "SSL: No Application Data "
2754 "included");
2755 } else {
6fc6879b 2756 tls_show_errors(MSG_INFO, __func__,
81c85c06
JM		 2757 "Failed to read possible "
2758 "Application Data");
6fc6879b 2759 }
81c85c06 2760 wpabuf_free(appl_data);
6fc6879b
JM		 2761 return NULL;
2762 }
81c85c06
JM		 2763
2764 wpabuf_put(appl_data, res);
2765 wpa_hexdump_buf_key(MSG_MSGDUMP, "SSL: Application Data in Finished "
2766 "message", appl_data);
2767
2768 return appl_data;
2769}
2770
2771
2772static struct wpabuf *
2773openssl_connection_handshake(struct tls_connection *conn,
2774 const struct wpabuf *in_data,
2775 struct wpabuf **appl_data, int server)
2776{
2777 struct wpabuf *out_data;
2778
2779 if (appl_data)
2780 *appl_data = NULL;
2781
2782 out_data = openssl_handshake(conn, in_data, server);
2783 if (out_data == NULL)
6fc6879b 2784 return NULL;
bb52293e
JM		 2785 if (conn->invalid_hb_used) {
2786 wpa_printf(MSG_INFO, "TLS: Heartbeat attack detected - do not send response");
2787 wpabuf_free(out_data);
2788 return NULL;
2789 }
81c85c06
JM		 2790
2791 if (SSL_is_init_finished(conn->ssl) && appl_data && in_data)
2792 *appl_data = openssl_get_appl_data(conn, wpabuf_len(in_data));
2793
bb52293e
JM		 2794 if (conn->invalid_hb_used) {
2795 wpa_printf(MSG_INFO, "TLS: Heartbeat attack detected - do not send response");
2796 if (appl_data) {
2797 wpabuf_free(*appl_data);
2798 *appl_data = NULL;
2799 }
2800 wpabuf_free(out_data);
2801 return NULL;
2802 }
2803
6fc6879b
JM		 2804 return out_data;
2805}
2806
2807
81c85c06
JM		 2808struct wpabuf *
2809tls_connection_handshake(void *ssl_ctx, struct tls_connection *conn,
2810 const struct wpabuf *in_data,
2811 struct wpabuf **appl_data)
2812{
2813 return openssl_connection_handshake(conn, in_data, appl_data, 0);
2814}
2815
2816
2817struct wpabuf * tls_connection_server_handshake(void *tls_ctx,
2818 struct tls_connection *conn,
2819 const struct wpabuf *in_data,
2820 struct wpabuf **appl_data)
2821{
2822 return openssl_connection_handshake(conn, in_data, appl_data, 1);
2823}
2824
2825
2826struct wpabuf * tls_connection_encrypt(void *tls_ctx,
2827 struct tls_connection *conn,
2828 const struct wpabuf *in_data)
6fc6879b
JM		 2829{
2830 int res;
81c85c06 2831 struct wpabuf *buf;
6fc6879b
JM		 2832
2833 if (conn == NULL)
81c85c06 2834 return NULL;
6fc6879b
JM		 2835
2836 /* Give plaintext data for OpenSSL to encrypt into the TLS tunnel. */
2837 if ((res = BIO_reset(conn->ssl_in)) < 0 ||
2838 (res = BIO_reset(conn->ssl_out)) < 0) {
2839 tls_show_errors(MSG_INFO, __func__, "BIO_reset failed");
81c85c06 2840 return NULL;
6fc6879b 2841 }
81c85c06 2842 res = SSL_write(conn->ssl, wpabuf_head(in_data), wpabuf_len(in_data));
6fc6879b
JM		 2843 if (res < 0) {
2844 tls_show_errors(MSG_INFO, __func__,
2845 "Encryption failed - SSL_write");
81c85c06 2846 return NULL;
6fc6879b
JM		 2847 }
2848
2849 /* Read encrypted data to be sent to the server */
81c85c06
JM		 2850 buf = wpabuf_alloc(wpabuf_len(in_data) + 300);
2851 if (buf == NULL)
2852 return NULL;
2853 res = BIO_read(conn->ssl_out, wpabuf_mhead(buf), wpabuf_size(buf));
6fc6879b
JM		 2854 if (res < 0) {
2855 tls_show_errors(MSG_INFO, __func__,
2856 "Encryption failed - BIO_read");
81c85c06
JM		 2857 wpabuf_free(buf);
2858 return NULL;
6fc6879b 2859 }
81c85c06 2860 wpabuf_put(buf, res);
6fc6879b 2861
81c85c06 2862 return buf;
6fc6879b
JM		 2863}
2864
2865
81c85c06
JM		 2866struct wpabuf * tls_connection_decrypt(void *tls_ctx,
2867 struct tls_connection *conn,
2868 const struct wpabuf *in_data)
6fc6879b
JM		 2869{
2870 int res;
81c85c06 2871 struct wpabuf *buf;
6fc6879b
JM		 2872
2873 /* Give encrypted data from TLS tunnel for OpenSSL to decrypt. */
81c85c06
JM		 2874 res = BIO_write(conn->ssl_in, wpabuf_head(in_data),
2875 wpabuf_len(in_data));
6fc6879b
JM		 2876 if (res < 0) {
2877 tls_show_errors(MSG_INFO, __func__,
2878 "Decryption failed - BIO_write");
81c85c06 2879 return NULL;
6fc6879b
JM		 2880 }
2881 if (BIO_reset(conn->ssl_out) < 0) {
2882 tls_show_errors(MSG_INFO, __func__, "BIO_reset failed");
81c85c06 2883 return NULL;
6fc6879b
JM		 2884 }
2885
2886 /* Read decrypted data for further processing */
81c85c06
JM		 2887 /*
2888 * Even though we try to disable TLS compression, it is possible that
2889 * this cannot be done with all TLS libraries. Add extra buffer space
2890 * to handle the possibility of the decrypted data being longer than
2891 * input data.
2892 */
2893 buf = wpabuf_alloc((wpabuf_len(in_data) + 500) * 3);
2894 if (buf == NULL)
2895 return NULL;
2896 res = SSL_read(conn->ssl, wpabuf_mhead(buf), wpabuf_size(buf));
6fc6879b
JM		 2897 if (res < 0) {
2898 tls_show_errors(MSG_INFO, __func__,
2899 "Decryption failed - SSL_read");
a86a7316 2900 wpabuf_free(buf);
81c85c06 2901 return NULL;
6fc6879b 2902 }
81c85c06 2903 wpabuf_put(buf, res);
6fc6879b 2904
bb52293e
JM		 2905 if (conn->invalid_hb_used) {
2906 wpa_printf(MSG_INFO, "TLS: Heartbeat attack detected - do not send response");
2907 wpabuf_free(buf);
2908 return NULL;
2909 }
2910
81c85c06 2911 return buf;
6fc6879b
JM		 2912}
2913
2914
2915int tls_connection_resumed(void *ssl_ctx, struct tls_connection *conn)
2916{
db3168d4
JM		 2917#if OPENSSL_VERSION_NUMBER >= 0x10001000L
2918 return conn ? SSL_cache_hit(conn->ssl) : 0;
2919#else
6fc6879b 2920 return conn ? conn->ssl->hit : 0;
db3168d4 2921#endif
6fc6879b
JM		 2922}
2923
2924
2925int tls_connection_set_cipher_list(void *tls_ctx, struct tls_connection *conn,
2926 u8 *ciphers)
2927{
2928 char buf[100], *pos, *end;
2929 u8 *c;
2930 int ret;
2931
2932 if (conn == NULL || conn->ssl == NULL || ciphers == NULL)
2933 return -1;
2934
2935 buf[0] = '\0';
2936 pos = buf;
2937 end = pos + sizeof(buf);
2938
2939 c = ciphers;
2940 while (*c != TLS_CIPHER_NONE) {
2941 const char *suite;
2942
2943 switch (*c) {
2944 case TLS_CIPHER_RC4_SHA:
2945 suite = "RC4-SHA";
2946 break;
2947 case TLS_CIPHER_AES128_SHA:
2948 suite = "AES128-SHA";
2949 break;
2950 case TLS_CIPHER_RSA_DHE_AES128_SHA:
2951 suite = "DHE-RSA-AES128-SHA";
2952 break;
2953 case TLS_CIPHER_ANON_DH_AES128_SHA:
2954 suite = "ADH-AES128-SHA";
2955 break;
2956 default:
2957 wpa_printf(MSG_DEBUG, "TLS: Unsupported "
2958 "cipher selection: %d", *c);
2959 return -1;
2960 }
2961 ret = os_snprintf(pos, end - pos, ":%s", suite);
d85e1fc8 2962 if (os_snprintf_error(end - pos, ret))
6fc6879b
JM		 2963 break;
2964 pos += ret;
2965
2966 c++;
2967 }
2968
2969 wpa_printf(MSG_DEBUG, "OpenSSL: cipher suites: %s", buf + 1);
2970
2971 if (SSL_set_cipher_list(conn->ssl, buf + 1) != 1) {
2972 tls_show_errors(MSG_INFO, __func__,
2973 "Cipher suite configuration failed");
2974 return -1;
2975 }
2976
2977 return 0;
2978}
2979
2980
2981int tls_get_cipher(void *ssl_ctx, struct tls_connection *conn,
2982 char *buf, size_t buflen)
2983{
2984 const char *name;
2985 if (conn == NULL || conn->ssl == NULL)
2986 return -1;
2987
2988 name = SSL_get_cipher(conn->ssl);
2989 if (name == NULL)
2990 return -1;
2991
2992 os_strlcpy(buf, name, buflen);
2993 return 0;
2994}
2995
2996
2997int tls_connection_enable_workaround(void *ssl_ctx,
2998 struct tls_connection *conn)
2999{
3000 SSL_set_options(conn->ssl, SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS);
3001
3002 return 0;
3003}
3004
3005
1e5839e0 3006#if defined(EAP_FAST) || defined(EAP_FAST_DYNAMIC) || defined(EAP_SERVER_FAST)
6fc6879b
JM		 3007/* ClientHello TLS extensions require a patch to openssl, so this function is
3008 * commented out unless explicitly needed for EAP-FAST in order to be able to
3009 * build this file with unmodified openssl. */
3010int tls_connection_client_hello_ext(void *ssl_ctx, struct tls_connection *conn,
3011 int ext_type, const u8 *data,
3012 size_t data_len)
3013{
0cf03892 3014 if (conn == NULL || conn->ssl == NULL || ext_type != 35)
6fc6879b
JM		 3015 return -1;
3016
0cf03892
JM		 3017 if (SSL_set_session_ticket_ext(conn->ssl, (void *) data,
3018 data_len) != 1)
3019 return -1;
6fc6879b
JM		 3020
3021 return 0;
3022}
1e5839e0 3023#endif /* EAP_FAST || EAP_FAST_DYNAMIC || EAP_SERVER_FAST */
6fc6879b
JM		 3024
3025
3026int tls_connection_get_failed(void *ssl_ctx, struct tls_connection *conn)
3027{
3028 if (conn == NULL)
3029 return -1;
3030 return conn->failed;
3031}
3032
3033
3034int tls_connection_get_read_alerts(void *ssl_ctx, struct tls_connection *conn)
3035{
3036 if (conn == NULL)
3037 return -1;
3038 return conn->read_alerts;
3039}
3040
3041
3042int tls_connection_get_write_alerts(void *ssl_ctx, struct tls_connection *conn)
3043{
3044 if (conn == NULL)
3045 return -1;
3046 return conn->write_alerts;
3047}
3048
3049
080585c0
JM		 3050#ifdef HAVE_OCSP
3051
3052static void ocsp_debug_print_resp(OCSP_RESPONSE *rsp)
3053{
3054#ifndef CONFIG_NO_STDOUT_DEBUG
080585c0
JM		 3055 BIO *out;
3056 size_t rlen;
3057 char *txt;
3058 int res;
3059
3060 if (wpa_debug_level > MSG_DEBUG)
3061 return;
3062
3063 out = BIO_new(BIO_s_mem());
3064 if (!out)
3065 return;
3066
3067 OCSP_RESPONSE_print(out, rsp, 0);
3068 rlen = BIO_ctrl_pending(out);
3069 txt = os_malloc(rlen + 1);
3070 if (!txt) {
3071 BIO_free(out);
3072 return;
3073 }
3074
3075 res = BIO_read(out, txt, rlen);
3076 if (res > 0) {
3077 txt[res] = '\0';
3078 wpa_printf(MSG_DEBUG, "OpenSSL: OCSP Response\n%s", txt);
3079 }
3080 os_free(txt);
3081 BIO_free(out);
3082#endif /* CONFIG_NO_STDOUT_DEBUG */
3083}
3084
3085
4eb3b76b
JM		 3086static void debug_print_cert(X509 *cert, const char *title)
3087{
3088#ifndef CONFIG_NO_STDOUT_DEBUG
3089 BIO *out;
3090 size_t rlen;
3091 char *txt;
3092 int res;
3093
3094 if (wpa_debug_level > MSG_DEBUG)
3095 return;
3096
3097 out = BIO_new(BIO_s_mem());
3098 if (!out)
3099 return;
3100
3101 X509_print(out, cert);
3102 rlen = BIO_ctrl_pending(out);
3103 txt = os_malloc(rlen + 1);
3104 if (!txt) {
3105 BIO_free(out);
3106 return;
3107 }
3108
3109 res = BIO_read(out, txt, rlen);
3110 if (res > 0) {
3111 txt[res] = '\0';
3112 wpa_printf(MSG_DEBUG, "OpenSSL: %s\n%s", title, txt);
3113 }
3114 os_free(txt);
3115
3116 BIO_free(out);
3117#endif /* CONFIG_NO_STDOUT_DEBUG */
3118}
3119
3120
080585c0
JM		 3121static int ocsp_resp_cb(SSL *s, void *arg)
3122{
3123 struct tls_connection *conn = arg;
3124 const unsigned char *p;
3125 int len, status, reason;
3126 OCSP_RESPONSE *rsp;
3127 OCSP_BASICRESP *basic;
3128 OCSP_CERTID *id;
3129 ASN1_GENERALIZEDTIME *produced_at, *this_update, *next_update;
6bf61fb2
JM		 3130 X509_STORE *store;
3131 STACK_OF(X509) *certs = NULL;
080585c0
JM		 3132
3133 len = SSL_get_tlsext_status_ocsp_resp(s, &p);
3134 if (!p) {
3135 wpa_printf(MSG_DEBUG, "OpenSSL: No OCSP response received");
3136 return (conn->flags & TLS_CONN_REQUIRE_OCSP) ? 0 : 1;
3137 }
3138
3139 wpa_hexdump(MSG_DEBUG, "OpenSSL: OCSP response", p, len);
3140
3141 rsp = d2i_OCSP_RESPONSE(NULL, &p, len);
3142 if (!rsp) {
3143 wpa_printf(MSG_INFO, "OpenSSL: Failed to parse OCSP response");
3144 return 0;
3145 }
3146
3147 ocsp_debug_print_resp(rsp);
3148
3149 status = OCSP_response_status(rsp);
3150 if (status != OCSP_RESPONSE_STATUS_SUCCESSFUL) {
3151 wpa_printf(MSG_INFO, "OpenSSL: OCSP responder error %d (%s)",
3152 status, OCSP_response_status_str(status));
3153 return 0;
3154 }
3155
3156 basic = OCSP_response_get1_basic(rsp);
3157 if (!basic) {
3158 wpa_printf(MSG_INFO, "OpenSSL: Could not find BasicOCSPResponse");
3159 return 0;
3160 }
3161
68ae4773 3162 store = SSL_CTX_get_cert_store(conn->ssl_ctx);
6bf61fb2 3163 if (conn->peer_issuer) {
4eb3b76b 3164 debug_print_cert(conn->peer_issuer, "Add OCSP issuer");
6bf61fb2
JM		 3165
3166 if (X509_STORE_add_cert(store, conn->peer_issuer) != 1) {
3167 tls_show_errors(MSG_INFO, __func__,
58d405fc 3168 "OpenSSL: Could not add issuer to certificate store");
6bf61fb2
JM		 3169 }
3170 certs = sk_X509_new_null();
3171 if (certs) {
3172 X509 *cert;
3173 cert = X509_dup(conn->peer_issuer);
3174 if (cert && !sk_X509_push(certs, cert)) {
3175 tls_show_errors(
3176 MSG_INFO, __func__,
58d405fc 3177 "OpenSSL: Could not add issuer to OCSP responder trust store");
6bf61fb2
JM		 3178 X509_free(cert);
3179 sk_X509_free(certs);
3180 certs = NULL;
3181 }
710dfb4e 3182 if (certs && conn->peer_issuer_issuer) {
6bf61fb2
JM		 3183 cert = X509_dup(conn->peer_issuer_issuer);
3184 if (cert && !sk_X509_push(certs, cert)) {
3185 tls_show_errors(
3186 MSG_INFO, __func__,
58d405fc 3187 "OpenSSL: Could not add issuer's issuer to OCSP responder trust store");
6bf61fb2
JM		 3188 X509_free(cert);
3189 }
3190 }
3191 }
3192 }
3193
3194 status = OCSP_basic_verify(basic, certs, store, OCSP_TRUSTOTHER);
3195 sk_X509_pop_free(certs, X509_free);
080585c0
JM		 3196 if (status <= 0) {
3197 tls_show_errors(MSG_INFO, __func__,
3198 "OpenSSL: OCSP response failed verification");
3199 OCSP_BASICRESP_free(basic);
3200 OCSP_RESPONSE_free(rsp);
3201 return 0;
3202 }
3203
3204 wpa_printf(MSG_DEBUG, "OpenSSL: OCSP response verification succeeded");
3205
762c92a4
JM		 3206 if (!conn->peer_cert) {
3207 wpa_printf(MSG_DEBUG, "OpenSSL: Peer certificate not available for OCSP status check");
3208 OCSP_BASICRESP_free(basic);
3209 OCSP_RESPONSE_free(rsp);
3210 return 0;
3211 }
3212
3213 if (!conn->peer_issuer) {
3214 wpa_printf(MSG_DEBUG, "OpenSSL: Peer issuer certificate not available for OCSP status check");
080585c0
JM		 3215 OCSP_BASICRESP_free(basic);
3216 OCSP_RESPONSE_free(rsp);
3217 return 0;
3218 }
3219
3220 id = OCSP_cert_to_id(NULL, conn->peer_cert, conn->peer_issuer);
3221 if (!id) {
3222 wpa_printf(MSG_DEBUG, "OpenSSL: Could not create OCSP certificate identifier");
3223 OCSP_BASICRESP_free(basic);
3224 OCSP_RESPONSE_free(rsp);
3225 return 0;
3226 }
3227
3228 if (!OCSP_resp_find_status(basic, id, &status, &reason, &produced_at,
3229 &this_update, &next_update)) {
3230 wpa_printf(MSG_INFO, "OpenSSL: Could not find current server certificate from OCSP response%s",
3231 (conn->flags & TLS_CONN_REQUIRE_OCSP) ? "" :
3232 " (OCSP not required)");
3233 OCSP_BASICRESP_free(basic);
3234 OCSP_RESPONSE_free(rsp);
3235 return (conn->flags & TLS_CONN_REQUIRE_OCSP) ? 0 : 1;
3236 }
3237
3238 if (!OCSP_check_validity(this_update, next_update, 5 * 60, -1)) {
3239 tls_show_errors(MSG_INFO, __func__,
3240 "OpenSSL: OCSP status times invalid");
3241 OCSP_BASICRESP_free(basic);
3242 OCSP_RESPONSE_free(rsp);
3243 return 0;
3244 }
3245
3246 OCSP_BASICRESP_free(basic);
3247 OCSP_RESPONSE_free(rsp);
3248
3249 wpa_printf(MSG_DEBUG, "OpenSSL: OCSP status for server certificate: %s",
3250 OCSP_cert_status_str(status));
3251
3252 if (status == V_OCSP_CERTSTATUS_GOOD)
3253 return 1;
3254 if (status == V_OCSP_CERTSTATUS_REVOKED)
3255 return 0;
3256 if (conn->flags & TLS_CONN_REQUIRE_OCSP) {
3257 wpa_printf(MSG_DEBUG, "OpenSSL: OCSP status unknown, but OCSP required");
3258 return 0;
3259 }
be7963b3 3260 wpa_printf(MSG_DEBUG, "OpenSSL: OCSP status unknown, but OCSP was not required, so allow connection to continue");
080585c0
JM		 3261 return 1;
3262}
3263
3264
3265static int ocsp_status_cb(SSL *s, void *arg)
3266{
3267 char *tmp;
3268 char *resp;
3269 size_t len;
3270
3271 if (tls_global->ocsp_stapling_response == NULL) {
3272 wpa_printf(MSG_DEBUG, "OpenSSL: OCSP status callback - no response configured");
3273 return SSL_TLSEXT_ERR_OK;
3274 }
3275
3276 resp = os_readfile(tls_global->ocsp_stapling_response, &len);
3277 if (resp == NULL) {
3278 wpa_printf(MSG_DEBUG, "OpenSSL: OCSP status callback - could not read response file");
3279 /* TODO: Build OCSPResponse with responseStatus = internalError
3280 */
3281 return SSL_TLSEXT_ERR_OK;
3282 }
3283 wpa_printf(MSG_DEBUG, "OpenSSL: OCSP status callback - send cached response");
3284 tmp = OPENSSL_malloc(len);
3285 if (tmp == NULL) {
3286 os_free(resp);
3287 return SSL_TLSEXT_ERR_ALERT_FATAL;
3288 }
3289
3290 os_memcpy(tmp, resp, len);
3291 os_free(resp);
3292 SSL_set_tlsext_status_ocsp_resp(s, tmp, len);
3293
3294 return SSL_TLSEXT_ERR_OK;
3295}
3296
3297#endif /* HAVE_OCSP */
3298
3299
6fc6879b
JM		 3300int tls_connection_set_params(void *tls_ctx, struct tls_connection *conn,
3301 const struct tls_connection_params *params)
3302{
3303 int ret;
3304 unsigned long err;
96955192 3305 int can_pkcs11 = 0;
01b0d1d5
DW		 3306 const char *key_id = params->key_id;
3307 const char *cert_id = params->cert_id;
3308 const char *ca_cert_id = params->ca_cert_id;
96955192 3309 const char *engine_id = params->engine ? params->engine_id : NULL;
6fc6879b
JM		 3310
3311 if (conn == NULL)
3312 return -1;
3313
01b0d1d5 3314 /*
96955192
DW		 3315 * If the engine isn't explicitly configured, and any of the
3316 * cert/key fields are actually PKCS#11 URIs, then automatically
3317 * use the PKCS#11 ENGINE.
01b0d1d5 3318 */
96955192
DW		 3319 if (!engine_id || os_strcmp(engine_id, "pkcs11") == 0)
3320 can_pkcs11 = 1;
3321
3322 if (!key_id && params->private_key && can_pkcs11 &&
3323 os_strncmp(params->private_key, "pkcs11:", 7) == 0) {
3324 can_pkcs11 = 2;
01b0d1d5 3325 key_id = params->private_key;
96955192 3326 }
01b0d1d5 3327
96955192
DW		 3328 if (!cert_id && params->client_cert && can_pkcs11 &&
3329 os_strncmp(params->client_cert, "pkcs11:", 7) == 0) {
3330 can_pkcs11 = 2;
01b0d1d5 3331 cert_id = params->client_cert;
96955192 3332 }
01b0d1d5 3333
96955192
DW		 3334 if (!ca_cert_id && params->ca_cert && can_pkcs11 &&
3335 os_strncmp(params->ca_cert, "pkcs11:", 7) == 0) {
3336 can_pkcs11 = 2;
01b0d1d5 3337 ca_cert_id = params->ca_cert;
96955192
DW		 3338 }
3339
3340 /* If we need to automatically enable the PKCS#11 ENGINE, do so. */
3341 if (can_pkcs11 == 2 && !engine_id)
3342 engine_id = "pkcs11";
01b0d1d5 3343
6a31a31d
JM		 3344 if (params->flags & TLS_CONN_EAP_FAST) {
3345 wpa_printf(MSG_DEBUG,
3346 "OpenSSL: Use TLSv1_method() for EAP-FAST");
3347 if (SSL_set_ssl_method(conn->ssl, TLSv1_method()) != 1) {
3348 tls_show_errors(MSG_INFO, __func__,
3349 "Failed to set TLSv1_method() for EAP-FAST");
3350 return -1;
3351 }
3352 }
d4913c58 3353
6fc6879b
JM		 3354 while ((err = ERR_get_error())) {
3355 wpa_printf(MSG_INFO, "%s: Clearing pending SSL error: %s",
3356 __func__, ERR_error_string(err, NULL));
3357 }
3358
96955192 3359 if (engine_id) {
e59c91af 3360 wpa_printf(MSG_DEBUG, "SSL: Initializing TLS engine");
96955192 3361 ret = tls_engine_init(conn, engine_id, params->pin,
01b0d1d5 3362 key_id, cert_id, ca_cert_id);
e59c91af
DS		 3363 if (ret)
3364 return ret;
3365 }
6fc6879b
JM		 3366 if (tls_connection_set_subject_match(conn,
3367 params->subject_match,
01f809c7 3368 params->altsubject_match,
cebee30f
JM		 3369 params->suffix_match,
3370 params->domain_match))
6fc6879b 3371 return -1;
e59c91af 3372
96955192 3373 if (engine_id && ca_cert_id) {
e59c91af 3374 if (tls_connection_engine_ca_cert(tls_ctx, conn,
01b0d1d5 3375 ca_cert_id))
e59c91af
DS		 3376 return TLS_SET_PARAMS_ENGINE_PRV_VERIFY_FAILED;
3377 } else if (tls_connection_ca_cert(tls_ctx, conn, params->ca_cert,
3378 params->ca_cert_blob,
3379 params->ca_cert_blob_len,
3380 params->ca_path))
6fc6879b 3381 return -1;
e59c91af 3382
96955192 3383 if (engine_id && cert_id) {
01b0d1d5 3384 if (tls_connection_engine_client_cert(conn, cert_id))
e59c91af
DS		 3385 return TLS_SET_PARAMS_ENGINE_PRV_VERIFY_FAILED;
3386 } else if (tls_connection_client_cert(conn, params->client_cert,
3387 params->client_cert_blob,
3388 params->client_cert_blob_len))
6fc6879b
JM		 3389 return -1;
3390
96955192 3391 if (engine_id && key_id) {
e59c91af 3392 wpa_printf(MSG_DEBUG, "TLS: Using private key from engine");
6fc6879b
JM		 3393 if (tls_connection_engine_private_key(conn))
3394 return TLS_SET_PARAMS_ENGINE_PRV_VERIFY_FAILED;
3395 } else if (tls_connection_private_key(tls_ctx, conn,
3396 params->private_key,
3397 params->private_key_passwd,
3398 params->private_key_blob,
3399 params->private_key_blob_len)) {
3400 wpa_printf(MSG_INFO, "TLS: Failed to load private key '%s'",
3401 params->private_key);
3402 return -1;
3403 }
3404
3405 if (tls_connection_dh(conn, params->dh_file)) {
3406 wpa_printf(MSG_INFO, "TLS: Failed to load DH file '%s'",
3407 params->dh_file);
3408 return -1;
3409 }
3410
b7328434
JM		 3411 if (params->openssl_ciphers &&
3412 SSL_set_cipher_list(conn->ssl, params->openssl_ciphers) != 1) {
3413 wpa_printf(MSG_INFO,
3414 "OpenSSL: Failed to set cipher string '%s'",
3415 params->openssl_ciphers);
3416 return -1;
3417 }
3418
e866f39f
JM		 3419#ifdef SSL_OP_NO_TICKET
3420 if (params->flags & TLS_CONN_DISABLE_SESSION_TICKET)
3421 SSL_set_options(conn->ssl, SSL_OP_NO_TICKET);
d53d2596 3422#ifdef SSL_clear_options
e866f39f
JM		 3423 else
3424 SSL_clear_options(conn->ssl, SSL_OP_NO_TICKET);
d53d2596 3425#endif /* SSL_clear_options */
e866f39f
JM		 3426#endif /* SSL_OP_NO_TICKET */
3427
e9a6f183
DS		 3428#ifdef SSL_OP_NO_TLSv1_1
3429 if (params->flags & TLS_CONN_DISABLE_TLSv1_1)
3430 SSL_set_options(conn->ssl, SSL_OP_NO_TLSv1_1);
3431 else
3432 SSL_clear_options(conn->ssl, SSL_OP_NO_TLSv1_1);
3433#endif /* SSL_OP_NO_TLSv1_1 */
3434#ifdef SSL_OP_NO_TLSv1_2
3435 if (params->flags & TLS_CONN_DISABLE_TLSv1_2)
3436 SSL_set_options(conn->ssl, SSL_OP_NO_TLSv1_2);
3437 else
3438 SSL_clear_options(conn->ssl, SSL_OP_NO_TLSv1_2);
3439#endif /* SSL_OP_NO_TLSv1_2 */
3440
080585c0
JM		 3441#ifdef HAVE_OCSP
3442 if (params->flags & TLS_CONN_REQUEST_OCSP) {
81cbc046 3443 SSL_CTX *ssl_ctx = tls_ctx;
080585c0
JM		 3444 SSL_set_tlsext_status_type(conn->ssl, TLSEXT_STATUSTYPE_ocsp);
3445 SSL_CTX_set_tlsext_status_cb(ssl_ctx, ocsp_resp_cb);
3446 SSL_CTX_set_tlsext_status_arg(ssl_ctx, conn);
3447 }
3448#endif /* HAVE_OCSP */
3449
235279e7
JM		 3450 conn->flags = params->flags;
3451
6fc6879b
JM		 3452 tls_get_errors(tls_ctx);
3453
3454 return 0;
3455}
3456
3457
3458int tls_global_set_params(void *tls_ctx,
3459 const struct tls_connection_params *params)
3460{
3461 SSL_CTX *ssl_ctx = tls_ctx;
3462 unsigned long err;
3463
3464 while ((err = ERR_get_error())) {
3465 wpa_printf(MSG_INFO, "%s: Clearing pending SSL error: %s",
3466 __func__, ERR_error_string(err, NULL));
3467 }
3468
3469 if (tls_global_ca_cert(ssl_ctx, params->ca_cert))
3470 return -1;
3471
3472 if (tls_global_client_cert(ssl_ctx, params->client_cert))
3473 return -1;
3474
3475 if (tls_global_private_key(ssl_ctx, params->private_key,
3476 params->private_key_passwd))
3477 return -1;
3478
3479 if (tls_global_dh(ssl_ctx, params->dh_file)) {
3480 wpa_printf(MSG_INFO, "TLS: Failed to load DH file '%s'",
3481 params->dh_file);
3482 return -1;
3483 }
3484
b7328434
JM		 3485 if (params->openssl_ciphers &&
3486 SSL_CTX_set_cipher_list(ssl_ctx, params->openssl_ciphers) != 1) {
3487 wpa_printf(MSG_INFO,
3488 "OpenSSL: Failed to set cipher string '%s'",
3489 params->openssl_ciphers);
3490 return -1;
3491 }
3492
e866f39f
JM		 3493#ifdef SSL_OP_NO_TICKET
3494 if (params->flags & TLS_CONN_DISABLE_SESSION_TICKET)
3495 SSL_CTX_set_options(ssl_ctx, SSL_OP_NO_TICKET);
d53d2596 3496#ifdef SSL_CTX_clear_options
e866f39f
JM		 3497 else
3498 SSL_CTX_clear_options(ssl_ctx, SSL_OP_NO_TICKET);
d53d2596 3499#endif /* SSL_clear_options */
e866f39f
JM		 3500#endif /* SSL_OP_NO_TICKET */
3501
080585c0
JM		 3502#ifdef HAVE_OCSP
3503 SSL_CTX_set_tlsext_status_cb(ssl_ctx, ocsp_status_cb);
3504 SSL_CTX_set_tlsext_status_arg(ssl_ctx, ssl_ctx);
3505 os_free(tls_global->ocsp_stapling_response);
3506 if (params->ocsp_stapling_response)
3507 tls_global->ocsp_stapling_response =
3508 os_strdup(params->ocsp_stapling_response);
3509 else
3510 tls_global->ocsp_stapling_response = NULL;
3511#endif /* HAVE_OCSP */
3512
6fc6879b
JM		 3513 return 0;
3514}
3515
3516
3517int tls_connection_get_keyblock_size(void *tls_ctx,
3518 struct tls_connection *conn)
3519{
3520 const EVP_CIPHER *c;
3521 const EVP_MD *h;
7f996409 3522 int md_size;
6fc6879b
JM		 3523
3524 if (conn == NULL || conn->ssl == NULL ||
3525 conn->ssl->enc_read_ctx == NULL ||
3526 conn->ssl->enc_read_ctx->cipher == NULL ||
3527 conn->ssl->read_hash == NULL)
3528 return -1;
3529
3530 c = conn->ssl->enc_read_ctx->cipher;
3531#if OPENSSL_VERSION_NUMBER >= 0x00909000L
3532 h = EVP_MD_CTX_md(conn->ssl->read_hash);
3533#else
3534 h = conn->ssl->read_hash;
3535#endif
7f996409
JM		 3536 if (h)
3537 md_size = EVP_MD_size(h);
3538#if OPENSSL_VERSION_NUMBER >= 0x10000000L
3539 else if (conn->ssl->s3)
3540 md_size = conn->ssl->s3->tmp.new_mac_secret_size;
3541#endif
3542 else
3543 return -1;
6fc6879b 3544
7f996409
JM		 3545 wpa_printf(MSG_DEBUG, "OpenSSL: keyblock size: key_len=%d MD_size=%d "
3546 "IV_len=%d", EVP_CIPHER_key_length(c), md_size,
3547 EVP_CIPHER_iv_length(c));
6fc6879b 3548 return 2 * (EVP_CIPHER_key_length(c) +
7f996409 3549 md_size +
6fc6879b
JM		 3550 EVP_CIPHER_iv_length(c));
3551}
3552
3553
3554unsigned int tls_capabilities(void *tls_ctx)
3555{
3556 return 0;
3557}
3558
3559
1e5839e0 3560#if defined(EAP_FAST) || defined(EAP_FAST_DYNAMIC) || defined(EAP_SERVER_FAST)
6fc6879b
JM		 3561/* Pre-shared secred requires a patch to openssl, so this function is
3562 * commented out unless explicitly needed for EAP-FAST in order to be able to
3563 * build this file with unmodified openssl. */
3564
a8572960
AL		 3565#ifdef OPENSSL_IS_BORINGSSL
3566static int tls_sess_sec_cb(SSL *s, void *secret, int *secret_len,
3567 STACK_OF(SSL_CIPHER) *peer_ciphers,
3568 const SSL_CIPHER **cipher, void *arg)
3569#else /* OPENSSL_IS_BORINGSSL */
6fc6879b
JM		 3570static int tls_sess_sec_cb(SSL *s, void *secret, int *secret_len,
3571 STACK_OF(SSL_CIPHER) *peer_ciphers,
3572 SSL_CIPHER **cipher, void *arg)
a8572960 3573#endif /* OPENSSL_IS_BORINGSSL */
6fc6879b
JM		 3574{
3575 struct tls_connection *conn = arg;
3576 int ret;
3577
3578 if (conn == NULL || conn->session_ticket_cb == NULL)
3579 return 0;
3580
3581 ret = conn->session_ticket_cb(conn->session_ticket_cb_ctx,
3582 conn->session_ticket,
3583 conn->session_ticket_len,
3584 s->s3->client_random,
3585 s->s3->server_random, secret);
3586 os_free(conn->session_ticket);
3587 conn->session_ticket = NULL;
3588
3589 if (ret <= 0)
3590 return 0;
3591
3592 *secret_len = SSL_MAX_MASTER_KEY_LENGTH;
3593 return 1;
3594}
3595
3596
0cf03892
JM		 3597static int tls_session_ticket_ext_cb(SSL *s, const unsigned char *data,
3598 int len, void *arg)
3599{
3600 struct tls_connection *conn = arg;
3601
3602 if (conn == NULL || conn->session_ticket_cb == NULL)
3603 return 0;
3604
3605 wpa_printf(MSG_DEBUG, "OpenSSL: %s: length=%d", __func__, len);
3606
3607 os_free(conn->session_ticket);
3608 conn->session_ticket = NULL;
3609
3610 wpa_hexdump(MSG_DEBUG, "OpenSSL: ClientHello SessionTicket "
3611 "extension", data, len);
3612
3613 conn->session_ticket = os_malloc(len);
3614 if (conn->session_ticket == NULL)
3615 return 0;
3616
3617 os_memcpy(conn->session_ticket, data, len);
3618 conn->session_ticket_len = len;
3619
3620 return 1;
3621}
1e5839e0 3622#endif /* EAP_FAST || EAP_FAST_DYNAMIC || EAP_SERVER_FAST */
6fc6879b
JM		 3623
3624
3625int tls_connection_set_session_ticket_cb(void *tls_ctx,
3626 struct tls_connection *conn,
3627 tls_session_ticket_cb cb,
3628 void *ctx)
3629{
1e5839e0 3630#if defined(EAP_FAST) || defined(EAP_FAST_DYNAMIC) || defined(EAP_SERVER_FAST)
6fc6879b
JM		 3631 conn->session_ticket_cb = cb;
3632 conn->session_ticket_cb_ctx = ctx;
3633
3634 if (cb) {
3635 if (SSL_set_session_secret_cb(conn->ssl, tls_sess_sec_cb,
3636 conn) != 1)
3637 return -1;
0cf03892
JM		 3638 SSL_set_session_ticket_ext_cb(conn->ssl,
3639 tls_session_ticket_ext_cb, conn);
6fc6879b
JM		 3640 } else {
3641 if (SSL_set_session_secret_cb(conn->ssl, NULL, NULL) != 1)
3642 return -1;
0cf03892 3643 SSL_set_session_ticket_ext_cb(conn->ssl, NULL, NULL);
6fc6879b
JM		 3644 }
3645
3646 return 0;
1e5839e0 3647#else /* EAP_FAST || EAP_FAST_DYNAMIC || EAP_SERVER_FAST */
6fc6879b 3648 return -1;
1e5839e0 3649#endif /* EAP_FAST || EAP_FAST_DYNAMIC || EAP_SERVER_FAST */
6fc6879b 3650}
a1651451
JM		 3651
3652
3653int tls_get_library_version(char *buf, size_t buf_len)
3654{
3655 return os_snprintf(buf, buf_len, "OpenSSL build=%s run=%s",
3656 OPENSSL_VERSION_TEXT,
3657 SSLeay_version(SSLEAY_VERSION));
3658}
Unnamed repository; edit this file 'description' to name the repository.