2008-01-18 22:04:33 +00:00
|
|
|
/*
|
|
|
|
* Asterisk -- An open source telephony toolkit.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2007 - 2008, Digium, Inc.
|
|
|
|
*
|
|
|
|
* Luigi Rizzo (TCP and TLS server code)
|
|
|
|
* Brett Bryant <brettbryant@gmail.com> (updated for client support)
|
|
|
|
*
|
|
|
|
* See http://www.asterisk.org for more information about
|
|
|
|
* the Asterisk project. Please do not directly contact
|
|
|
|
* any of the maintainers of this project for assistance;
|
|
|
|
* the project provides a web site, mailing lists and IRC
|
|
|
|
* channels for your use.
|
|
|
|
*
|
|
|
|
* This program is free software, distributed under the terms of
|
|
|
|
* the GNU General Public License Version 2. See the LICENSE file
|
|
|
|
* at the top of the source tree.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* \file
|
|
|
|
* \brief Code to support TCP and TLS server/client
|
|
|
|
*
|
|
|
|
* \author Luigi Rizzo
|
|
|
|
* \author Brett Bryant <brettbryant@gmail.com>
|
|
|
|
*/
|
|
|
|
|
2012-06-15 16:20:16 +00:00
|
|
|
/*** MODULEINFO
|
|
|
|
<support_level>core</support_level>
|
|
|
|
***/
|
|
|
|
|
2008-01-18 22:04:33 +00:00
|
|
|
#include "asterisk.h"
|
|
|
|
|
|
|
|
#ifdef HAVE_FCNTL_H
|
|
|
|
#include <fcntl.h>
|
|
|
|
#endif
|
|
|
|
|
2010-03-20 12:03:07 +00:00
|
|
|
#include <signal.h>
|
2016-11-15 19:44:13 +00:00
|
|
|
#include <sys/stat.h>
|
2008-01-18 22:04:33 +00:00
|
|
|
|
|
|
|
#include "asterisk/compat.h"
|
|
|
|
#include "asterisk/tcptls.h"
|
|
|
|
#include "asterisk/http.h"
|
|
|
|
#include "asterisk/utils.h"
|
|
|
|
#include "asterisk/strings.h"
|
|
|
|
#include "asterisk/options.h"
|
|
|
|
#include "asterisk/manager.h"
|
2008-10-19 19:11:28 +00:00
|
|
|
#include "asterisk/astobj2.h"
|
2013-12-16 19:11:51 +00:00
|
|
|
#include "asterisk/pbx.h"
|
2016-11-15 19:44:13 +00:00
|
|
|
#include "asterisk/app.h"
|
2008-01-18 22:04:33 +00:00
|
|
|
|
2012-10-12 16:31:01 +00:00
|
|
|
static void session_instance_destructor(void *obj)
|
|
|
|
{
|
|
|
|
struct ast_tcptls_session_instance *i = obj;
|
2014-06-12 17:00:08 +00:00
|
|
|
|
2016-06-02 19:10:06 +00:00
|
|
|
if (i->stream) {
|
|
|
|
ast_iostream_close(i->stream);
|
|
|
|
i->stream = NULL;
|
2014-06-12 17:00:08 +00:00
|
|
|
}
|
2012-10-12 16:31:01 +00:00
|
|
|
ast_free(i->overflow_buf);
|
2014-07-03 17:16:55 +00:00
|
|
|
ao2_cleanup(i->private_data);
|
2012-10-12 16:31:01 +00:00
|
|
|
}
|
|
|
|
|
2015-05-14 22:12:41 +00:00
|
|
|
#ifdef DO_SSL
|
|
|
|
static int check_tcptls_cert_name(ASN1_STRING *cert_str, const char *hostname, const char *desc)
|
|
|
|
{
|
|
|
|
unsigned char *str;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = ASN1_STRING_to_UTF8(&str, cert_str);
|
|
|
|
if (ret < 0 || !str) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strlen((char *) str) != ret) {
|
|
|
|
ast_log(LOG_WARNING, "Invalid certificate %s length (contains NULL bytes?)\n", desc);
|
|
|
|
|
|
|
|
ret = -1;
|
|
|
|
} else if (!strcasecmp(hostname, (char *) str)) {
|
|
|
|
ret = 0;
|
|
|
|
} else {
|
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_debug(3, "SSL %s compare s1='%s' s2='%s'\n", desc, hostname, str);
|
|
|
|
OPENSSL_free(str);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-10-19 19:11:28 +00:00
|
|
|
/*! \brief
|
|
|
|
* creates a FILE * from the fd passed by the accept thread.
|
|
|
|
* This operation is potentially expensive (certificate verification),
|
|
|
|
* so we do it in the child thread context.
|
2009-09-24 20:37:20 +00:00
|
|
|
*
|
|
|
|
* \note must decrement ref count before returning NULL on error
|
2008-10-19 19:11:28 +00:00
|
|
|
*/
|
SIP TCP/TLS: move client connection setup/write into tcp helper thread, various related locking/memory fixes.
What this patch fixes
1.Moves sip TCP/TLS connection setup into the TCP helper thread:
Connection setup takes awhile and before this it was being
done while holding the monitor lock.
2.Moves TCP/TLS writing to the TCP helper thread: Through the
use of a packet queue and an alert pipe, the TCP helper thread
can now be woken up to write data as well as read data.
3.Locking error: sip_xmit returned an XMIT_ERROR without giving
up the tcptls_session lock. This lock has been completely removed
from sip_xmit and placed in the new sip_tcptls_write() function.
4.Memory leak: When creating a tcptls_client the tls_cfg was alloced
but never freed unless the tcptls_session failed to start. Now the
session_args for a sip client are an ao2 object which frees the
tls_cfg on destruction.
5.Pointer to stack variable: During sip_prepare_socket the creation
of a client's ast_tcptls_session_args was done on the stack and
stored as a pointer in the newly created tcptls_session. Depending
on the events that followed, there was a slight possibility that
pointer could have been accessed after the stack returned. Given
the new changes, it is always accessed after the stack returns
which is why I found it.
Notable code changes
1.I broke tcptls.c's ast_tcptls_client_start() function into two
functions. One for creating and allocating the new tcptls_session,
and a separate one for starting and handling the new connection.
This allowed me to create the tcptls_session, launch the helper
thread, and then establish the connection within the helper thread.
2.Writes to a tcptls_session are now done within the helper thread.
This is done by using an alert pipe to wake up the thread if new
data needs to be sent. The thread's sip_threadinfo object contains
the alert pipe as well as the packet queue.
3.Since the threadinfo object contains the alert pipe, it must now be
accessed outside of the helper thread for every write (queuing of a
packet). For easy lookup, I moved the threadinfo objects from a
linked list to an ao2_container.
(closes issue #13136)
Reported by: pabelanger
Tested by: dvossel, whys
(closes issue #15894)
Reported by: dvossel
Tested by: dvossel
Review: https://reviewboard.asterisk.org/r/380/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@225445 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-10-22 19:55:51 +00:00
|
|
|
static void *handle_tcptls_connection(void *data)
|
2008-10-19 19:11:28 +00:00
|
|
|
{
|
2008-12-12 18:45:03 +00:00
|
|
|
struct ast_tcptls_session_instance *tcptls_session = data;
|
2008-10-19 19:11:28 +00:00
|
|
|
#ifdef DO_SSL
|
2016-06-02 19:10:06 +00:00
|
|
|
SSL *ssl;
|
2008-10-19 19:11:28 +00:00
|
|
|
#endif
|
|
|
|
|
2013-12-16 19:11:51 +00:00
|
|
|
/* TCP/TLS connections are associated with external protocols, and
|
|
|
|
* should not be allowed to execute 'dangerous' functions. This may
|
|
|
|
* need to be pushed down into the individual protocol handlers, but
|
|
|
|
* this seems like a good general policy.
|
|
|
|
*/
|
|
|
|
if (ast_thread_inhibit_escalations()) {
|
|
|
|
ast_log(LOG_ERROR, "Failed to inhibit privilege escalations; killing connection\n");
|
2014-01-26 23:04:46 +00:00
|
|
|
ast_tcptls_close_session_file(tcptls_session);
|
|
|
|
ao2_ref(tcptls_session, -1);
|
2013-12-16 19:11:51 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2016-06-02 19:10:06 +00:00
|
|
|
if (tcptls_session->parent->tls_cfg) {
|
|
|
|
#ifdef DO_SSL
|
|
|
|
if (ast_iostream_start_tls(&tcptls_session->stream, tcptls_session->parent->tls_cfg->ssl_ctx, tcptls_session->client) < 0) {
|
|
|
|
ast_tcptls_close_session_file(tcptls_session);
|
|
|
|
ao2_ref(tcptls_session, -1);
|
|
|
|
return NULL;
|
|
|
|
}
|
2014-06-12 17:00:08 +00:00
|
|
|
|
2016-06-02 19:10:06 +00:00
|
|
|
ssl = ast_iostream_get_ssl(tcptls_session->stream);
|
|
|
|
if ((tcptls_session->client && !ast_test_flag(&tcptls_session->parent->tls_cfg->flags, AST_SSL_DONT_VERIFY_SERVER))
|
|
|
|
|| (!tcptls_session->client && ast_test_flag(&tcptls_session->parent->tls_cfg->flags, AST_SSL_VERIFY_CLIENT))) {
|
|
|
|
X509 *peer;
|
|
|
|
long res;
|
|
|
|
peer = SSL_get_peer_certificate(ssl);
|
|
|
|
if (!peer) {
|
|
|
|
ast_log(LOG_ERROR, "No peer SSL certificate to verify\n");
|
2011-11-30 22:03:02 +00:00
|
|
|
ast_tcptls_close_session_file(tcptls_session);
|
2016-06-02 19:10:06 +00:00
|
|
|
ao2_ref(tcptls_session, -1);
|
|
|
|
return NULL;
|
2011-03-16 19:51:55 +00:00
|
|
|
}
|
2012-10-17 19:01:27 +00:00
|
|
|
|
2016-06-02 19:10:06 +00:00
|
|
|
res = SSL_get_verify_result(ssl);
|
|
|
|
if (res != X509_V_OK) {
|
|
|
|
ast_log(LOG_ERROR, "Certificate did not verify: %s\n", X509_verify_cert_error_string(res));
|
|
|
|
X509_free(peer);
|
|
|
|
ast_tcptls_close_session_file(tcptls_session);
|
|
|
|
ao2_ref(tcptls_session, -1);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (!ast_test_flag(&tcptls_session->parent->tls_cfg->flags, AST_SSL_IGNORE_COMMON_NAME)) {
|
|
|
|
ASN1_STRING *str;
|
|
|
|
X509_NAME *name = X509_get_subject_name(peer);
|
|
|
|
STACK_OF(GENERAL_NAME) *alt_names;
|
|
|
|
int pos = -1;
|
|
|
|
int found = 0;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
/* Walk the certificate to check all available "Common Name" */
|
|
|
|
/* XXX Probably should do a gethostbyname on the hostname and compare that as well */
|
|
|
|
pos = X509_NAME_get_index_by_NID(name, NID_commonName, pos);
|
|
|
|
if (pos < 0) {
|
|
|
|
break;
|
2015-05-14 22:12:41 +00:00
|
|
|
}
|
2016-06-02 19:10:06 +00:00
|
|
|
str = X509_NAME_ENTRY_get_data(X509_NAME_get_entry(name, pos));
|
|
|
|
if (!check_tcptls_cert_name(str, tcptls_session->parent->hostname, "common name")) {
|
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2015-05-14 22:12:41 +00:00
|
|
|
|
2016-06-02 19:10:06 +00:00
|
|
|
if (!found) {
|
|
|
|
alt_names = X509_get_ext_d2i(peer, NID_subject_alt_name, NULL, NULL);
|
|
|
|
if (alt_names != NULL) {
|
|
|
|
int alt_names_count = sk_GENERAL_NAME_num(alt_names);
|
2015-05-14 22:12:41 +00:00
|
|
|
|
2016-06-02 19:10:06 +00:00
|
|
|
for (pos = 0; pos < alt_names_count; pos++) {
|
|
|
|
const GENERAL_NAME *alt_name = sk_GENERAL_NAME_value(alt_names, pos);
|
2015-05-14 22:12:41 +00:00
|
|
|
|
2016-06-02 19:10:06 +00:00
|
|
|
if (alt_name->type != GEN_DNS) {
|
|
|
|
continue;
|
2011-11-06 09:51:09 +00:00
|
|
|
}
|
2015-05-14 22:12:41 +00:00
|
|
|
|
2016-06-02 19:10:06 +00:00
|
|
|
if (!check_tcptls_cert_name(alt_name->d.dNSName, tcptls_session->parent->hostname, "alt name")) {
|
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
2011-11-06 09:51:09 +00:00
|
|
|
}
|
2015-05-14 22:12:41 +00:00
|
|
|
|
2016-06-02 19:10:06 +00:00
|
|
|
sk_GENERAL_NAME_pop_free(alt_names, GENERAL_NAME_free);
|
2008-10-19 19:11:28 +00:00
|
|
|
}
|
|
|
|
}
|
2016-06-02 19:10:06 +00:00
|
|
|
|
|
|
|
if (!found) {
|
|
|
|
ast_log(LOG_ERROR, "Certificate common name did not match (%s)\n", tcptls_session->parent->hostname);
|
|
|
|
X509_free(peer);
|
|
|
|
ast_tcptls_close_session_file(tcptls_session);
|
|
|
|
ao2_ref(tcptls_session, -1);
|
|
|
|
return NULL;
|
|
|
|
}
|
2008-10-19 19:11:28 +00:00
|
|
|
}
|
2016-06-02 19:10:06 +00:00
|
|
|
X509_free(peer);
|
2008-10-19 19:11:28 +00:00
|
|
|
}
|
2016-06-02 19:10:06 +00:00
|
|
|
#else
|
|
|
|
ast_log(LOG_ERROR, "Attempted a TLS connection without OpenSSL support. This will not work!\n");
|
2011-11-30 22:03:02 +00:00
|
|
|
ast_tcptls_close_session_file(tcptls_session);
|
2008-12-12 18:45:03 +00:00
|
|
|
ao2_ref(tcptls_session, -1);
|
2008-10-19 19:11:28 +00:00
|
|
|
return NULL;
|
2016-06-02 19:10:06 +00:00
|
|
|
#endif /* DO_SSL */
|
2008-10-19 19:11:28 +00:00
|
|
|
}
|
|
|
|
|
2012-05-31 18:39:30 +00:00
|
|
|
if (tcptls_session->parent->worker_fn) {
|
2008-12-12 18:45:03 +00:00
|
|
|
return tcptls_session->parent->worker_fn(tcptls_session);
|
2011-11-06 09:51:09 +00:00
|
|
|
} else {
|
2008-12-12 18:45:03 +00:00
|
|
|
return tcptls_session;
|
2011-11-06 09:51:09 +00:00
|
|
|
}
|
2008-10-19 19:11:28 +00:00
|
|
|
}
|
|
|
|
|
2008-03-04 22:23:21 +00:00
|
|
|
void *ast_tcptls_server_root(void *data)
|
2008-01-18 22:04:33 +00:00
|
|
|
{
|
2008-10-19 19:11:28 +00:00
|
|
|
struct ast_tcptls_session_args *desc = data;
|
2008-01-18 22:04:33 +00:00
|
|
|
int fd;
|
2010-07-08 22:08:07 +00:00
|
|
|
struct ast_sockaddr addr;
|
2008-12-12 18:45:03 +00:00
|
|
|
struct ast_tcptls_session_instance *tcptls_session;
|
2008-01-18 22:04:33 +00:00
|
|
|
pthread_t launched;
|
2009-04-29 21:13:43 +00:00
|
|
|
|
2008-01-18 22:04:33 +00:00
|
|
|
for (;;) {
|
|
|
|
int i, flags;
|
|
|
|
|
2011-11-06 09:51:09 +00:00
|
|
|
if (desc->periodic_fn) {
|
2008-01-18 22:04:33 +00:00
|
|
|
desc->periodic_fn(desc);
|
2011-11-06 09:51:09 +00:00
|
|
|
}
|
2008-01-18 22:04:33 +00:00
|
|
|
i = ast_wait_for_input(desc->accept_fd, desc->poll_timeout);
|
2011-11-06 09:51:09 +00:00
|
|
|
if (i <= 0) {
|
2017-04-10 22:45:35 +00:00
|
|
|
/* Prevent tight loop from hogging CPU */
|
|
|
|
usleep(1);
|
2008-01-18 22:04:33 +00:00
|
|
|
continue;
|
2011-11-06 09:51:09 +00:00
|
|
|
}
|
2010-07-08 22:08:07 +00:00
|
|
|
fd = ast_accept(desc->accept_fd, &addr);
|
2008-01-18 22:04:33 +00:00
|
|
|
if (fd < 0) {
|
2017-04-10 22:45:35 +00:00
|
|
|
if (errno != EAGAIN
|
|
|
|
&& errno != EWOULDBLOCK
|
|
|
|
&& errno != EINTR
|
|
|
|
&& errno != ECONNABORTED) {
|
|
|
|
ast_log(LOG_ERROR, "TCP/TLS accept failed: %s\n", strerror(errno));
|
|
|
|
if (errno != EMFILE) {
|
|
|
|
break;
|
|
|
|
}
|
2011-11-06 09:51:09 +00:00
|
|
|
}
|
2017-04-10 22:45:35 +00:00
|
|
|
/* Prevent tight loop from hogging CPU */
|
|
|
|
usleep(1);
|
2008-01-18 22:04:33 +00:00
|
|
|
continue;
|
|
|
|
}
|
2012-10-12 16:31:01 +00:00
|
|
|
tcptls_session = ao2_alloc(sizeof(*tcptls_session), session_instance_destructor);
|
2008-12-12 18:45:03 +00:00
|
|
|
if (!tcptls_session) {
|
2017-02-17 22:57:54 +00:00
|
|
|
close(fd);
|
2008-01-18 22:04:33 +00:00
|
|
|
continue;
|
|
|
|
}
|
2008-06-17 21:46:57 +00:00
|
|
|
|
2012-10-12 16:31:01 +00:00
|
|
|
tcptls_session->overflow_buf = ast_str_create(128);
|
2017-02-17 22:57:54 +00:00
|
|
|
if (!tcptls_session->overflow_buf) {
|
|
|
|
ao2_ref(tcptls_session, -1);
|
|
|
|
close(fd);
|
|
|
|
continue;
|
|
|
|
}
|
2008-01-18 22:04:33 +00:00
|
|
|
flags = fcntl(fd, F_GETFL);
|
|
|
|
fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);
|
2016-06-02 19:10:06 +00:00
|
|
|
|
|
|
|
tcptls_session->stream = ast_iostream_from_fd(&fd);
|
|
|
|
if (!tcptls_session->stream) {
|
2017-02-17 22:57:54 +00:00
|
|
|
ao2_ref(tcptls_session, -1);
|
|
|
|
close(fd);
|
2016-06-02 19:10:06 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2008-12-12 18:45:03 +00:00
|
|
|
tcptls_session->parent = desc;
|
2010-07-08 22:08:07 +00:00
|
|
|
ast_sockaddr_copy(&tcptls_session->remote_address, &addr);
|
2008-01-18 22:04:33 +00:00
|
|
|
|
2008-12-12 18:45:03 +00:00
|
|
|
tcptls_session->client = 0;
|
2009-04-29 21:13:43 +00:00
|
|
|
|
2009-09-24 20:37:20 +00:00
|
|
|
/* This thread is now the only place that controls the single ref to tcptls_session */
|
SIP TCP/TLS: move client connection setup/write into tcp helper thread, various related locking/memory fixes.
What this patch fixes
1.Moves sip TCP/TLS connection setup into the TCP helper thread:
Connection setup takes awhile and before this it was being
done while holding the monitor lock.
2.Moves TCP/TLS writing to the TCP helper thread: Through the
use of a packet queue and an alert pipe, the TCP helper thread
can now be woken up to write data as well as read data.
3.Locking error: sip_xmit returned an XMIT_ERROR without giving
up the tcptls_session lock. This lock has been completely removed
from sip_xmit and placed in the new sip_tcptls_write() function.
4.Memory leak: When creating a tcptls_client the tls_cfg was alloced
but never freed unless the tcptls_session failed to start. Now the
session_args for a sip client are an ao2 object which frees the
tls_cfg on destruction.
5.Pointer to stack variable: During sip_prepare_socket the creation
of a client's ast_tcptls_session_args was done on the stack and
stored as a pointer in the newly created tcptls_session. Depending
on the events that followed, there was a slight possibility that
pointer could have been accessed after the stack returned. Given
the new changes, it is always accessed after the stack returns
which is why I found it.
Notable code changes
1.I broke tcptls.c's ast_tcptls_client_start() function into two
functions. One for creating and allocating the new tcptls_session,
and a separate one for starting and handling the new connection.
This allowed me to create the tcptls_session, launch the helper
thread, and then establish the connection within the helper thread.
2.Writes to a tcptls_session are now done within the helper thread.
This is done by using an alert pipe to wake up the thread if new
data needs to be sent. The thread's sip_threadinfo object contains
the alert pipe as well as the packet queue.
3.Since the threadinfo object contains the alert pipe, it must now be
accessed outside of the helper thread for every write (queuing of a
packet). For easy lookup, I moved the threadinfo objects from a
linked list to an ao2_container.
(closes issue #13136)
Reported by: pabelanger
Tested by: dvossel, whys
(closes issue #15894)
Reported by: dvossel
Tested by: dvossel
Review: https://reviewboard.asterisk.org/r/380/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@225445 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-10-22 19:55:51 +00:00
|
|
|
if (ast_pthread_create_detached_background(&launched, NULL, handle_tcptls_connection, tcptls_session)) {
|
2017-04-10 22:45:35 +00:00
|
|
|
ast_log(LOG_ERROR, "TCP/TLS unable to launch helper thread: %s\n",
|
|
|
|
strerror(errno));
|
2008-12-12 18:45:03 +00:00
|
|
|
ao2_ref(tcptls_session, -1);
|
2008-01-18 22:04:33 +00:00
|
|
|
}
|
|
|
|
}
|
2017-04-10 22:45:35 +00:00
|
|
|
|
|
|
|
ast_log(LOG_ERROR, "TCP/TLS listener thread ended abnormally\n");
|
|
|
|
|
|
|
|
/* Close the listener socket so Asterisk doesn't appear dead. */
|
|
|
|
fd = desc->accept_fd;
|
|
|
|
desc->accept_fd = -1;
|
|
|
|
if (0 <= fd) {
|
|
|
|
close(fd);
|
|
|
|
}
|
2008-01-18 22:04:33 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-06-02 16:35:39 +00:00
|
|
|
#ifdef DO_SSL
|
2015-05-10 14:55:24 +00:00
|
|
|
static void __ssl_setup_certs(struct ast_tls_config *cfg, const size_t cert_file_len, const char *key_type_extension, const char *key_type)
|
|
|
|
{
|
|
|
|
char *cert_file = ast_strdupa(cfg->certfile);
|
|
|
|
|
|
|
|
memcpy(cert_file + cert_file_len - 8, key_type_extension, 5);
|
|
|
|
if (access(cert_file, F_OK) == 0) {
|
|
|
|
if (SSL_CTX_use_certificate_chain_file(cfg->ssl_ctx, cert_file) == 0) {
|
|
|
|
ast_log(LOG_WARNING, "TLS/SSL error loading public %s key (certificate) from <%s>.\n", key_type, cert_file);
|
|
|
|
} else if (SSL_CTX_use_PrivateKey_file(cfg->ssl_ctx, cert_file, SSL_FILETYPE_PEM) == 0) {
|
|
|
|
ast_log(LOG_WARNING, "TLS/SSL error loading private %s key from <%s>.\n", key_type, cert_file);
|
|
|
|
} else if (SSL_CTX_check_private_key(cfg->ssl_ctx) == 0) {
|
|
|
|
ast_log(LOG_WARNING, "TLS/SSL error matching private %s key and certificate in <%s>.\n", key_type, cert_file);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-06-02 16:35:39 +00:00
|
|
|
#endif
|
2015-05-10 14:55:24 +00:00
|
|
|
|
2008-01-18 22:04:33 +00:00
|
|
|
static int __ssl_setup(struct ast_tls_config *cfg, int client)
|
|
|
|
{
|
|
|
|
#ifndef DO_SSL
|
|
|
|
cfg->enabled = 0;
|
|
|
|
return 0;
|
|
|
|
#else
|
AST-2014-011: Fix POODLE security issues
There are two aspects to the vulnerability:
(1) res_jabber/res_xmpp use SSLv3 only. This patch updates the module to use
TLSv1+. At this time, it does not refactor res_jabber/res_xmpp to use the
TCP/TLS core, which should be done as an improvement at a latter date.
(2) The TCP/TLS core, when tlsclientmethod/sslclientmethod is left unspecified,
will default to the OpenSSL SSLv23_method. This method allows for all
ecnryption methods, including SSLv2/SSLv3. A MITM can exploit this by
forcing a fallback to SSLv3, which leaves the server vulnerable to POODLE.
This patch adds WARNINGS if a user uses SSLv2/SSLv3 in their configuration,
and explicitly disables SSLv2/SSLv3 if using SSLv23_method.
For TLS clients, Asterisk will default to TLSv1+ and WARN if SSLv2 or SSLv3 is
explicitly chosen. For TLS servers, Asterisk will no longer support SSLv2 or
SSLv3.
Much thanks to abelbeck for reporting the vulnerability and providing a patch
for the res_jabber/res_xmpp modules.
Review: https://reviewboard.asterisk.org/r/4096/
ASTERISK-24425 #close
Reported by: abelbeck
Tested by: abelbeck, opsmonitor, gtjoseph
patches:
asterisk-1.8-jabber-tls.patch uploaded by abelbeck (License 5903)
asterisk-11-jabber-xmpp-tls.patch uploaded by abelbeck (License 5903)
AST-2014-011-1.8.diff uploaded by mjordan (License 6283)
AST-2014-011-11.diff uploaded by mjordan (License 6283)
........
Merged revisions 425987 from http://svn.asterisk.org/svn/asterisk/branches/12
........
Merged revisions 425991 from http://svn.asterisk.org/svn/asterisk/branches/13
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@426003 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-10-20 14:20:15 +00:00
|
|
|
int disable_ssl = 0;
|
2016-02-03 18:05:20 +00:00
|
|
|
long ssl_opts = 0;
|
|
|
|
|
2011-11-06 09:51:09 +00:00
|
|
|
if (!cfg->enabled) {
|
2008-01-18 22:04:33 +00:00
|
|
|
return 0;
|
2011-11-06 09:51:09 +00:00
|
|
|
}
|
2008-01-18 22:04:33 +00:00
|
|
|
|
2012-05-18 17:24:57 +00:00
|
|
|
/* Get rid of an old SSL_CTX since we're about to
|
|
|
|
* allocate a new one
|
|
|
|
*/
|
|
|
|
if (cfg->ssl_ctx) {
|
|
|
|
SSL_CTX_free(cfg->ssl_ctx);
|
|
|
|
cfg->ssl_ctx = NULL;
|
|
|
|
}
|
|
|
|
|
2009-04-29 21:13:43 +00:00
|
|
|
if (client) {
|
2016-06-28 21:26:59 +00:00
|
|
|
#if !defined(OPENSSL_NO_SSL2) && (OPENSSL_VERSION_NUMBER < 0x10100000L)
|
2009-04-29 21:13:43 +00:00
|
|
|
if (ast_test_flag(&cfg->flags, AST_SSL_SSLV2_CLIENT)) {
|
AST-2014-011: Fix POODLE security issues
There are two aspects to the vulnerability:
(1) res_jabber/res_xmpp use SSLv3 only. This patch updates the module to use
TLSv1+. At this time, it does not refactor res_jabber/res_xmpp to use the
TCP/TLS core, which should be done as an improvement at a latter date.
(2) The TCP/TLS core, when tlsclientmethod/sslclientmethod is left unspecified,
will default to the OpenSSL SSLv23_method. This method allows for all
ecnryption methods, including SSLv2/SSLv3. A MITM can exploit this by
forcing a fallback to SSLv3, which leaves the server vulnerable to POODLE.
This patch adds WARNINGS if a user uses SSLv2/SSLv3 in their configuration,
and explicitly disables SSLv2/SSLv3 if using SSLv23_method.
For TLS clients, Asterisk will default to TLSv1+ and WARN if SSLv2 or SSLv3 is
explicitly chosen. For TLS servers, Asterisk will no longer support SSLv2 or
SSLv3.
Much thanks to abelbeck for reporting the vulnerability and providing a patch
for the res_jabber/res_xmpp modules.
Review: https://reviewboard.asterisk.org/r/4096/
ASTERISK-24425 #close
Reported by: abelbeck
Tested by: abelbeck, opsmonitor, gtjoseph
patches:
asterisk-1.8-jabber-tls.patch uploaded by abelbeck (License 5903)
asterisk-11-jabber-xmpp-tls.patch uploaded by abelbeck (License 5903)
AST-2014-011-1.8.diff uploaded by mjordan (License 6283)
AST-2014-011-11.diff uploaded by mjordan (License 6283)
........
Merged revisions 425987 from http://svn.asterisk.org/svn/asterisk/branches/12
........
Merged revisions 425991 from http://svn.asterisk.org/svn/asterisk/branches/13
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@426003 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-10-20 14:20:15 +00:00
|
|
|
ast_log(LOG_WARNING, "Usage of SSLv2 is discouraged due to known vulnerabilities. Please use 'tlsv1' or leave the TLS method unspecified!\n");
|
2009-04-29 21:13:43 +00:00
|
|
|
cfg->ssl_ctx = SSL_CTX_new(SSLv2_client_method());
|
2011-04-19 15:42:32 +00:00
|
|
|
} else
|
|
|
|
#endif
|
2015-02-19 15:28:56 +00:00
|
|
|
#ifndef OPENSSL_NO_SSL3_METHOD
|
2011-04-19 15:42:32 +00:00
|
|
|
if (ast_test_flag(&cfg->flags, AST_SSL_SSLV3_CLIENT)) {
|
AST-2014-011: Fix POODLE security issues
There are two aspects to the vulnerability:
(1) res_jabber/res_xmpp use SSLv3 only. This patch updates the module to use
TLSv1+. At this time, it does not refactor res_jabber/res_xmpp to use the
TCP/TLS core, which should be done as an improvement at a latter date.
(2) The TCP/TLS core, when tlsclientmethod/sslclientmethod is left unspecified,
will default to the OpenSSL SSLv23_method. This method allows for all
ecnryption methods, including SSLv2/SSLv3. A MITM can exploit this by
forcing a fallback to SSLv3, which leaves the server vulnerable to POODLE.
This patch adds WARNINGS if a user uses SSLv2/SSLv3 in their configuration,
and explicitly disables SSLv2/SSLv3 if using SSLv23_method.
For TLS clients, Asterisk will default to TLSv1+ and WARN if SSLv2 or SSLv3 is
explicitly chosen. For TLS servers, Asterisk will no longer support SSLv2 or
SSLv3.
Much thanks to abelbeck for reporting the vulnerability and providing a patch
for the res_jabber/res_xmpp modules.
Review: https://reviewboard.asterisk.org/r/4096/
ASTERISK-24425 #close
Reported by: abelbeck
Tested by: abelbeck, opsmonitor, gtjoseph
patches:
asterisk-1.8-jabber-tls.patch uploaded by abelbeck (License 5903)
asterisk-11-jabber-xmpp-tls.patch uploaded by abelbeck (License 5903)
AST-2014-011-1.8.diff uploaded by mjordan (License 6283)
AST-2014-011-11.diff uploaded by mjordan (License 6283)
........
Merged revisions 425987 from http://svn.asterisk.org/svn/asterisk/branches/12
........
Merged revisions 425991 from http://svn.asterisk.org/svn/asterisk/branches/13
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@426003 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-10-20 14:20:15 +00:00
|
|
|
ast_log(LOG_WARNING, "Usage of SSLv3 is discouraged due to known vulnerabilities. Please use 'tlsv1' or leave the TLS method unspecified!\n");
|
2009-04-29 21:13:43 +00:00
|
|
|
cfg->ssl_ctx = SSL_CTX_new(SSLv3_client_method());
|
2015-02-19 15:28:56 +00:00
|
|
|
} else
|
|
|
|
#endif
|
2017-01-21 05:59:15 +00:00
|
|
|
#if defined(OPENSSL_VERSION_NUMBER) && (OPENSSL_VERSION_NUMBER >= 0x10100000L)
|
|
|
|
cfg->ssl_ctx = SSL_CTX_new(TLS_client_method());
|
|
|
|
#else
|
2015-02-19 15:28:56 +00:00
|
|
|
if (ast_test_flag(&cfg->flags, AST_SSL_TLSV1_CLIENT)) {
|
2009-04-29 21:13:43 +00:00
|
|
|
cfg->ssl_ctx = SSL_CTX_new(TLSv1_client_method());
|
|
|
|
} else {
|
AST-2014-011: Fix POODLE security issues
There are two aspects to the vulnerability:
(1) res_jabber/res_xmpp use SSLv3 only. This patch updates the module to use
TLSv1+. At this time, it does not refactor res_jabber/res_xmpp to use the
TCP/TLS core, which should be done as an improvement at a latter date.
(2) The TCP/TLS core, when tlsclientmethod/sslclientmethod is left unspecified,
will default to the OpenSSL SSLv23_method. This method allows for all
ecnryption methods, including SSLv2/SSLv3. A MITM can exploit this by
forcing a fallback to SSLv3, which leaves the server vulnerable to POODLE.
This patch adds WARNINGS if a user uses SSLv2/SSLv3 in their configuration,
and explicitly disables SSLv2/SSLv3 if using SSLv23_method.
For TLS clients, Asterisk will default to TLSv1+ and WARN if SSLv2 or SSLv3 is
explicitly chosen. For TLS servers, Asterisk will no longer support SSLv2 or
SSLv3.
Much thanks to abelbeck for reporting the vulnerability and providing a patch
for the res_jabber/res_xmpp modules.
Review: https://reviewboard.asterisk.org/r/4096/
ASTERISK-24425 #close
Reported by: abelbeck
Tested by: abelbeck, opsmonitor, gtjoseph
patches:
asterisk-1.8-jabber-tls.patch uploaded by abelbeck (License 5903)
asterisk-11-jabber-xmpp-tls.patch uploaded by abelbeck (License 5903)
AST-2014-011-1.8.diff uploaded by mjordan (License 6283)
AST-2014-011-11.diff uploaded by mjordan (License 6283)
........
Merged revisions 425987 from http://svn.asterisk.org/svn/asterisk/branches/12
........
Merged revisions 425991 from http://svn.asterisk.org/svn/asterisk/branches/13
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@426003 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-10-20 14:20:15 +00:00
|
|
|
disable_ssl = 1;
|
2009-04-29 21:13:43 +00:00
|
|
|
cfg->ssl_ctx = SSL_CTX_new(SSLv23_client_method());
|
|
|
|
}
|
2017-01-21 05:59:15 +00:00
|
|
|
#endif
|
2009-04-29 21:13:43 +00:00
|
|
|
} else {
|
AST-2014-011: Fix POODLE security issues
There are two aspects to the vulnerability:
(1) res_jabber/res_xmpp use SSLv3 only. This patch updates the module to use
TLSv1+. At this time, it does not refactor res_jabber/res_xmpp to use the
TCP/TLS core, which should be done as an improvement at a latter date.
(2) The TCP/TLS core, when tlsclientmethod/sslclientmethod is left unspecified,
will default to the OpenSSL SSLv23_method. This method allows for all
ecnryption methods, including SSLv2/SSLv3. A MITM can exploit this by
forcing a fallback to SSLv3, which leaves the server vulnerable to POODLE.
This patch adds WARNINGS if a user uses SSLv2/SSLv3 in their configuration,
and explicitly disables SSLv2/SSLv3 if using SSLv23_method.
For TLS clients, Asterisk will default to TLSv1+ and WARN if SSLv2 or SSLv3 is
explicitly chosen. For TLS servers, Asterisk will no longer support SSLv2 or
SSLv3.
Much thanks to abelbeck for reporting the vulnerability and providing a patch
for the res_jabber/res_xmpp modules.
Review: https://reviewboard.asterisk.org/r/4096/
ASTERISK-24425 #close
Reported by: abelbeck
Tested by: abelbeck, opsmonitor, gtjoseph
patches:
asterisk-1.8-jabber-tls.patch uploaded by abelbeck (License 5903)
asterisk-11-jabber-xmpp-tls.patch uploaded by abelbeck (License 5903)
AST-2014-011-1.8.diff uploaded by mjordan (License 6283)
AST-2014-011-11.diff uploaded by mjordan (License 6283)
........
Merged revisions 425987 from http://svn.asterisk.org/svn/asterisk/branches/12
........
Merged revisions 425991 from http://svn.asterisk.org/svn/asterisk/branches/13
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@426003 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-10-20 14:20:15 +00:00
|
|
|
disable_ssl = 1;
|
2009-04-29 21:13:43 +00:00
|
|
|
cfg->ssl_ctx = SSL_CTX_new(SSLv23_server_method());
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!cfg->ssl_ctx) {
|
2008-01-22 08:58:46 +00:00
|
|
|
ast_debug(1, "Sorry, SSL_CTX_new call returned null...\n");
|
2008-01-18 22:04:33 +00:00
|
|
|
cfg->enabled = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
2013-03-15 12:53:03 +00:00
|
|
|
|
AST-2014-011: Fix POODLE security issues
There are two aspects to the vulnerability:
(1) res_jabber/res_xmpp use SSLv3 only. This patch updates the module to use
TLSv1+. At this time, it does not refactor res_jabber/res_xmpp to use the
TCP/TLS core, which should be done as an improvement at a latter date.
(2) The TCP/TLS core, when tlsclientmethod/sslclientmethod is left unspecified,
will default to the OpenSSL SSLv23_method. This method allows for all
ecnryption methods, including SSLv2/SSLv3. A MITM can exploit this by
forcing a fallback to SSLv3, which leaves the server vulnerable to POODLE.
This patch adds WARNINGS if a user uses SSLv2/SSLv3 in their configuration,
and explicitly disables SSLv2/SSLv3 if using SSLv23_method.
For TLS clients, Asterisk will default to TLSv1+ and WARN if SSLv2 or SSLv3 is
explicitly chosen. For TLS servers, Asterisk will no longer support SSLv2 or
SSLv3.
Much thanks to abelbeck for reporting the vulnerability and providing a patch
for the res_jabber/res_xmpp modules.
Review: https://reviewboard.asterisk.org/r/4096/
ASTERISK-24425 #close
Reported by: abelbeck
Tested by: abelbeck, opsmonitor, gtjoseph
patches:
asterisk-1.8-jabber-tls.patch uploaded by abelbeck (License 5903)
asterisk-11-jabber-xmpp-tls.patch uploaded by abelbeck (License 5903)
AST-2014-011-1.8.diff uploaded by mjordan (License 6283)
AST-2014-011-11.diff uploaded by mjordan (License 6283)
........
Merged revisions 425987 from http://svn.asterisk.org/svn/asterisk/branches/12
........
Merged revisions 425991 from http://svn.asterisk.org/svn/asterisk/branches/13
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@426003 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-10-20 14:20:15 +00:00
|
|
|
/* Due to the POODLE vulnerability, completely disable
|
|
|
|
* SSLv2 and SSLv3 if we are not explicitly told to use
|
|
|
|
* them. SSLv23_*_method supports TLSv1+.
|
|
|
|
*/
|
|
|
|
if (disable_ssl) {
|
2016-02-03 18:05:20 +00:00
|
|
|
ssl_opts |= SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ast_test_flag(&cfg->flags, AST_SSL_SERVER_CIPHER_ORDER)) {
|
|
|
|
ssl_opts |= SSL_OP_CIPHER_SERVER_PREFERENCE;
|
|
|
|
}
|
AST-2014-011: Fix POODLE security issues
There are two aspects to the vulnerability:
(1) res_jabber/res_xmpp use SSLv3 only. This patch updates the module to use
TLSv1+. At this time, it does not refactor res_jabber/res_xmpp to use the
TCP/TLS core, which should be done as an improvement at a latter date.
(2) The TCP/TLS core, when tlsclientmethod/sslclientmethod is left unspecified,
will default to the OpenSSL SSLv23_method. This method allows for all
ecnryption methods, including SSLv2/SSLv3. A MITM can exploit this by
forcing a fallback to SSLv3, which leaves the server vulnerable to POODLE.
This patch adds WARNINGS if a user uses SSLv2/SSLv3 in their configuration,
and explicitly disables SSLv2/SSLv3 if using SSLv23_method.
For TLS clients, Asterisk will default to TLSv1+ and WARN if SSLv2 or SSLv3 is
explicitly chosen. For TLS servers, Asterisk will no longer support SSLv2 or
SSLv3.
Much thanks to abelbeck for reporting the vulnerability and providing a patch
for the res_jabber/res_xmpp modules.
Review: https://reviewboard.asterisk.org/r/4096/
ASTERISK-24425 #close
Reported by: abelbeck
Tested by: abelbeck, opsmonitor, gtjoseph
patches:
asterisk-1.8-jabber-tls.patch uploaded by abelbeck (License 5903)
asterisk-11-jabber-xmpp-tls.patch uploaded by abelbeck (License 5903)
AST-2014-011-1.8.diff uploaded by mjordan (License 6283)
AST-2014-011-11.diff uploaded by mjordan (License 6283)
........
Merged revisions 425987 from http://svn.asterisk.org/svn/asterisk/branches/12
........
Merged revisions 425991 from http://svn.asterisk.org/svn/asterisk/branches/13
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@426003 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-10-20 14:20:15 +00:00
|
|
|
|
2016-02-03 18:05:20 +00:00
|
|
|
if (ast_test_flag(&cfg->flags, AST_SSL_DISABLE_TLSV1)) {
|
|
|
|
ssl_opts |= SSL_OP_NO_TLSv1;
|
AST-2014-011: Fix POODLE security issues
There are two aspects to the vulnerability:
(1) res_jabber/res_xmpp use SSLv3 only. This patch updates the module to use
TLSv1+. At this time, it does not refactor res_jabber/res_xmpp to use the
TCP/TLS core, which should be done as an improvement at a latter date.
(2) The TCP/TLS core, when tlsclientmethod/sslclientmethod is left unspecified,
will default to the OpenSSL SSLv23_method. This method allows for all
ecnryption methods, including SSLv2/SSLv3. A MITM can exploit this by
forcing a fallback to SSLv3, which leaves the server vulnerable to POODLE.
This patch adds WARNINGS if a user uses SSLv2/SSLv3 in their configuration,
and explicitly disables SSLv2/SSLv3 if using SSLv23_method.
For TLS clients, Asterisk will default to TLSv1+ and WARN if SSLv2 or SSLv3 is
explicitly chosen. For TLS servers, Asterisk will no longer support SSLv2 or
SSLv3.
Much thanks to abelbeck for reporting the vulnerability and providing a patch
for the res_jabber/res_xmpp modules.
Review: https://reviewboard.asterisk.org/r/4096/
ASTERISK-24425 #close
Reported by: abelbeck
Tested by: abelbeck, opsmonitor, gtjoseph
patches:
asterisk-1.8-jabber-tls.patch uploaded by abelbeck (License 5903)
asterisk-11-jabber-xmpp-tls.patch uploaded by abelbeck (License 5903)
AST-2014-011-1.8.diff uploaded by mjordan (License 6283)
AST-2014-011-11.diff uploaded by mjordan (License 6283)
........
Merged revisions 425987 from http://svn.asterisk.org/svn/asterisk/branches/12
........
Merged revisions 425991 from http://svn.asterisk.org/svn/asterisk/branches/13
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@426003 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-10-20 14:20:15 +00:00
|
|
|
}
|
2016-02-04 22:17:55 +00:00
|
|
|
#if defined(HAVE_SSL_OP_NO_TLSV1_1) && defined(HAVE_SSL_OP_NO_TLSV1_2)
|
2016-02-03 18:05:20 +00:00
|
|
|
if (ast_test_flag(&cfg->flags, AST_SSL_DISABLE_TLSV11)) {
|
|
|
|
ssl_opts |= SSL_OP_NO_TLSv1_1;
|
|
|
|
}
|
|
|
|
if (ast_test_flag(&cfg->flags, AST_SSL_DISABLE_TLSV12)) {
|
|
|
|
ssl_opts |= SSL_OP_NO_TLSv1_2;
|
|
|
|
}
|
2016-02-04 22:17:55 +00:00
|
|
|
#else
|
|
|
|
ast_log(LOG_WARNING, "Your version of OpenSSL leaves you potentially vulnerable "
|
|
|
|
"to the SSL BEAST attack. Please upgrade to OpenSSL 1.0.1 or later\n");
|
|
|
|
#endif
|
2016-02-03 18:05:20 +00:00
|
|
|
|
|
|
|
SSL_CTX_set_options(cfg->ssl_ctx, ssl_opts);
|
AST-2014-011: Fix POODLE security issues
There are two aspects to the vulnerability:
(1) res_jabber/res_xmpp use SSLv3 only. This patch updates the module to use
TLSv1+. At this time, it does not refactor res_jabber/res_xmpp to use the
TCP/TLS core, which should be done as an improvement at a latter date.
(2) The TCP/TLS core, when tlsclientmethod/sslclientmethod is left unspecified,
will default to the OpenSSL SSLv23_method. This method allows for all
ecnryption methods, including SSLv2/SSLv3. A MITM can exploit this by
forcing a fallback to SSLv3, which leaves the server vulnerable to POODLE.
This patch adds WARNINGS if a user uses SSLv2/SSLv3 in their configuration,
and explicitly disables SSLv2/SSLv3 if using SSLv23_method.
For TLS clients, Asterisk will default to TLSv1+ and WARN if SSLv2 or SSLv3 is
explicitly chosen. For TLS servers, Asterisk will no longer support SSLv2 or
SSLv3.
Much thanks to abelbeck for reporting the vulnerability and providing a patch
for the res_jabber/res_xmpp modules.
Review: https://reviewboard.asterisk.org/r/4096/
ASTERISK-24425 #close
Reported by: abelbeck
Tested by: abelbeck, opsmonitor, gtjoseph
patches:
asterisk-1.8-jabber-tls.patch uploaded by abelbeck (License 5903)
asterisk-11-jabber-xmpp-tls.patch uploaded by abelbeck (License 5903)
AST-2014-011-1.8.diff uploaded by mjordan (License 6283)
AST-2014-011-11.diff uploaded by mjordan (License 6283)
........
Merged revisions 425987 from http://svn.asterisk.org/svn/asterisk/branches/12
........
Merged revisions 425991 from http://svn.asterisk.org/svn/asterisk/branches/13
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@426003 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-10-20 14:20:15 +00:00
|
|
|
|
2013-03-15 12:53:03 +00:00
|
|
|
SSL_CTX_set_verify(cfg->ssl_ctx,
|
|
|
|
ast_test_flag(&cfg->flags, AST_SSL_VERIFY_CLIENT) ? SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT : SSL_VERIFY_NONE,
|
|
|
|
NULL);
|
|
|
|
|
2008-01-18 22:04:33 +00:00
|
|
|
if (!ast_strlen_zero(cfg->certfile)) {
|
2009-04-24 21:22:31 +00:00
|
|
|
char *tmpprivate = ast_strlen_zero(cfg->pvtfile) ? cfg->certfile : cfg->pvtfile;
|
2014-02-04 18:16:09 +00:00
|
|
|
if (SSL_CTX_use_certificate_chain_file(cfg->ssl_ctx, cfg->certfile) == 0) {
|
2008-01-18 22:04:33 +00:00
|
|
|
if (!client) {
|
|
|
|
/* Clients don't need a certificate, but if its setup we can use it */
|
2014-04-27 19:29:27 +00:00
|
|
|
ast_log(LOG_ERROR, "TLS/SSL error loading cert file. <%s>\n", cfg->certfile);
|
2009-04-24 21:22:31 +00:00
|
|
|
cfg->enabled = 0;
|
2012-05-18 17:24:57 +00:00
|
|
|
SSL_CTX_free(cfg->ssl_ctx);
|
|
|
|
cfg->ssl_ctx = NULL;
|
2009-04-24 21:22:31 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ((SSL_CTX_use_PrivateKey_file(cfg->ssl_ctx, tmpprivate, SSL_FILETYPE_PEM) == 0) || (SSL_CTX_check_private_key(cfg->ssl_ctx) == 0 )) {
|
|
|
|
if (!client) {
|
|
|
|
/* Clients don't need a private key, but if its setup we can use it */
|
2014-04-27 19:29:27 +00:00
|
|
|
ast_log(LOG_ERROR, "TLS/SSL error loading private key file. <%s>\n", tmpprivate);
|
2008-01-18 22:04:33 +00:00
|
|
|
cfg->enabled = 0;
|
2012-05-18 17:24:57 +00:00
|
|
|
SSL_CTX_free(cfg->ssl_ctx);
|
|
|
|
cfg->ssl_ctx = NULL;
|
2008-01-18 22:04:33 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
2015-05-10 14:55:24 +00:00
|
|
|
if (!client) {
|
|
|
|
size_t certfile_len = strlen(cfg->certfile);
|
|
|
|
|
|
|
|
/* expects a file name which contains _rsa. like asterisk_rsa.pem
|
|
|
|
* ignores any 3-character file-extension like .pem, .cer, .crt
|
|
|
|
*/
|
|
|
|
if (certfile_len >= 8 && !strncmp(cfg->certfile + certfile_len - 8, "_rsa.", 5)) {
|
|
|
|
__ssl_setup_certs(cfg, certfile_len, "_ecc.", "ECC");
|
|
|
|
__ssl_setup_certs(cfg, certfile_len, "_dsa.", "DSA");
|
|
|
|
}
|
|
|
|
}
|
2008-01-18 22:04:33 +00:00
|
|
|
}
|
|
|
|
if (!ast_strlen_zero(cfg->cipher)) {
|
|
|
|
if (SSL_CTX_set_cipher_list(cfg->ssl_ctx, cfg->cipher) == 0 ) {
|
|
|
|
if (!client) {
|
2014-04-27 19:29:27 +00:00
|
|
|
ast_log(LOG_ERROR, "TLS/SSL cipher error <%s>\n", cfg->cipher);
|
2008-01-18 22:04:33 +00:00
|
|
|
cfg->enabled = 0;
|
2012-05-18 17:24:57 +00:00
|
|
|
SSL_CTX_free(cfg->ssl_ctx);
|
|
|
|
cfg->ssl_ctx = NULL;
|
2008-01-18 22:04:33 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!ast_strlen_zero(cfg->cafile) || !ast_strlen_zero(cfg->capath)) {
|
2011-11-06 09:51:09 +00:00
|
|
|
if (SSL_CTX_load_verify_locations(cfg->ssl_ctx, S_OR(cfg->cafile, NULL), S_OR(cfg->capath,NULL)) == 0) {
|
2014-04-27 19:29:27 +00:00
|
|
|
ast_log(LOG_ERROR, "TLS/SSL CA file(%s)/path(%s) error\n", cfg->cafile, cfg->capath);
|
2011-11-06 09:51:09 +00:00
|
|
|
}
|
2008-01-18 22:04:33 +00:00
|
|
|
}
|
|
|
|
|
2014-07-03 16:55:44 +00:00
|
|
|
#ifdef HAVE_OPENSSL_EC
|
|
|
|
|
2014-07-03 12:10:17 +00:00
|
|
|
if (!ast_strlen_zero(cfg->pvtfile)) {
|
|
|
|
BIO *bio = BIO_new_file(cfg->pvtfile, "r");
|
|
|
|
if (bio != NULL) {
|
|
|
|
DH *dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
|
|
|
|
if (dh != NULL) {
|
|
|
|
if (SSL_CTX_set_tmp_dh(cfg->ssl_ctx, dh)) {
|
|
|
|
long options = SSL_OP_CIPHER_SERVER_PREFERENCE | SSL_OP_SINGLE_DH_USE | SSL_OP_SINGLE_ECDH_USE;
|
|
|
|
options = SSL_CTX_set_options(cfg->ssl_ctx, options);
|
|
|
|
ast_verb(2, "TLS/SSL DH initialized, PFS cipher-suites enabled\n");
|
|
|
|
}
|
|
|
|
DH_free(dh);
|
|
|
|
}
|
|
|
|
BIO_free(bio);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#ifndef SSL_CTRL_SET_ECDH_AUTO
|
|
|
|
#define SSL_CTRL_SET_ECDH_AUTO 94
|
|
|
|
#endif
|
|
|
|
/* SSL_CTX_set_ecdh_auto(cfg->ssl_ctx, on); requires OpenSSL 1.0.2 which wraps: */
|
|
|
|
if (SSL_CTX_ctrl(cfg->ssl_ctx, SSL_CTRL_SET_ECDH_AUTO, 1, NULL)) {
|
|
|
|
ast_verb(2, "TLS/SSL ECDH initialized (automatic), faster PFS ciphers enabled\n");
|
|
|
|
} else {
|
|
|
|
/* enables AES-128 ciphers, to get AES-256 use NID_secp384r1 */
|
|
|
|
EC_KEY *ecdh = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
|
|
|
|
if (ecdh != NULL) {
|
|
|
|
if (SSL_CTX_set_tmp_ecdh(cfg->ssl_ctx, ecdh)) {
|
|
|
|
ast_verb(2, "TLS/SSL ECDH initialized (secp256r1), faster PFS cipher-suites enabled\n");
|
|
|
|
}
|
|
|
|
EC_KEY_free(ecdh);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-03 16:55:44 +00:00
|
|
|
#endif /* #ifdef HAVE_OPENSSL_EC */
|
|
|
|
|
2014-04-27 19:29:27 +00:00
|
|
|
ast_verb(2, "TLS/SSL certificate ok\n"); /* We should log which one that is ok. This message doesn't really make sense in production use */
|
2008-01-18 22:04:33 +00:00
|
|
|
return 1;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2008-03-04 22:23:21 +00:00
|
|
|
int ast_ssl_setup(struct ast_tls_config *cfg)
|
2008-01-18 22:04:33 +00:00
|
|
|
{
|
|
|
|
return __ssl_setup(cfg, 0);
|
|
|
|
}
|
|
|
|
|
2012-05-18 17:24:57 +00:00
|
|
|
void ast_ssl_teardown(struct ast_tls_config *cfg)
|
|
|
|
{
|
2012-05-23 20:30:21 +00:00
|
|
|
#ifdef DO_SSL
|
2012-05-18 17:24:57 +00:00
|
|
|
if (cfg->ssl_ctx) {
|
|
|
|
SSL_CTX_free(cfg->ssl_ctx);
|
|
|
|
cfg->ssl_ctx = NULL;
|
|
|
|
}
|
2012-05-23 20:30:21 +00:00
|
|
|
#endif
|
2012-05-18 17:24:57 +00:00
|
|
|
}
|
|
|
|
|
SIP TCP/TLS: move client connection setup/write into tcp helper thread, various related locking/memory fixes.
What this patch fixes
1.Moves sip TCP/TLS connection setup into the TCP helper thread:
Connection setup takes awhile and before this it was being
done while holding the monitor lock.
2.Moves TCP/TLS writing to the TCP helper thread: Through the
use of a packet queue and an alert pipe, the TCP helper thread
can now be woken up to write data as well as read data.
3.Locking error: sip_xmit returned an XMIT_ERROR without giving
up the tcptls_session lock. This lock has been completely removed
from sip_xmit and placed in the new sip_tcptls_write() function.
4.Memory leak: When creating a tcptls_client the tls_cfg was alloced
but never freed unless the tcptls_session failed to start. Now the
session_args for a sip client are an ao2 object which frees the
tls_cfg on destruction.
5.Pointer to stack variable: During sip_prepare_socket the creation
of a client's ast_tcptls_session_args was done on the stack and
stored as a pointer in the newly created tcptls_session. Depending
on the events that followed, there was a slight possibility that
pointer could have been accessed after the stack returned. Given
the new changes, it is always accessed after the stack returns
which is why I found it.
Notable code changes
1.I broke tcptls.c's ast_tcptls_client_start() function into two
functions. One for creating and allocating the new tcptls_session,
and a separate one for starting and handling the new connection.
This allowed me to create the tcptls_session, launch the helper
thread, and then establish the connection within the helper thread.
2.Writes to a tcptls_session are now done within the helper thread.
This is done by using an alert pipe to wake up the thread if new
data needs to be sent. The thread's sip_threadinfo object contains
the alert pipe as well as the packet queue.
3.Since the threadinfo object contains the alert pipe, it must now be
accessed outside of the helper thread for every write (queuing of a
packet). For easy lookup, I moved the threadinfo objects from a
linked list to an ao2_container.
(closes issue #13136)
Reported by: pabelanger
Tested by: dvossel, whys
(closes issue #15894)
Reported by: dvossel
Tested by: dvossel
Review: https://reviewboard.asterisk.org/r/380/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@225445 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-10-22 19:55:51 +00:00
|
|
|
struct ast_tcptls_session_instance *ast_tcptls_client_start(struct ast_tcptls_session_instance *tcptls_session)
|
2008-01-18 22:04:33 +00:00
|
|
|
{
|
SIP TCP/TLS: move client connection setup/write into tcp helper thread, various related locking/memory fixes.
What this patch fixes
1.Moves sip TCP/TLS connection setup into the TCP helper thread:
Connection setup takes awhile and before this it was being
done while holding the monitor lock.
2.Moves TCP/TLS writing to the TCP helper thread: Through the
use of a packet queue and an alert pipe, the TCP helper thread
can now be woken up to write data as well as read data.
3.Locking error: sip_xmit returned an XMIT_ERROR without giving
up the tcptls_session lock. This lock has been completely removed
from sip_xmit and placed in the new sip_tcptls_write() function.
4.Memory leak: When creating a tcptls_client the tls_cfg was alloced
but never freed unless the tcptls_session failed to start. Now the
session_args for a sip client are an ao2 object which frees the
tls_cfg on destruction.
5.Pointer to stack variable: During sip_prepare_socket the creation
of a client's ast_tcptls_session_args was done on the stack and
stored as a pointer in the newly created tcptls_session. Depending
on the events that followed, there was a slight possibility that
pointer could have been accessed after the stack returned. Given
the new changes, it is always accessed after the stack returns
which is why I found it.
Notable code changes
1.I broke tcptls.c's ast_tcptls_client_start() function into two
functions. One for creating and allocating the new tcptls_session,
and a separate one for starting and handling the new connection.
This allowed me to create the tcptls_session, launch the helper
thread, and then establish the connection within the helper thread.
2.Writes to a tcptls_session are now done within the helper thread.
This is done by using an alert pipe to wake up the thread if new
data needs to be sent. The thread's sip_threadinfo object contains
the alert pipe as well as the packet queue.
3.Since the threadinfo object contains the alert pipe, it must now be
accessed outside of the helper thread for every write (queuing of a
packet). For easy lookup, I moved the threadinfo objects from a
linked list to an ao2_container.
(closes issue #13136)
Reported by: pabelanger
Tested by: dvossel, whys
(closes issue #15894)
Reported by: dvossel
Tested by: dvossel
Review: https://reviewboard.asterisk.org/r/380/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@225445 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-10-22 19:55:51 +00:00
|
|
|
struct ast_tcptls_session_args *desc;
|
2008-01-18 22:04:33 +00:00
|
|
|
int flags;
|
SIP TCP/TLS: move client connection setup/write into tcp helper thread, various related locking/memory fixes.
What this patch fixes
1.Moves sip TCP/TLS connection setup into the TCP helper thread:
Connection setup takes awhile and before this it was being
done while holding the monitor lock.
2.Moves TCP/TLS writing to the TCP helper thread: Through the
use of a packet queue and an alert pipe, the TCP helper thread
can now be woken up to write data as well as read data.
3.Locking error: sip_xmit returned an XMIT_ERROR without giving
up the tcptls_session lock. This lock has been completely removed
from sip_xmit and placed in the new sip_tcptls_write() function.
4.Memory leak: When creating a tcptls_client the tls_cfg was alloced
but never freed unless the tcptls_session failed to start. Now the
session_args for a sip client are an ao2 object which frees the
tls_cfg on destruction.
5.Pointer to stack variable: During sip_prepare_socket the creation
of a client's ast_tcptls_session_args was done on the stack and
stored as a pointer in the newly created tcptls_session. Depending
on the events that followed, there was a slight possibility that
pointer could have been accessed after the stack returned. Given
the new changes, it is always accessed after the stack returns
which is why I found it.
Notable code changes
1.I broke tcptls.c's ast_tcptls_client_start() function into two
functions. One for creating and allocating the new tcptls_session,
and a separate one for starting and handling the new connection.
This allowed me to create the tcptls_session, launch the helper
thread, and then establish the connection within the helper thread.
2.Writes to a tcptls_session are now done within the helper thread.
This is done by using an alert pipe to wake up the thread if new
data needs to be sent. The thread's sip_threadinfo object contains
the alert pipe as well as the packet queue.
3.Since the threadinfo object contains the alert pipe, it must now be
accessed outside of the helper thread for every write (queuing of a
packet). For easy lookup, I moved the threadinfo objects from a
linked list to an ao2_container.
(closes issue #13136)
Reported by: pabelanger
Tested by: dvossel, whys
(closes issue #15894)
Reported by: dvossel
Tested by: dvossel
Review: https://reviewboard.asterisk.org/r/380/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@225445 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-10-22 19:55:51 +00:00
|
|
|
|
|
|
|
if (!(desc = tcptls_session->parent)) {
|
|
|
|
goto client_start_error;
|
|
|
|
}
|
|
|
|
|
2010-07-08 22:08:07 +00:00
|
|
|
if (ast_connect(desc->accept_fd, &desc->remote_address)) {
|
|
|
|
ast_log(LOG_ERROR, "Unable to connect %s to %s: %s\n",
|
SIP TCP/TLS: move client connection setup/write into tcp helper thread, various related locking/memory fixes.
What this patch fixes
1.Moves sip TCP/TLS connection setup into the TCP helper thread:
Connection setup takes awhile and before this it was being
done while holding the monitor lock.
2.Moves TCP/TLS writing to the TCP helper thread: Through the
use of a packet queue and an alert pipe, the TCP helper thread
can now be woken up to write data as well as read data.
3.Locking error: sip_xmit returned an XMIT_ERROR without giving
up the tcptls_session lock. This lock has been completely removed
from sip_xmit and placed in the new sip_tcptls_write() function.
4.Memory leak: When creating a tcptls_client the tls_cfg was alloced
but never freed unless the tcptls_session failed to start. Now the
session_args for a sip client are an ao2 object which frees the
tls_cfg on destruction.
5.Pointer to stack variable: During sip_prepare_socket the creation
of a client's ast_tcptls_session_args was done on the stack and
stored as a pointer in the newly created tcptls_session. Depending
on the events that followed, there was a slight possibility that
pointer could have been accessed after the stack returned. Given
the new changes, it is always accessed after the stack returns
which is why I found it.
Notable code changes
1.I broke tcptls.c's ast_tcptls_client_start() function into two
functions. One for creating and allocating the new tcptls_session,
and a separate one for starting and handling the new connection.
This allowed me to create the tcptls_session, launch the helper
thread, and then establish the connection within the helper thread.
2.Writes to a tcptls_session are now done within the helper thread.
This is done by using an alert pipe to wake up the thread if new
data needs to be sent. The thread's sip_threadinfo object contains
the alert pipe as well as the packet queue.
3.Since the threadinfo object contains the alert pipe, it must now be
accessed outside of the helper thread for every write (queuing of a
packet). For easy lookup, I moved the threadinfo objects from a
linked list to an ao2_container.
(closes issue #13136)
Reported by: pabelanger
Tested by: dvossel, whys
(closes issue #15894)
Reported by: dvossel
Tested by: dvossel
Review: https://reviewboard.asterisk.org/r/380/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@225445 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-10-22 19:55:51 +00:00
|
|
|
desc->name,
|
2010-07-08 22:08:07 +00:00
|
|
|
ast_sockaddr_stringify(&desc->remote_address),
|
SIP TCP/TLS: move client connection setup/write into tcp helper thread, various related locking/memory fixes.
What this patch fixes
1.Moves sip TCP/TLS connection setup into the TCP helper thread:
Connection setup takes awhile and before this it was being
done while holding the monitor lock.
2.Moves TCP/TLS writing to the TCP helper thread: Through the
use of a packet queue and an alert pipe, the TCP helper thread
can now be woken up to write data as well as read data.
3.Locking error: sip_xmit returned an XMIT_ERROR without giving
up the tcptls_session lock. This lock has been completely removed
from sip_xmit and placed in the new sip_tcptls_write() function.
4.Memory leak: When creating a tcptls_client the tls_cfg was alloced
but never freed unless the tcptls_session failed to start. Now the
session_args for a sip client are an ao2 object which frees the
tls_cfg on destruction.
5.Pointer to stack variable: During sip_prepare_socket the creation
of a client's ast_tcptls_session_args was done on the stack and
stored as a pointer in the newly created tcptls_session. Depending
on the events that followed, there was a slight possibility that
pointer could have been accessed after the stack returned. Given
the new changes, it is always accessed after the stack returns
which is why I found it.
Notable code changes
1.I broke tcptls.c's ast_tcptls_client_start() function into two
functions. One for creating and allocating the new tcptls_session,
and a separate one for starting and handling the new connection.
This allowed me to create the tcptls_session, launch the helper
thread, and then establish the connection within the helper thread.
2.Writes to a tcptls_session are now done within the helper thread.
This is done by using an alert pipe to wake up the thread if new
data needs to be sent. The thread's sip_threadinfo object contains
the alert pipe as well as the packet queue.
3.Since the threadinfo object contains the alert pipe, it must now be
accessed outside of the helper thread for every write (queuing of a
packet). For easy lookup, I moved the threadinfo objects from a
linked list to an ao2_container.
(closes issue #13136)
Reported by: pabelanger
Tested by: dvossel, whys
(closes issue #15894)
Reported by: dvossel
Tested by: dvossel
Review: https://reviewboard.asterisk.org/r/380/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@225445 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-10-22 19:55:51 +00:00
|
|
|
strerror(errno));
|
|
|
|
goto client_start_error;
|
|
|
|
}
|
|
|
|
|
|
|
|
flags = fcntl(desc->accept_fd, F_GETFL);
|
|
|
|
fcntl(desc->accept_fd, F_SETFL, flags & ~O_NONBLOCK);
|
|
|
|
|
|
|
|
if (desc->tls_cfg) {
|
|
|
|
desc->tls_cfg->enabled = 1;
|
|
|
|
__ssl_setup(desc->tls_cfg, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
return handle_tcptls_connection(tcptls_session);
|
|
|
|
|
|
|
|
client_start_error:
|
Resolve FORWARD_NULL static analysis warnings
This resolves core findings from ASTERISK-19650 numbers 0-2, 6, 7, 9-11, 14-20,
22-24, 28, 30-32, 34-36, 42-56, 82-84, 87, 89-90, 93-102, 104, 105, 109-111,
and 115. Finding numbers 26, 33, and 29 were already resolved. Those skipped
were either extended/deprecated or in areas of code that shouldn't be
disturbed.
(Closes issue ASTERISK-19650)
........
Merged revisions 366167 from http://svn.asterisk.org/svn/asterisk/branches/1.8
........
Merged revisions 366168 from http://svn.asterisk.org/svn/asterisk/branches/10
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@366169 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2012-05-10 20:56:09 +00:00
|
|
|
if (desc) {
|
|
|
|
close(desc->accept_fd);
|
|
|
|
desc->accept_fd = -1;
|
|
|
|
}
|
2012-05-31 18:39:30 +00:00
|
|
|
ao2_ref(tcptls_session, -1);
|
SIP TCP/TLS: move client connection setup/write into tcp helper thread, various related locking/memory fixes.
What this patch fixes
1.Moves sip TCP/TLS connection setup into the TCP helper thread:
Connection setup takes awhile and before this it was being
done while holding the monitor lock.
2.Moves TCP/TLS writing to the TCP helper thread: Through the
use of a packet queue and an alert pipe, the TCP helper thread
can now be woken up to write data as well as read data.
3.Locking error: sip_xmit returned an XMIT_ERROR without giving
up the tcptls_session lock. This lock has been completely removed
from sip_xmit and placed in the new sip_tcptls_write() function.
4.Memory leak: When creating a tcptls_client the tls_cfg was alloced
but never freed unless the tcptls_session failed to start. Now the
session_args for a sip client are an ao2 object which frees the
tls_cfg on destruction.
5.Pointer to stack variable: During sip_prepare_socket the creation
of a client's ast_tcptls_session_args was done on the stack and
stored as a pointer in the newly created tcptls_session. Depending
on the events that followed, there was a slight possibility that
pointer could have been accessed after the stack returned. Given
the new changes, it is always accessed after the stack returns
which is why I found it.
Notable code changes
1.I broke tcptls.c's ast_tcptls_client_start() function into two
functions. One for creating and allocating the new tcptls_session,
and a separate one for starting and handling the new connection.
This allowed me to create the tcptls_session, launch the helper
thread, and then establish the connection within the helper thread.
2.Writes to a tcptls_session are now done within the helper thread.
This is done by using an alert pipe to wake up the thread if new
data needs to be sent. The thread's sip_threadinfo object contains
the alert pipe as well as the packet queue.
3.Since the threadinfo object contains the alert pipe, it must now be
accessed outside of the helper thread for every write (queuing of a
packet). For easy lookup, I moved the threadinfo objects from a
linked list to an ao2_container.
(closes issue #13136)
Reported by: pabelanger
Tested by: dvossel, whys
(closes issue #15894)
Reported by: dvossel
Tested by: dvossel
Review: https://reviewboard.asterisk.org/r/380/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@225445 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-10-22 19:55:51 +00:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
struct ast_tcptls_session_instance *ast_tcptls_client_create(struct ast_tcptls_session_args *desc)
|
|
|
|
{
|
2016-06-02 19:10:06 +00:00
|
|
|
int fd, x = 1;
|
2008-12-12 18:45:03 +00:00
|
|
|
struct ast_tcptls_session_instance *tcptls_session = NULL;
|
2008-01-18 22:04:33 +00:00
|
|
|
|
|
|
|
/* Do nothing if nothing has changed */
|
2010-07-08 22:08:07 +00:00
|
|
|
if (!ast_sockaddr_cmp(&desc->old_address, &desc->remote_address)) {
|
2008-01-22 08:58:46 +00:00
|
|
|
ast_debug(1, "Nothing changed in %s\n", desc->name);
|
2008-01-18 22:04:33 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-05-20 21:40:19 +00:00
|
|
|
/* If we return early, there is no connection */
|
|
|
|
ast_sockaddr_setnull(&desc->old_address);
|
2008-01-18 22:04:33 +00:00
|
|
|
|
2011-11-06 09:51:09 +00:00
|
|
|
if (desc->accept_fd != -1) {
|
2008-01-18 22:04:33 +00:00
|
|
|
close(desc->accept_fd);
|
2011-11-06 09:51:09 +00:00
|
|
|
}
|
2008-01-18 22:04:33 +00:00
|
|
|
|
2016-06-02 19:10:06 +00:00
|
|
|
fd = desc->accept_fd = socket(ast_sockaddr_is_ipv6(&desc->remote_address) ?
|
|
|
|
AF_INET6 : AF_INET, SOCK_STREAM, IPPROTO_TCP);
|
2008-01-18 22:04:33 +00:00
|
|
|
if (desc->accept_fd < 0) {
|
2014-04-27 19:29:27 +00:00
|
|
|
ast_log(LOG_ERROR, "Unable to allocate socket for %s: %s\n",
|
2008-01-18 22:04:33 +00:00
|
|
|
desc->name, strerror(errno));
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-10-19 19:11:28 +00:00
|
|
|
/* if a local address was specified, bind to it so the connection will
|
|
|
|
originate from the desired address */
|
2010-07-08 22:08:07 +00:00
|
|
|
if (!ast_sockaddr_isnull(&desc->local_address)) {
|
2008-10-19 19:11:28 +00:00
|
|
|
setsockopt(desc->accept_fd, SOL_SOCKET, SO_REUSEADDR, &x, sizeof(x));
|
2010-07-08 22:08:07 +00:00
|
|
|
if (ast_bind(desc->accept_fd, &desc->local_address)) {
|
|
|
|
ast_log(LOG_ERROR, "Unable to bind %s to %s: %s\n",
|
|
|
|
desc->name,
|
|
|
|
ast_sockaddr_stringify(&desc->local_address),
|
2008-10-19 19:11:28 +00:00
|
|
|
strerror(errno));
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-17 22:57:54 +00:00
|
|
|
tcptls_session = ao2_alloc(sizeof(*tcptls_session), session_instance_destructor);
|
|
|
|
if (!tcptls_session) {
|
2008-01-18 22:04:33 +00:00
|
|
|
goto error;
|
2011-11-06 09:51:09 +00:00
|
|
|
}
|
2008-01-18 22:04:33 +00:00
|
|
|
|
2012-10-12 16:31:01 +00:00
|
|
|
tcptls_session->overflow_buf = ast_str_create(128);
|
2017-02-17 22:57:54 +00:00
|
|
|
if (!tcptls_session->overflow_buf) {
|
|
|
|
goto error;
|
|
|
|
}
|
SIP TCP/TLS: move client connection setup/write into tcp helper thread, various related locking/memory fixes.
What this patch fixes
1.Moves sip TCP/TLS connection setup into the TCP helper thread:
Connection setup takes awhile and before this it was being
done while holding the monitor lock.
2.Moves TCP/TLS writing to the TCP helper thread: Through the
use of a packet queue and an alert pipe, the TCP helper thread
can now be woken up to write data as well as read data.
3.Locking error: sip_xmit returned an XMIT_ERROR without giving
up the tcptls_session lock. This lock has been completely removed
from sip_xmit and placed in the new sip_tcptls_write() function.
4.Memory leak: When creating a tcptls_client the tls_cfg was alloced
but never freed unless the tcptls_session failed to start. Now the
session_args for a sip client are an ao2 object which frees the
tls_cfg on destruction.
5.Pointer to stack variable: During sip_prepare_socket the creation
of a client's ast_tcptls_session_args was done on the stack and
stored as a pointer in the newly created tcptls_session. Depending
on the events that followed, there was a slight possibility that
pointer could have been accessed after the stack returned. Given
the new changes, it is always accessed after the stack returns
which is why I found it.
Notable code changes
1.I broke tcptls.c's ast_tcptls_client_start() function into two
functions. One for creating and allocating the new tcptls_session,
and a separate one for starting and handling the new connection.
This allowed me to create the tcptls_session, launch the helper
thread, and then establish the connection within the helper thread.
2.Writes to a tcptls_session are now done within the helper thread.
This is done by using an alert pipe to wake up the thread if new
data needs to be sent. The thread's sip_threadinfo object contains
the alert pipe as well as the packet queue.
3.Since the threadinfo object contains the alert pipe, it must now be
accessed outside of the helper thread for every write (queuing of a
packet). For easy lookup, I moved the threadinfo objects from a
linked list to an ao2_container.
(closes issue #13136)
Reported by: pabelanger
Tested by: dvossel, whys
(closes issue #15894)
Reported by: dvossel
Tested by: dvossel
Review: https://reviewboard.asterisk.org/r/380/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@225445 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-10-22 19:55:51 +00:00
|
|
|
tcptls_session->client = 1;
|
2016-06-02 19:10:06 +00:00
|
|
|
tcptls_session->stream = ast_iostream_from_fd(&fd);
|
|
|
|
if (!tcptls_session->stream) {
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2008-12-12 18:45:03 +00:00
|
|
|
tcptls_session->parent = desc;
|
|
|
|
tcptls_session->parent->worker_fn = NULL;
|
2010-07-08 22:08:07 +00:00
|
|
|
ast_sockaddr_copy(&tcptls_session->remote_address,
|
|
|
|
&desc->remote_address);
|
2008-01-18 22:04:33 +00:00
|
|
|
|
2011-05-20 21:40:19 +00:00
|
|
|
/* Set current info */
|
|
|
|
ast_sockaddr_copy(&desc->old_address, &desc->remote_address);
|
2008-12-12 18:45:03 +00:00
|
|
|
return tcptls_session;
|
2008-01-18 22:04:33 +00:00
|
|
|
|
|
|
|
error:
|
|
|
|
close(desc->accept_fd);
|
|
|
|
desc->accept_fd = -1;
|
2017-02-17 22:57:54 +00:00
|
|
|
ao2_cleanup(tcptls_session);
|
2008-01-18 22:04:33 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-10-19 19:11:28 +00:00
|
|
|
void ast_tcptls_server_start(struct ast_tcptls_session_args *desc)
|
2008-01-18 22:04:33 +00:00
|
|
|
{
|
|
|
|
int flags;
|
|
|
|
int x = 1;
|
2016-11-15 19:44:13 +00:00
|
|
|
int tls_changed = 0;
|
|
|
|
|
|
|
|
if (desc->tls_cfg) {
|
|
|
|
char hash[41];
|
|
|
|
char *str = NULL;
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
/* Store the hashes of the TLS certificate etc. */
|
|
|
|
if (stat(desc->tls_cfg->certfile, &st) || NULL == (str = ast_read_textfile(desc->tls_cfg->certfile))) {
|
|
|
|
memset(hash, 0, 41);
|
|
|
|
} else {
|
|
|
|
ast_sha1_hash(hash, str);
|
|
|
|
}
|
|
|
|
ast_free(str);
|
|
|
|
str = NULL;
|
|
|
|
memcpy(desc->tls_cfg->certhash, hash, 41);
|
|
|
|
if (stat(desc->tls_cfg->pvtfile, &st) || NULL == (str = ast_read_textfile(desc->tls_cfg->pvtfile))) {
|
|
|
|
memset(hash, 0, 41);
|
|
|
|
} else {
|
|
|
|
ast_sha1_hash(hash, str);
|
|
|
|
}
|
|
|
|
ast_free(str);
|
|
|
|
str = NULL;
|
|
|
|
memcpy(desc->tls_cfg->pvthash, hash, 41);
|
|
|
|
if (stat(desc->tls_cfg->cafile, &st) || NULL == (str = ast_read_textfile(desc->tls_cfg->cafile))) {
|
|
|
|
memset(hash, 0, 41);
|
|
|
|
} else {
|
|
|
|
ast_sha1_hash(hash, str);
|
|
|
|
}
|
|
|
|
ast_free(str);
|
|
|
|
str = NULL;
|
|
|
|
memcpy(desc->tls_cfg->cahash, hash, 41);
|
|
|
|
|
|
|
|
/* Check whether TLS configuration has changed */
|
|
|
|
if (!desc->old_tls_cfg) { /* No previous configuration */
|
|
|
|
tls_changed = 1;
|
|
|
|
desc->old_tls_cfg = ast_calloc(1, sizeof(*desc->old_tls_cfg));
|
|
|
|
} else if (memcmp(desc->tls_cfg->certhash, desc->old_tls_cfg->certhash, 41)) {
|
|
|
|
tls_changed = 1;
|
|
|
|
} else if (memcmp(desc->tls_cfg->pvthash, desc->old_tls_cfg->pvthash, 41)) {
|
|
|
|
tls_changed = 1;
|
|
|
|
} else if (strcmp(desc->tls_cfg->cipher, desc->old_tls_cfg->cipher)) {
|
|
|
|
tls_changed = 1;
|
|
|
|
} else if (memcmp(desc->tls_cfg->cahash, desc->old_tls_cfg->cahash, 41)) {
|
|
|
|
tls_changed = 1;
|
|
|
|
} else if (strcmp(desc->tls_cfg->capath, desc->old_tls_cfg->capath)) {
|
|
|
|
tls_changed = 1;
|
|
|
|
} else if (memcmp(&desc->tls_cfg->flags, &desc->old_tls_cfg->flags, sizeof(desc->tls_cfg->flags))) {
|
|
|
|
tls_changed = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tls_changed) {
|
|
|
|
ast_debug(1, "Changed parameters for %s found\n", desc->name);
|
|
|
|
}
|
|
|
|
}
|
2009-04-29 21:13:43 +00:00
|
|
|
|
2008-01-18 22:04:33 +00:00
|
|
|
/* Do nothing if nothing has changed */
|
2016-11-15 19:44:13 +00:00
|
|
|
if (!tls_changed && !ast_sockaddr_cmp(&desc->old_address, &desc->local_address)) {
|
2008-01-22 08:58:46 +00:00
|
|
|
ast_debug(1, "Nothing changed in %s\n", desc->name);
|
2008-01-18 22:04:33 +00:00
|
|
|
return;
|
|
|
|
}
|
2009-04-29 21:13:43 +00:00
|
|
|
|
2011-05-20 21:40:19 +00:00
|
|
|
/* If we return early, there is no one listening */
|
|
|
|
ast_sockaddr_setnull(&desc->old_address);
|
2009-04-29 21:13:43 +00:00
|
|
|
|
2008-01-18 22:04:33 +00:00
|
|
|
/* Shutdown a running server if there is one */
|
|
|
|
if (desc->master != AST_PTHREADT_NULL) {
|
|
|
|
pthread_cancel(desc->master);
|
|
|
|
pthread_kill(desc->master, SIGURG);
|
|
|
|
pthread_join(desc->master, NULL);
|
|
|
|
}
|
2009-04-29 21:13:43 +00:00
|
|
|
|
2011-11-06 09:51:09 +00:00
|
|
|
if (desc->accept_fd != -1) {
|
2008-01-18 22:04:33 +00:00
|
|
|
close(desc->accept_fd);
|
2011-11-06 09:51:09 +00:00
|
|
|
}
|
2008-01-18 22:04:33 +00:00
|
|
|
|
|
|
|
/* If there's no new server, stop here */
|
2010-07-08 22:08:07 +00:00
|
|
|
if (ast_sockaddr_isnull(&desc->local_address)) {
|
2008-10-13 15:49:01 +00:00
|
|
|
ast_debug(2, "Server disabled: %s\n", desc->name);
|
2008-01-18 22:04:33 +00:00
|
|
|
return;
|
2008-10-13 15:49:01 +00:00
|
|
|
}
|
2008-01-18 22:04:33 +00:00
|
|
|
|
2010-07-08 22:08:07 +00:00
|
|
|
desc->accept_fd = socket(ast_sockaddr_is_ipv6(&desc->local_address) ?
|
|
|
|
AF_INET6 : AF_INET, SOCK_STREAM, 0);
|
2008-01-18 22:04:33 +00:00
|
|
|
if (desc->accept_fd < 0) {
|
2008-10-13 15:49:01 +00:00
|
|
|
ast_log(LOG_ERROR, "Unable to allocate socket for %s: %s\n", desc->name, strerror(errno));
|
2008-01-18 22:04:33 +00:00
|
|
|
return;
|
|
|
|
}
|
2009-04-29 21:13:43 +00:00
|
|
|
|
2008-01-18 22:04:33 +00:00
|
|
|
setsockopt(desc->accept_fd, SOL_SOCKET, SO_REUSEADDR, &x, sizeof(x));
|
2010-07-08 22:08:07 +00:00
|
|
|
if (ast_bind(desc->accept_fd, &desc->local_address)) {
|
|
|
|
ast_log(LOG_ERROR, "Unable to bind %s to %s: %s\n",
|
2008-01-18 22:04:33 +00:00
|
|
|
desc->name,
|
2010-07-08 22:08:07 +00:00
|
|
|
ast_sockaddr_stringify(&desc->local_address),
|
2008-01-18 22:04:33 +00:00
|
|
|
strerror(errno));
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (listen(desc->accept_fd, 10)) {
|
2008-01-22 08:58:46 +00:00
|
|
|
ast_log(LOG_ERROR, "Unable to listen for %s!\n", desc->name);
|
2008-01-18 22:04:33 +00:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
flags = fcntl(desc->accept_fd, F_GETFL);
|
|
|
|
fcntl(desc->accept_fd, F_SETFL, flags | O_NONBLOCK);
|
|
|
|
if (ast_pthread_create_background(&desc->master, NULL, desc->accept_fn, desc)) {
|
2010-07-08 22:08:07 +00:00
|
|
|
ast_log(LOG_ERROR, "Unable to launch thread for %s on %s: %s\n",
|
2008-01-18 22:04:33 +00:00
|
|
|
desc->name,
|
2010-07-08 22:08:07 +00:00
|
|
|
ast_sockaddr_stringify(&desc->local_address),
|
2008-01-18 22:04:33 +00:00
|
|
|
strerror(errno));
|
|
|
|
goto error;
|
|
|
|
}
|
2011-05-20 21:40:19 +00:00
|
|
|
|
|
|
|
/* Set current info */
|
|
|
|
ast_sockaddr_copy(&desc->old_address, &desc->local_address);
|
2016-11-15 19:44:13 +00:00
|
|
|
if (desc->old_tls_cfg) {
|
|
|
|
ast_free(desc->old_tls_cfg->certfile);
|
|
|
|
ast_free(desc->old_tls_cfg->pvtfile);
|
|
|
|
ast_free(desc->old_tls_cfg->cipher);
|
|
|
|
ast_free(desc->old_tls_cfg->cafile);
|
|
|
|
ast_free(desc->old_tls_cfg->capath);
|
|
|
|
desc->old_tls_cfg->certfile = ast_strdup(desc->tls_cfg->certfile);
|
|
|
|
desc->old_tls_cfg->pvtfile = ast_strdup(desc->tls_cfg->pvtfile);
|
|
|
|
desc->old_tls_cfg->cipher = ast_strdup(desc->tls_cfg->cipher);
|
|
|
|
desc->old_tls_cfg->cafile = ast_strdup(desc->tls_cfg->cafile);
|
|
|
|
desc->old_tls_cfg->capath = ast_strdup(desc->tls_cfg->capath);
|
|
|
|
memcpy(desc->old_tls_cfg->certhash, desc->tls_cfg->certhash, 41);
|
|
|
|
memcpy(desc->old_tls_cfg->pvthash, desc->tls_cfg->pvthash, 41);
|
|
|
|
memcpy(desc->old_tls_cfg->cahash, desc->tls_cfg->cahash, 41);
|
|
|
|
memcpy(&desc->old_tls_cfg->flags, &desc->tls_cfg->flags, sizeof(desc->old_tls_cfg->flags));
|
|
|
|
}
|
2011-05-20 21:40:19 +00:00
|
|
|
|
2008-01-18 22:04:33 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
error:
|
|
|
|
close(desc->accept_fd);
|
|
|
|
desc->accept_fd = -1;
|
|
|
|
}
|
|
|
|
|
2011-11-30 22:03:02 +00:00
|
|
|
void ast_tcptls_close_session_file(struct ast_tcptls_session_instance *tcptls_session)
|
|
|
|
{
|
2016-06-02 19:10:06 +00:00
|
|
|
if (tcptls_session->stream) {
|
|
|
|
ast_iostream_close(tcptls_session->stream);
|
|
|
|
tcptls_session->stream = NULL;
|
2011-11-30 22:03:02 +00:00
|
|
|
} else {
|
|
|
|
ast_log(LOG_ERROR, "ast_tcptls_close_session_file invoked on session instance without file or file descriptor\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-10-19 19:11:28 +00:00
|
|
|
void ast_tcptls_server_stop(struct ast_tcptls_session_args *desc)
|
2008-01-18 22:04:33 +00:00
|
|
|
{
|
|
|
|
if (desc->master != AST_PTHREADT_NULL) {
|
|
|
|
pthread_cancel(desc->master);
|
|
|
|
pthread_kill(desc->master, SIGURG);
|
|
|
|
pthread_join(desc->master, NULL);
|
2011-05-23 16:28:14 +00:00
|
|
|
desc->master = AST_PTHREADT_NULL;
|
2008-01-18 22:04:33 +00:00
|
|
|
}
|
2011-11-06 09:51:09 +00:00
|
|
|
if (desc->accept_fd != -1) {
|
2008-01-18 22:04:33 +00:00
|
|
|
close(desc->accept_fd);
|
2011-11-06 09:51:09 +00:00
|
|
|
}
|
2008-01-18 22:04:33 +00:00
|
|
|
desc->accept_fd = -1;
|
2016-11-15 19:44:13 +00:00
|
|
|
|
|
|
|
if (desc->old_tls_cfg) {
|
|
|
|
ast_free(desc->old_tls_cfg->certfile);
|
|
|
|
ast_free(desc->old_tls_cfg->pvtfile);
|
|
|
|
ast_free(desc->old_tls_cfg->cipher);
|
|
|
|
ast_free(desc->old_tls_cfg->cafile);
|
|
|
|
ast_free(desc->old_tls_cfg->capath);
|
|
|
|
ast_free(desc->old_tls_cfg);
|
|
|
|
desc->old_tls_cfg = NULL;
|
|
|
|
}
|
|
|
|
|
2008-10-13 15:49:01 +00:00
|
|
|
ast_debug(2, "Stopped server :: %s\n", desc->name);
|
2008-01-18 22:04:33 +00:00
|
|
|
}
|
2009-04-29 14:39:48 +00:00
|
|
|
|
|
|
|
int ast_tls_read_conf(struct ast_tls_config *tls_cfg, struct ast_tcptls_session_args *tls_desc, const char *varname, const char *value)
|
|
|
|
{
|
|
|
|
if (!strcasecmp(varname, "tlsenable") || !strcasecmp(varname, "sslenable")) {
|
|
|
|
tls_cfg->enabled = ast_true(value) ? 1 : 0;
|
2009-04-29 21:13:43 +00:00
|
|
|
} else if (!strcasecmp(varname, "tlscertfile") || !strcasecmp(varname, "sslcert") || !strcasecmp(varname, "tlscert")) {
|
2009-04-29 14:39:48 +00:00
|
|
|
ast_free(tls_cfg->certfile);
|
|
|
|
tls_cfg->certfile = ast_strdup(value);
|
|
|
|
} else if (!strcasecmp(varname, "tlsprivatekey") || !strcasecmp(varname, "sslprivatekey")) {
|
|
|
|
ast_free(tls_cfg->pvtfile);
|
|
|
|
tls_cfg->pvtfile = ast_strdup(value);
|
|
|
|
} else if (!strcasecmp(varname, "tlscipher") || !strcasecmp(varname, "sslcipher")) {
|
|
|
|
ast_free(tls_cfg->cipher);
|
|
|
|
tls_cfg->cipher = ast_strdup(value);
|
|
|
|
} else if (!strcasecmp(varname, "tlscafile")) {
|
|
|
|
ast_free(tls_cfg->cafile);
|
|
|
|
tls_cfg->cafile = ast_strdup(value);
|
2011-01-31 22:26:06 +00:00
|
|
|
} else if (!strcasecmp(varname, "tlscapath") || !strcasecmp(varname, "tlscadir")) {
|
2009-04-29 14:39:48 +00:00
|
|
|
ast_free(tls_cfg->capath);
|
|
|
|
tls_cfg->capath = ast_strdup(value);
|
|
|
|
} else if (!strcasecmp(varname, "tlsverifyclient")) {
|
|
|
|
ast_set2_flag(&tls_cfg->flags, ast_true(value), AST_SSL_VERIFY_CLIENT);
|
|
|
|
} else if (!strcasecmp(varname, "tlsdontverifyserver")) {
|
|
|
|
ast_set2_flag(&tls_cfg->flags, ast_true(value), AST_SSL_DONT_VERIFY_SERVER);
|
|
|
|
} else if (!strcasecmp(varname, "tlsbindaddr") || !strcasecmp(varname, "sslbindaddr")) {
|
2010-07-08 22:08:07 +00:00
|
|
|
if (ast_parse_arg(value, PARSE_ADDR, &tls_desc->local_address))
|
2014-04-27 19:29:27 +00:00
|
|
|
ast_log(LOG_ERROR, "Invalid %s '%s'\n", varname, value);
|
2009-04-29 21:13:43 +00:00
|
|
|
} else if (!strcasecmp(varname, "tlsclientmethod") || !strcasecmp(varname, "sslclientmethod")) {
|
|
|
|
if (!strcasecmp(value, "tlsv1")) {
|
|
|
|
ast_set_flag(&tls_cfg->flags, AST_SSL_TLSV1_CLIENT);
|
|
|
|
ast_clear_flag(&tls_cfg->flags, AST_SSL_SSLV3_CLIENT);
|
|
|
|
ast_clear_flag(&tls_cfg->flags, AST_SSL_SSLV2_CLIENT);
|
|
|
|
} else if (!strcasecmp(value, "sslv3")) {
|
|
|
|
ast_set_flag(&tls_cfg->flags, AST_SSL_SSLV3_CLIENT);
|
|
|
|
ast_clear_flag(&tls_cfg->flags, AST_SSL_SSLV2_CLIENT);
|
|
|
|
ast_clear_flag(&tls_cfg->flags, AST_SSL_TLSV1_CLIENT);
|
|
|
|
} else if (!strcasecmp(value, "sslv2")) {
|
|
|
|
ast_set_flag(&tls_cfg->flags, AST_SSL_SSLV2_CLIENT);
|
|
|
|
ast_clear_flag(&tls_cfg->flags, AST_SSL_TLSV1_CLIENT);
|
|
|
|
ast_clear_flag(&tls_cfg->flags, AST_SSL_SSLV3_CLIENT);
|
|
|
|
}
|
2016-02-03 18:05:20 +00:00
|
|
|
} else if (!strcasecmp(varname, "tlsservercipherorder")) {
|
|
|
|
ast_set2_flag(&tls_cfg->flags, ast_true(value), AST_SSL_SERVER_CIPHER_ORDER);
|
|
|
|
} else if (!strcasecmp(varname, "tlsdisablev1")) {
|
|
|
|
ast_set2_flag(&tls_cfg->flags, ast_true(value), AST_SSL_DISABLE_TLSV1);
|
|
|
|
} else if (!strcasecmp(varname, "tlsdisablev11")) {
|
|
|
|
ast_set2_flag(&tls_cfg->flags, ast_true(value), AST_SSL_DISABLE_TLSV11);
|
|
|
|
} else if (!strcasecmp(varname, "tlsdisablev12")) {
|
|
|
|
ast_set2_flag(&tls_cfg->flags, ast_true(value), AST_SSL_DISABLE_TLSV12);
|
2009-04-29 14:39:48 +00:00
|
|
|
} else {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|