trunk/src/tls_openssl.c

/*
 *  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
 *
 *  Copyright (c) 2015 Attila Molnar <attilamolnar@hush.com>
 *  Copyright (c) 2015 Adam <Adam@anope.org>
 *  Copyright (c) 2005-2020 ircd-hybrid development team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
 *  USA
 */

/*! \file tls_openssl.c
 * \brief Includes all OpenSSL-specific TLS functions
 * \version $Id$
 */

#include "stdinc.h"
#include "tls.h"
#include "conf.h"
#include "log.h"
#include "misc.h"
#include "memory.h"

#ifdef HAVE_TLS_OPENSSL
#if OPENSSL_VERSION_NUMBER < 0x1010100fL
#error "OpenSSL 1.1.1 and above is required to build this module"
#endif

static bool TLS_initialized;

/*
 * report_crypto_errors - Dump crypto error list to log
 */
static void
report_crypto_errors(void)
{
  unsigned long e;

  while ((e = ERR_get_error()))
    ilog(LOG_TYPE_IRCD, "SSL error: %s", ERR_error_string(e, 0));
}

static int
always_accept_verify_cb(int preverify_ok, X509_STORE_CTX *x509_ctx)
{
  return 1;
}

bool
tls_is_initialized(void)
{
  return TLS_initialized;
}

/* tls_init()
 *
 * inputs       - nothing
 * output       - nothing
 * side effects - setups SSL context.
 */
void
tls_init(void)
{
  if ((ConfigServerInfo.tls_ctx.server_ctx = SSL_CTX_new(TLS_server_method())) == NULL)
  {
    const char *s = ERR_lib_error_string(ERR_get_error());

    ilog(LOG_TYPE_IRCD, "ERROR: Could not initialize the TLS server context -- %s", s);
    exit(EXIT_FAILURE);
    return;  /* Not reached */
  }

  SSL_CTX_set_min_proto_version(ConfigServerInfo.tls_ctx.server_ctx, TLS1_2_VERSION);
  SSL_CTX_set_options(ConfigServerInfo.tls_ctx.server_ctx, SSL_OP_CIPHER_SERVER_PREFERENCE|SSL_OP_NO_TICKET);
  SSL_CTX_set_verify(ConfigServerInfo.tls_ctx.server_ctx, SSL_VERIFY_PEER|SSL_VERIFY_CLIENT_ONCE, always_accept_verify_cb);
  SSL_CTX_set_session_cache_mode(ConfigServerInfo.tls_ctx.server_ctx, SSL_SESS_CACHE_OFF);
  SSL_CTX_set_cipher_list(ConfigServerInfo.tls_ctx.server_ctx, "EECDH+HIGH:EDH+HIGH:HIGH:!aNULL");

  if ((ConfigServerInfo.tls_ctx.client_ctx = SSL_CTX_new(TLS_client_method())) == NULL)
  {
    const char *s = ERR_lib_error_string(ERR_get_error());

    ilog(LOG_TYPE_IRCD, "ERROR: Could not initialize the TLS client context -- %s", s);
    exit(EXIT_FAILURE);
    return;  /* Not reached */
  }

  SSL_CTX_set_min_proto_version(ConfigServerInfo.tls_ctx.client_ctx, TLS1_2_VERSION);
  SSL_CTX_set_options(ConfigServerInfo.tls_ctx.client_ctx, SSL_OP_NO_TICKET);
  SSL_CTX_set_verify(ConfigServerInfo.tls_ctx.client_ctx, SSL_VERIFY_PEER|SSL_VERIFY_CLIENT_ONCE, always_accept_verify_cb);
  SSL_CTX_set_session_cache_mode(ConfigServerInfo.tls_ctx.client_ctx, SSL_SESS_CACHE_OFF);
}

bool
tls_new_credentials(void)
{
  TLS_initialized = false;

  if (ConfigServerInfo.tls_certificate_file == NULL || ConfigServerInfo.rsa_private_key_file == NULL)
    return true;

  if (SSL_CTX_use_certificate_chain_file(ConfigServerInfo.tls_ctx.server_ctx, ConfigServerInfo.tls_certificate_file) != 1 ||
      SSL_CTX_use_certificate_chain_file(ConfigServerInfo.tls_ctx.client_ctx, ConfigServerInfo.tls_certificate_file) != 1)
  {
    report_crypto_errors();
    return false;
  }

  if (SSL_CTX_use_PrivateKey_file(ConfigServerInfo.tls_ctx.server_ctx, ConfigServerInfo.rsa_private_key_file, SSL_FILETYPE_PEM) != 1 ||
      SSL_CTX_use_PrivateKey_file(ConfigServerInfo.tls_ctx.client_ctx, ConfigServerInfo.rsa_private_key_file, SSL_FILETYPE_PEM) != 1)
  {
    report_crypto_errors();
    return false;
  }

  if (SSL_CTX_check_private_key(ConfigServerInfo.tls_ctx.server_ctx) != 1 ||
      SSL_CTX_check_private_key(ConfigServerInfo.tls_ctx.client_ctx) != 1)
  {
    report_crypto_errors();
    return false;
  }

  if (ConfigServerInfo.tls_dh_param_file)
  {
    BIO *file = BIO_new_file(ConfigServerInfo.tls_dh_param_file, "r");

    if (file)
    {
      DH *dh = PEM_read_bio_DHparams(file, NULL, NULL, NULL);

      BIO_free(file);

      if (dh)
      {
        SSL_CTX_set_tmp_dh(ConfigServerInfo.tls_ctx.server_ctx, dh);
        DH_free(dh);
      }
    }
    else
      ilog(LOG_TYPE_IRCD, "Ignoring serverinfo::tls_dh_param_file -- could not open/read Diffie-Hellman parameter file");
  }

  if (ConfigServerInfo.tls_supported_groups == NULL)
    SSL_CTX_set1_groups_list(ConfigServerInfo.tls_ctx.server_ctx, "X25519:P-256");
  else if (SSL_CTX_set1_groups_list(ConfigServerInfo.tls_ctx.server_ctx, ConfigServerInfo.tls_supported_groups) == 0)
  {
    SSL_CTX_set1_groups_list(ConfigServerInfo.tls_ctx.server_ctx, "X25519:P-256");
    ilog(LOG_TYPE_IRCD, "Ignoring serverinfo::tls_supported_groups -- could not set supported group(s)");
  }

  if (ConfigServerInfo.tls_message_digest_algorithm == NULL)
    ConfigServerInfo.message_digest_algorithm = EVP_sha256();
  else if ((ConfigServerInfo.message_digest_algorithm = EVP_get_digestbyname(ConfigServerInfo.tls_message_digest_algorithm)) == NULL)
  {
    ConfigServerInfo.message_digest_algorithm = EVP_sha256();
    ilog(LOG_TYPE_IRCD, "Ignoring serverinfo::tls_message_digest_algorithm -- unknown message digest algorithm");
  }

  if (ConfigServerInfo.tls_cipher_list == NULL)
    SSL_CTX_set_cipher_list(ConfigServerInfo.tls_ctx.server_ctx, "EECDH+HIGH:EDH+HIGH:HIGH:!aNULL");
  else if (SSL_CTX_set_cipher_list(ConfigServerInfo.tls_ctx.server_ctx, ConfigServerInfo.tls_cipher_list) == 0)
  {
    SSL_CTX_set_cipher_list(ConfigServerInfo.tls_ctx.server_ctx, "EECDH+HIGH:EDH+HIGH:HIGH:!aNULL");
    ilog(LOG_TYPE_IRCD, "Ignoring serverinfo::tls_cipher_list -- could not set supported cipher(s)");
  }

#ifndef LIBRESSL_VERSION_NUMBER
  if (ConfigServerInfo.tls_cipher_suites == NULL)
    SSL_CTX_set_ciphersuites(ConfigServerInfo.tls_ctx.server_ctx, "TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256");
  else if (SSL_CTX_set_ciphersuites(ConfigServerInfo.tls_ctx.server_ctx, ConfigServerInfo.tls_cipher_suites) == 0)
  {
    SSL_CTX_set_ciphersuites(ConfigServerInfo.tls_ctx.server_ctx, "TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256");
    ilog(LOG_TYPE_IRCD, "Ignoring serverinfo::tls_cipher_suites -- could not set supported cipher suite(s)");
  }
#endif

  TLS_initialized = true;
  return true;
}

const char *
tls_get_cipher(const tls_data_t *tls_data)
{
  static char buf[128];
  SSL *ssl = *tls_data;

  snprintf(buf, sizeof(buf), "%s-%s", SSL_get_version(ssl), SSL_get_cipher(ssl));
  return buf;
}

const char *
tls_get_version(void)
{
  static char buf[256];

  snprintf(buf, sizeof(buf), "OpenSSL version: library: %s, header: %s",
           OpenSSL_version(OPENSSL_VERSION), OPENSSL_VERSION_TEXT);
  return buf;
}

bool
tls_isusing(tls_data_t *tls_data)
{
  SSL *ssl = *tls_data;
  return ssl != NULL;
}

void
tls_free(tls_data_t *tls_data)
{
  SSL_free(*tls_data);
  *tls_data = NULL;
}

ssize_t
tls_read(tls_data_t *tls_data, char *buf, size_t bufsize, bool *want_write)
{
  ERR_clear_error();

  SSL *ssl = *tls_data;
  ssize_t ret = SSL_read(ssl, buf, bufsize);
  /* Translate openssl error codes, sigh */
  if (ret < 0)
  {
    switch (SSL_get_error(ssl, ret))
    {
      case SSL_ERROR_WANT_WRITE:
      {
        /* OpenSSL wants to write, we signal this to the caller and do nothing about that here */
        *want_write = true;
        break;
      }
      case SSL_ERROR_WANT_READ:
        errno = EWOULDBLOCK;
      case SSL_ERROR_SYSCALL:
        break;
      case SSL_ERROR_SSL:
        if (errno == EAGAIN)
          break;
      /* Fall through */
      default:
        ret = errno = 0;
    }
  }

  return ret;
}

ssize_t
tls_write(tls_data_t *tls_data, const char *buf, size_t bufsize, bool *want_read)
{
  ERR_clear_error();

  SSL *ssl = *tls_data;
  ssize_t ret = SSL_write(ssl, buf, bufsize);
  /* Translate openssl error codes, sigh */
  if (ret < 0)
  {
    switch (SSL_get_error(ssl, ret))
    {
      case SSL_ERROR_WANT_READ:
        *want_read = true;
        break;  /* Retry later, don't register for write events */
      case SSL_ERROR_WANT_WRITE:
        errno = EWOULDBLOCK;
        break;
      case SSL_ERROR_SYSCALL:
        break;
      case SSL_ERROR_SSL:
        if (errno == EAGAIN)
          break;
      /* Fall through */
      default:
        ret = errno = 0;  /* Either an SSL-specific error or EOF */
    }
  }

  return ret;
}

void
tls_shutdown(tls_data_t *tls_data)
{
  SSL *ssl = *tls_data;

  SSL_set_shutdown(ssl, SSL_RECEIVED_SHUTDOWN);

  if (SSL_shutdown(ssl) == 0)
    SSL_shutdown(ssl);
}

bool
tls_new(tls_data_t *tls_data, int fd, tls_role_t role)
{
  SSL *ssl;

  if (TLS_initialized == false)
    return false;

  if (role == TLS_ROLE_SERVER)
    ssl = SSL_new(ConfigServerInfo.tls_ctx.server_ctx);
  else
    ssl = SSL_new(ConfigServerInfo.tls_ctx.client_ctx);

  if (ssl == NULL)
  {
    ilog(LOG_TYPE_IRCD, "SSL_new() ERROR! -- %s",
         ERR_error_string(ERR_get_error(), NULL));
    return false;
  }

  *tls_data = ssl;
  SSL_set_fd(ssl, fd);
  return true;
}

bool
tls_set_ciphers(tls_data_t *tls_data, const char *cipher_list)
{
  SSL_set_cipher_list(*tls_data, cipher_list);
  return true;
}

tls_handshake_status_t
tls_handshake(tls_data_t *tls_data, tls_role_t role, const char **errstr)
{
  SSL *ssl = *tls_data;
  int ret;

  ERR_clear_error();

  if (role == TLS_ROLE_SERVER)
    ret = SSL_accept(ssl);
  else
    ret = SSL_connect(ssl);

  if (ret > 0)
    return TLS_HANDSHAKE_DONE;

  switch (SSL_get_error(ssl, ret))
  {
    case SSL_ERROR_WANT_WRITE:
      return TLS_HANDSHAKE_WANT_WRITE;
    case SSL_ERROR_WANT_READ:
      return TLS_HANDSHAKE_WANT_READ;
    default:
    {
      const char *error = ERR_error_string(ERR_get_error(), NULL);

      if (errstr)
        *errstr = error;

      return TLS_HANDSHAKE_ERROR;
    }
  }
}

bool
tls_verify_certificate(tls_data_t *tls_data, tls_md_t digest, char **fingerprint)
{
  SSL *ssl = *tls_data;
  unsigned int n;
  char buf[EVP_MAX_MD_SIZE * 2 + 1];
  unsigned char md[EVP_MAX_MD_SIZE];
  bool ret = false;

  /* Accept NULL return from SSL_get_peer_certificate */
  X509 *cert = SSL_get_peer_certificate(ssl);
  if (cert == NULL)
    return true;

  switch (SSL_get_verify_result(ssl))
  {
    case X509_V_OK:
    case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
    case X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE:
    case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
      ret = true;

      if (X509_digest(cert, digest, md, &n))
      {
        binary_to_hex(md, buf, n);
        *fingerprint = xstrdup(buf);
      }
    default:
      break;
  }

  X509_free(cert);
  return ret;
}
#endif  /* HAVE_TLS_OPENSSL */
Revision:	9529
Committed:	Sun Jul 12 12:49:33 2020 UTC (5 years, 1 month ago) by michael
Content type:	text/x-csrc
File size:	11259 byte(s)
Log Message:	- tls_gnutls.c, tls_openssl.c, tls_wolfssl.c: fixed ret vs. retlen vs. length inconsistency
#	Content
1	/*
2	* ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3	*
4	* Copyright (c) 2015 Attila Molnar <attilamolnar@hush.com>
5	* Copyright (c) 2015 Adam <Adam@anope.org>
6	* Copyright (c) 2005-2020 ircd-hybrid development team
7	*
8	* This program is free software; you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License as published by
10	* the Free Software Foundation; either version 2 of the License, or
11	* (at your option) any later version.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
21	* USA
22	*/
23
24	/*! \file tls_openssl.c
25	* \brief Includes all OpenSSL-specific TLS functions
26	* \version $Id$
27	*/
28
29	#include "stdinc.h"
30	#include "tls.h"
31	#include "conf.h"
32	#include "log.h"
33	#include "misc.h"
34	#include "memory.h"
35
36	#ifdef HAVE_TLS_OPENSSL
37	#if OPENSSL_VERSION_NUMBER < 0x1010100fL
38	#error "OpenSSL 1.1.1 and above is required to build this module"
39	#endif
40
41	static bool TLS_initialized;
42
43	/*
44	* report_crypto_errors - Dump crypto error list to log
45	*/
46	static void
47	report_crypto_errors(void)
48	{
49	unsigned long e;
50
51	while ((e = ERR_get_error()))
52	ilog(LOG_TYPE_IRCD, "SSL error: %s", ERR_error_string(e, 0));
53	}
54
55	static int
56	always_accept_verify_cb(int preverify_ok, X509_STORE_CTX *x509_ctx)
57	{
58	return 1;
59	}
60
61	bool
62	tls_is_initialized(void)
63	{
64	return TLS_initialized;
65	}
66
67	/* tls_init()
68	*
69	* inputs - nothing
70	* output - nothing
71	* side effects - setups SSL context.
72	*/
73	void
74	tls_init(void)
75	{
76	if ((ConfigServerInfo.tls_ctx.server_ctx = SSL_CTX_new(TLS_server_method())) == NULL)
77	{
78	const char *s = ERR_lib_error_string(ERR_get_error());
79
80	ilog(LOG_TYPE_IRCD, "ERROR: Could not initialize the TLS server context -- %s", s);
81	exit(EXIT_FAILURE);
82	return; /* Not reached */
83	}
84
85	SSL_CTX_set_min_proto_version(ConfigServerInfo.tls_ctx.server_ctx, TLS1_2_VERSION);
86	SSL_CTX_set_options(ConfigServerInfo.tls_ctx.server_ctx, SSL_OP_CIPHER_SERVER_PREFERENCE\|SSL_OP_NO_TICKET);
87	SSL_CTX_set_verify(ConfigServerInfo.tls_ctx.server_ctx, SSL_VERIFY_PEER\|SSL_VERIFY_CLIENT_ONCE, always_accept_verify_cb);
88	SSL_CTX_set_session_cache_mode(ConfigServerInfo.tls_ctx.server_ctx, SSL_SESS_CACHE_OFF);
89	SSL_CTX_set_cipher_list(ConfigServerInfo.tls_ctx.server_ctx, "EECDH+HIGH:EDH+HIGH:HIGH:!aNULL");
90
91	if ((ConfigServerInfo.tls_ctx.client_ctx = SSL_CTX_new(TLS_client_method())) == NULL)
92	{
93	const char *s = ERR_lib_error_string(ERR_get_error());
94
95	ilog(LOG_TYPE_IRCD, "ERROR: Could not initialize the TLS client context -- %s", s);
96	exit(EXIT_FAILURE);
97	return; /* Not reached */
98	}
99
100	SSL_CTX_set_min_proto_version(ConfigServerInfo.tls_ctx.client_ctx, TLS1_2_VERSION);
101	SSL_CTX_set_options(ConfigServerInfo.tls_ctx.client_ctx, SSL_OP_NO_TICKET);
102	SSL_CTX_set_verify(ConfigServerInfo.tls_ctx.client_ctx, SSL_VERIFY_PEER\|SSL_VERIFY_CLIENT_ONCE, always_accept_verify_cb);
103	SSL_CTX_set_session_cache_mode(ConfigServerInfo.tls_ctx.client_ctx, SSL_SESS_CACHE_OFF);
104	}
105
106	bool
107	tls_new_credentials(void)
108	{
109	TLS_initialized = false;
110
111	if (ConfigServerInfo.tls_certificate_file == NULL \|\| ConfigServerInfo.rsa_private_key_file == NULL)
112	return true;
113
114	if (SSL_CTX_use_certificate_chain_file(ConfigServerInfo.tls_ctx.server_ctx, ConfigServerInfo.tls_certificate_file) != 1 \|\|
115	SSL_CTX_use_certificate_chain_file(ConfigServerInfo.tls_ctx.client_ctx, ConfigServerInfo.tls_certificate_file) != 1)
116	{
117	report_crypto_errors();
118	return false;
119	}
120
121	if (SSL_CTX_use_PrivateKey_file(ConfigServerInfo.tls_ctx.server_ctx, ConfigServerInfo.rsa_private_key_file, SSL_FILETYPE_PEM) != 1 \|\|
122	SSL_CTX_use_PrivateKey_file(ConfigServerInfo.tls_ctx.client_ctx, ConfigServerInfo.rsa_private_key_file, SSL_FILETYPE_PEM) != 1)
123	{
124	report_crypto_errors();
125	return false;
126	}
127
128	if (SSL_CTX_check_private_key(ConfigServerInfo.tls_ctx.server_ctx) != 1 \|\|
129	SSL_CTX_check_private_key(ConfigServerInfo.tls_ctx.client_ctx) != 1)
130	{
131	report_crypto_errors();
132	return false;
133	}
134
135	if (ConfigServerInfo.tls_dh_param_file)
136	{
137	BIO *file = BIO_new_file(ConfigServerInfo.tls_dh_param_file, "r");
138
139	if (file)
140	{
141	DH *dh = PEM_read_bio_DHparams(file, NULL, NULL, NULL);
142
143	BIO_free(file);
144
145	if (dh)
146	{
147	SSL_CTX_set_tmp_dh(ConfigServerInfo.tls_ctx.server_ctx, dh);
148	DH_free(dh);
149	}
150	}
151	else
152	ilog(LOG_TYPE_IRCD, "Ignoring serverinfo::tls_dh_param_file -- could not open/read Diffie-Hellman parameter file");
153	}
154
155	if (ConfigServerInfo.tls_supported_groups == NULL)
156	SSL_CTX_set1_groups_list(ConfigServerInfo.tls_ctx.server_ctx, "X25519:P-256");
157	else if (SSL_CTX_set1_groups_list(ConfigServerInfo.tls_ctx.server_ctx, ConfigServerInfo.tls_supported_groups) == 0)
158	{
159	SSL_CTX_set1_groups_list(ConfigServerInfo.tls_ctx.server_ctx, "X25519:P-256");
160	ilog(LOG_TYPE_IRCD, "Ignoring serverinfo::tls_supported_groups -- could not set supported group(s)");
161	}
162
163	if (ConfigServerInfo.tls_message_digest_algorithm == NULL)
164	ConfigServerInfo.message_digest_algorithm = EVP_sha256();
165	else if ((ConfigServerInfo.message_digest_algorithm = EVP_get_digestbyname(ConfigServerInfo.tls_message_digest_algorithm)) == NULL)
166	{
167	ConfigServerInfo.message_digest_algorithm = EVP_sha256();
168	ilog(LOG_TYPE_IRCD, "Ignoring serverinfo::tls_message_digest_algorithm -- unknown message digest algorithm");
169	}
170
171	if (ConfigServerInfo.tls_cipher_list == NULL)
172	SSL_CTX_set_cipher_list(ConfigServerInfo.tls_ctx.server_ctx, "EECDH+HIGH:EDH+HIGH:HIGH:!aNULL");
173	else if (SSL_CTX_set_cipher_list(ConfigServerInfo.tls_ctx.server_ctx, ConfigServerInfo.tls_cipher_list) == 0)
174	{
175	SSL_CTX_set_cipher_list(ConfigServerInfo.tls_ctx.server_ctx, "EECDH+HIGH:EDH+HIGH:HIGH:!aNULL");
176	ilog(LOG_TYPE_IRCD, "Ignoring serverinfo::tls_cipher_list -- could not set supported cipher(s)");
177	}
178
179	#ifndef LIBRESSL_VERSION_NUMBER
180	if (ConfigServerInfo.tls_cipher_suites == NULL)
181	SSL_CTX_set_ciphersuites(ConfigServerInfo.tls_ctx.server_ctx, "TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256");
182	else if (SSL_CTX_set_ciphersuites(ConfigServerInfo.tls_ctx.server_ctx, ConfigServerInfo.tls_cipher_suites) == 0)
183	{
184	SSL_CTX_set_ciphersuites(ConfigServerInfo.tls_ctx.server_ctx, "TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256");
185	ilog(LOG_TYPE_IRCD, "Ignoring serverinfo::tls_cipher_suites -- could not set supported cipher suite(s)");
186	}
187	#endif
188
189	TLS_initialized = true;
190	return true;
191	}
192
193	const char *
194	tls_get_cipher(const tls_data_t *tls_data)
195	{
196	static char buf[128];
197	SSL ssl = tls_data;
198
199	snprintf(buf, sizeof(buf), "%s-%s", SSL_get_version(ssl), SSL_get_cipher(ssl));
200	return buf;
201	}
202
203	const char *
204	tls_get_version(void)
205	{
206	static char buf[256];
207
208	snprintf(buf, sizeof(buf), "OpenSSL version: library: %s, header: %s",
209	OpenSSL_version(OPENSSL_VERSION), OPENSSL_VERSION_TEXT);
210	return buf;
211	}
212
213	bool
214	tls_isusing(tls_data_t *tls_data)
215	{
216	SSL ssl = tls_data;
217	return ssl != NULL;
218	}
219
220	void
221	tls_free(tls_data_t *tls_data)
222	{
223	SSL_free(*tls_data);
224	*tls_data = NULL;
225	}
226
227	ssize_t
228	tls_read(tls_data_t tls_data, char buf, size_t bufsize, bool *want_write)
229	{
230	ERR_clear_error();
231
232	SSL ssl = tls_data;
233	ssize_t ret = SSL_read(ssl, buf, bufsize);
234	/* Translate openssl error codes, sigh */
235	if (ret < 0)
236	{
237	switch (SSL_get_error(ssl, ret))
238	{
239	case SSL_ERROR_WANT_WRITE:
240	{
241	/* OpenSSL wants to write, we signal this to the caller and do nothing about that here */
242	*want_write = true;
243	break;
244	}
245	case SSL_ERROR_WANT_READ:
246	errno = EWOULDBLOCK;
247	case SSL_ERROR_SYSCALL:
248	break;
249	case SSL_ERROR_SSL:
250	if (errno == EAGAIN)
251	break;
252	/* Fall through */
253	default:
254	ret = errno = 0;
255	}
256	}
257
258	return ret;
259	}
260
261	ssize_t
262	tls_write(tls_data_t tls_data, const char buf, size_t bufsize, bool *want_read)
263	{
264	ERR_clear_error();
265
266	SSL ssl = tls_data;
267	ssize_t ret = SSL_write(ssl, buf, bufsize);
268	/* Translate openssl error codes, sigh */
269	if (ret < 0)
270	{
271	switch (SSL_get_error(ssl, ret))
272	{
273	case SSL_ERROR_WANT_READ:
274	*want_read = true;
275	break; /* Retry later, don't register for write events */
276	case SSL_ERROR_WANT_WRITE:
277	errno = EWOULDBLOCK;
278	break;
279	case SSL_ERROR_SYSCALL:
280	break;
281	case SSL_ERROR_SSL:
282	if (errno == EAGAIN)
283	break;
284	/* Fall through */
285	default:
286	ret = errno = 0; /* Either an SSL-specific error or EOF */
287	}
288	}
289
290	return ret;
291	}
292
293	void
294	tls_shutdown(tls_data_t *tls_data)
295	{
296	SSL ssl = tls_data;
297
298	SSL_set_shutdown(ssl, SSL_RECEIVED_SHUTDOWN);
299
300	if (SSL_shutdown(ssl) == 0)
301	SSL_shutdown(ssl);
302	}
303
304	bool
305	tls_new(tls_data_t *tls_data, int fd, tls_role_t role)
306	{
307	SSL *ssl;
308
309	if (TLS_initialized == false)
310	return false;
311
312	if (role == TLS_ROLE_SERVER)
313	ssl = SSL_new(ConfigServerInfo.tls_ctx.server_ctx);
314	else
315	ssl = SSL_new(ConfigServerInfo.tls_ctx.client_ctx);
316
317	if (ssl == NULL)
318	{
319	ilog(LOG_TYPE_IRCD, "SSL_new() ERROR! -- %s",
320	ERR_error_string(ERR_get_error(), NULL));
321	return false;
322	}
323
324	*tls_data = ssl;
325	SSL_set_fd(ssl, fd);
326	return true;
327	}
328
329	bool
330	tls_set_ciphers(tls_data_t tls_data, const char cipher_list)
331	{
332	SSL_set_cipher_list(*tls_data, cipher_list);
333	return true;
334	}
335
336	tls_handshake_status_t
337	tls_handshake(tls_data_t tls_data, tls_role_t role, const char *errstr)
338	{
339	SSL ssl = tls_data;
340	int ret;
341
342	ERR_clear_error();
343
344	if (role == TLS_ROLE_SERVER)
345	ret = SSL_accept(ssl);
346	else
347	ret = SSL_connect(ssl);
348
349	if (ret > 0)
350	return TLS_HANDSHAKE_DONE;
351
352	switch (SSL_get_error(ssl, ret))
353	{
354	case SSL_ERROR_WANT_WRITE:
355	return TLS_HANDSHAKE_WANT_WRITE;
356	case SSL_ERROR_WANT_READ:
357	return TLS_HANDSHAKE_WANT_READ;
358	default:
359	{
360	const char *error = ERR_error_string(ERR_get_error(), NULL);
361
362	if (errstr)
363	*errstr = error;
364
365	return TLS_HANDSHAKE_ERROR;
366	}
367	}
368	}
369
370	bool
371	tls_verify_certificate(tls_data_t tls_data, tls_md_t digest, char *fingerprint)
372	{
373	SSL ssl = tls_data;
374	unsigned int n;
375	char buf[EVP_MAX_MD_SIZE * 2 + 1];
376	unsigned char md[EVP_MAX_MD_SIZE];
377	bool ret = false;
378
379	/* Accept NULL return from SSL_get_peer_certificate */
380	X509 *cert = SSL_get_peer_certificate(ssl);
381	if (cert == NULL)
382	return true;
383
384	switch (SSL_get_verify_result(ssl))
385	{
386	case X509_V_OK:
387	case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
388	case X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE:
389	case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
390	ret = true;
391
392	if (X509_digest(cert, digest, md, &n))
393	{
394	binary_to_hex(md, buf, n);
395	*fingerprint = xstrdup(buf);
396	}
397	default:
398	break;
399	}
400
401	X509_free(cert);
402	return ret;
403	}
404	#endif /* HAVE_TLS_OPENSSL */