From 30d96f81dbefffd3f1523256cc5a5328ea1c7ecb Mon Sep 17 00:00:00 2001
From: Kalle Olavi Niemitalo <kon@iki.fi>
Date: Mon, 2 May 2011 14:41:40 +0300
Subject: [PATCH 1/4] 1024: Use RFC 3546 server_name TLS extension
For both GnuTLS and OpenSSL. Not tested with nss-compat-openssl.
Signed-off-by: Kamil Dudka <kdudka@redhat.com>
---
src/network/ssl/socket.c | 19 ++++++++++++++++++-
src/network/ssl/ssl.c | 29 ++++++++++++++++++++++++-----
src/network/ssl/ssl.h | 14 ++++++++++++--
3 files changed, 54 insertions(+), 8 deletions(-)
diff --git a/src/network/ssl/socket.c b/src/network/ssl/socket.c
index 45b4b4a..dc682d0 100644
--- a/src/network/ssl/socket.c
+++ b/src/network/ssl/socket.c
@@ -22,6 +22,7 @@
#include "network/socket.h"
#include "network/ssl/socket.h"
#include "network/ssl/ssl.h"
+#include "protocol/uri.h"
#include "util/memory.h"
@@ -117,12 +118,28 @@ int
ssl_connect(struct socket *socket)
{
int ret;
+ unsigned char *server_name;
+ struct connection *conn = socket->conn;
- if (init_ssl_connection(socket) == S_SSL_ERROR) {
+ /* TODO: Recode server_name to UTF-8. */
+ server_name = get_uri_string(conn->proxied_uri, URI_HOST);
+ if (!server_name) {
+ socket->ops->done(socket, connection_state(S_OUT_OF_MEM));
+ return -1;
+ }
+
+ /* RFC 3546 says literal IPv4 and IPv6 addresses are not allowed. */
+ if (is_ip_address(server_name, strlen(server_name)))
+ mem_free_set(&server_name, NULL);
+
+ if (init_ssl_connection(socket, server_name) == S_SSL_ERROR) {
+ mem_free_if(server_name);
socket->ops->done(socket, connection_state(S_SSL_ERROR));
return -1;
}
+ mem_free_if(server_name);
+
if (socket->no_tls)
ssl_set_no_tls(socket);
diff --git a/src/network/ssl/ssl.c b/src/network/ssl/ssl.c
index 685c31e..7767a71 100644
--- a/src/network/ssl/ssl.c
+++ b/src/network/ssl/ssl.c
@@ -212,13 +212,26 @@ struct module ssl_module = struct_module(
);
int
-init_ssl_connection(struct socket *socket)
+init_ssl_connection(struct socket *socket,
+ const unsigned char *server_name)
{
#ifdef CONFIG_OPENSSL
socket->ssl = SSL_new(context);
if (!socket->ssl) return S_SSL_ERROR;
+
+ /* If the server name is known, pass it to OpenSSL.
+ *
+ * The return value of SSL_set_tlsext_host_name is not
+ * documented. The source shows that it returns 1 if
+ * successful; on error, it calls SSLerr and returns 0. */
+ if (server_name
+ && !SSL_set_tlsext_host_name(socket->ssl, server_name)) {
+ SSL_free(socket->ssl);
+ socket->ssl = NULL;
+ return S_SSL_ERROR;
+ }
+
#elif defined(CONFIG_GNUTLS)
- /* const unsigned char server_name[] = "localhost"; */
ssl_t *state = mem_alloc(sizeof(ssl_t));
if (!state) return S_SSL_ERROR;
@@ -255,9 +268,15 @@ init_ssl_connection(struct socket *socket)
/* gnutls_handshake_set_private_extensions(*state, 1); */
gnutls_cipher_set_priority(*state, cipher_priority);
gnutls_kx_set_priority(*state, kx_priority);
- /* gnutls_certificate_type_set_priority(*state, cert_type_priority);
- gnutls_server_name_set(*state, GNUTLS_NAME_DNS, server_name,
- sizeof(server_name) - 1); */
+ /* gnutls_certificate_type_set_priority(*state, cert_type_priority); */
+
+ if (server_name
+ && gnutls_server_name_set(*state, GNUTLS_NAME_DNS, server_name,
+ strlen(server_name))) {
+ gnutls_deinit(*state);
+ mem_free(state);
+ return S_SSL_ERROR;
+ }
socket->ssl = state;
#endif
diff --git a/src/network/ssl/ssl.h b/src/network/ssl/ssl.h
index 7c54a7a..bfd94e1 100644
--- a/src/network/ssl/ssl.h
+++ b/src/network/ssl/ssl.h
@@ -11,8 +11,18 @@ struct socket;
extern struct module ssl_module;
/* Initializes the SSL connection data. Returns S_OK on success and S_SSL_ERROR
- * on failure. */
-int init_ssl_connection(struct socket *socket);
+ * on failure.
+ *
+ * server_name is the DNS name of the server (in UTF-8), or NULL if
+ * ELinks knows only the IP address. ELinks reports that name to the
+ * server so that the server can choose the correct certificate if it
+ * has multiple virtual hosts on the same IP address. See RFC 3546
+ * section 3.1.
+ *
+ * server_name does not affect how ELinks verifies the certificate
+ * after the server has returned it. */
+int init_ssl_connection(struct socket *socket,
+ const unsigned char *server_name);
/* Releases the SSL connection data */
void done_ssl_connection(struct socket *socket);
--
2.1.0
From e7484a980572b665747c28aa1376e29a12fb4b19 Mon Sep 17 00:00:00 2001
From: Kalle Olavi Niemitalo <kon@iki.fi>
Date: Tue, 3 May 2011 03:52:21 +0300
Subject: [PATCH 2/4] 1024: Verify server certificate hostname with OpenSSL
Not tested with nss-compat-ossl.
Signed-off-by: Kamil Dudka <kdudka@redhat.com>
---
src/network/ssl/Makefile | 7 +-
src/network/ssl/match-hostname.c | 125 +++++++++++++++++
src/network/ssl/match-hostname.h | 10 ++
src/network/ssl/socket.c | 211 ++++++++++++++++++++++++++++-
src/network/ssl/ssl.c | 41 +++++-
src/network/ssl/ssl.h | 3 +
src/network/ssl/test/Makefile | 9 ++
src/network/ssl/test/match-hostname-test.c | 123 +++++++++++++++++
src/network/ssl/test/test-match-hostname | 3 +
9 files changed, 529 insertions(+), 3 deletions(-)
create mode 100644 src/network/ssl/match-hostname.c
create mode 100644 src/network/ssl/match-hostname.h
create mode 100644 src/network/ssl/test/Makefile
create mode 100644 src/network/ssl/test/match-hostname-test.c
create mode 100755 src/network/ssl/test/test-match-hostname
diff --git a/src/network/ssl/Makefile b/src/network/ssl/Makefile
index 26f02c2..6f265da 100644
--- a/src/network/ssl/Makefile
+++ b/src/network/ssl/Makefile
@@ -3,6 +3,11 @@ include $(top_builddir)/Makefile.config
INCLUDES += $(GNUTLS_CFLAGS) $(OPENSSL_CFLAGS)
-OBJS = ssl.o socket.o
+SUBDIRS = test
+
+# ELinks uses match-hostname.o only if CONFIG_OPENSSL.
+# However, match-hostname.o has test cases that always need it.
+# The test framework doesn't seem to support conditional tests.
+OBJS = match-hostname.o ssl.o socket.o
include $(top_srcdir)/Makefile.lib
diff --git a/src/network/ssl/match-hostname.c b/src/network/ssl/match-hostname.c
new file mode 100644
index 0000000..9a64bb4
--- /dev/null
+++ b/src/network/ssl/match-hostname.c
@@ -0,0 +1,125 @@
+/* Matching a host name to wildcards in SSL certificates */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "elinks.h"
+
+#include "intl/charsets.h"
+#include "network/ssl/match-hostname.h"
+#include "util/conv.h"
+#include "util/error.h"
+#include "util/string.h"
+
+/** Checks whether a host name matches a pattern that may contain
+ * wildcards.
+ *
+ * @param[in] hostname
+ * The host name to which the user wanted to connect.
+ * Should be in UTF-8 and need not be null-terminated.
+ * @param[in] hostname_length
+ * The length of @a hostname, in bytes.
+ * @param[in] pattern
+ * A pattern that the host name might match.
+ * Should be in UTF-8 and need not be null-terminated.
+ * The pattern may contain wildcards, as specified in
+ * RFC 2818 section 3.1.
+ * @param[in] pattern_length
+ * The length of @a pattern, in bytes.
+ *
+ * @return
+ * Nonzero if the host name matches. Zero if it doesn't.
+ *
+ * According to RFC 2818 section 3.1, '*' matches any number of
+ * characters except '.'. For example, "*r*.example.org" matches
+ * "random.example.org" or "history.example.org" but not
+ * "frozen.fruit.example.org".
+ *
+ * This function does not allocate memory, and consumes at most
+ * O(@a hostname_length * @a pattern_length) time. */
+int
+match_hostname_pattern(const unsigned char *hostname,
+ size_t hostname_length,
+ const unsigned char *pattern,
+ size_t pattern_length)
+{
+ const unsigned char *const hostname_end = hostname + hostname_length;
+ const unsigned char *const pattern_end = pattern + pattern_length;
+
+ assert(hostname <= hostname_end);
+ assert(pattern <= pattern_end);
+ if_assert_failed return 0;
+
+ while (pattern < pattern_end) {
+ if (*pattern == '*') {
+ const unsigned char *next_wildcard;
+ size_t literal_length;
+
+ ++pattern;
+ next_wildcard = memchr(pattern, '*',
+ pattern_end - pattern);
+ if (next_wildcard == NULL)
+ literal_length = pattern_end - pattern;
+ else
+ literal_length = next_wildcard - pattern;
+
+ for (;;) {
+ size_t hostname_left = hostname_end - hostname;
+ unicode_val_T uni;
+
+ if (hostname_left < literal_length)
+ return 0;
+
+ /* If next_wildcard == NULL, then the
+ * literal string is at the end of the
+ * pattern, so anchor the match to the
+ * end of the hostname. The end of
+ * this function can then easily
+ * verify that the whole hostname was
+ * matched.
+ *
+ * But do not jump directly there;
+ * first verify that there are no '.'
+ * characters in between. */
+ if ((next_wildcard != NULL
+ || hostname_left == literal_length)
+ && !c_strlcasecmp(pattern, literal_length,
+ hostname, literal_length))
+ break;
+
+ /* The literal string doesn't match here.
+ * Skip one character of the hostname and
+ * retry. If the skipped character is '.'
+ * or one of the equivalent characters
+ * listed in RFC 3490 section 3.1
+ * requirement 1, then return 0, because
+ * '*' must not match such characters.
+ * Do the same if invalid UTF-8 is found.
+ * Cast away const. */
+ uni = utf8_to_unicode((unsigned char **) hostname,
+ hostname_end);
+ if (uni == 0x002E
+ || uni == 0x3002
+ || uni == 0xFF0E
+ || uni == 0xFF61
+ || uni == UCS_NO_CHAR)
+ return 0;
+ }
+
+ pattern += literal_length;
+ hostname += literal_length;
+ } else {
+ if (hostname == hostname_end)
+ return 0;
+
+ if (c_toupper(*pattern) != c_toupper(*hostname))
+ return 0;
+
+ ++pattern;
+ ++hostname;
+ }
+ }
+
+ return hostname == hostname_end;
+}
diff --git a/src/network/ssl/match-hostname.h b/src/network/ssl/match-hostname.h
new file mode 100644
index 0000000..60d32b2
--- /dev/null
+++ b/src/network/ssl/match-hostname.h
@@ -0,0 +1,10 @@
+
+#ifndef EL__NETWORK_SSL_MATCH_HOSTNAME_H
+#define EL__NETWORK_SSL_MATCH_HOSTNAME_H
+
+int match_hostname_pattern(const unsigned char *hostname,
+ size_t hostname_length,
+ const unsigned char *pattern,
+ size_t pattern_length);
+
+#endif
diff --git a/src/network/ssl/socket.c b/src/network/ssl/socket.c
index dc682d0..a67bbde 100644
--- a/src/network/ssl/socket.c
+++ b/src/network/ssl/socket.c
@@ -6,13 +6,24 @@
#ifdef CONFIG_OPENSSL
#include <openssl/ssl.h>
+#include <openssl/x509v3.h>
+#define USE_OPENSSL
+#elif defined(CONFIG_NSS_COMPAT_OSSL)
+#include <nss_compat_ossl/nss_compat_ossl.h>
+#define USE_OPENSSL
#elif defined(CONFIG_GNUTLS)
#include <gnutls/gnutls.h>
#else
#error "Huh?! You have SSL enabled, but not OPENSSL nor GNUTLS!! And then you want exactly *what* from me?"
#endif
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
#include <errno.h>
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
#include "elinks.h"
@@ -20,6 +31,7 @@
#include "main/select.h"
#include "network/connection.h"
#include "network/socket.h"
+#include "network/ssl/match-hostname.h"
#include "network/ssl/socket.h"
#include "network/ssl/ssl.h"
#include "protocol/uri.h"
@@ -83,6 +95,203 @@ ssl_set_no_tls(struct socket *socket)
#endif
}
+#ifdef USE_OPENSSL
+
+/** Checks whether the host component of a URI matches a host name in
+ * the server certificate.
+ *
+ * @param[in] uri_host
+ * The host name (or IP address) to which the user wanted to connect.
+ * Should be in UTF-8.
+ * @param[in] cert_host_asn1
+ * A host name found in the server certificate: either as commonName
+ * in the subject field, or as a dNSName in the subjectAltName
+ * extension. This may contain wildcards, as specified in RFC 2818
+ * section 3.1.
+ *
+ * @return
+ * Nonzero if the host matches. Zero if it doesn't, or on error.
+ *
+ * If @a uri_host is an IP address literal rather than a host name,
+ * then this function returns 0, meaning that the host name does not match.
+ * According to RFC 2818, if the certificate is intended to match an
+ * IP address, then it must have that IP address as an iPAddress
+ * SubjectAltName, rather than in commonName. For comparing those,
+ * match_uri_host_ip() must be used instead of this function. */
+static int
+match_uri_host_name(const unsigned char *uri_host,
+ ASN1_STRING *cert_host_asn1)
+{
+ const size_t uri_host_len = strlen(uri_host);
+ unsigned char *cert_host = NULL;
+ int cert_host_len;
+ int matched = 0;
+
+ if (is_ip_address(uri_host, uri_host_len))
+ goto mismatch;
+
+ /* This function is used for both dNSName and commonName.
+ * Although dNSName is always an IA5 string, commonName allows
+ * many other encodings too. Normalize all to UTF-8. */
+ cert_host_len = ASN1_STRING_to_UTF8(&cert_host,
+ cert_host_asn1);
+ if (cert_host_len < 0)
+ goto mismatch;
+
+ matched = match_hostname_pattern(uri_host, uri_host_len,
+ cert_host, cert_host_len);
+
+mismatch:
+ if (cert_host)
+ OPENSSL_free(cert_host);
+ return matched;
+}
+
+/** Checks whether the host component of a URI matches an IP address
+ * in the server certificate.
+ *
+ * @param[in] uri_host
+ * The IP address (or host name) to which the user wanted to connect.
+ * Should be in UTF-8.
+ * @param[in] cert_host_asn1
+ * An IP address found as iPAddress in the subjectAltName extension
+ * of the server certificate. According to RFC 5280 section 4.2.1.6,
+ * that is an octet string in network byte order. According to
+ * RFC 2818 section 3.1, wildcards are not allowed.
+ *
+ * @return
+ * Nonzero if the host matches. Zero if it doesn't, or on error.
+ *
+ * If @a uri_host is a host name rather than an IP address literal,
+ * then this function returns 0, meaning that the address does not match.
+ * This function does not try to resolve the host name to an IP address
+ * and compare that to @a cert_host_asn1, because such an approach would
+ * be vulnerable to DNS spoofing.
+ *
+ * This function does not support the address-and-netmask format used
+ * in the name constraints extension of a CA certificate (RFC 5280
+ * section 4.2.1.10). */
+static int
+match_uri_host_ip(const unsigned char *uri_host,
+ ASN1_OCTET_STRING *cert_host_asn1)
+{
+ const unsigned char *cert_host_addr = ASN1_STRING_data(cert_host_asn1);
+ struct in_addr uri_host_in;
+#ifdef CONFIG_IPV6
+ struct in6_addr uri_host_in6;
+#endif
+
+ /* RFC 5280 defines the iPAddress alternative of GeneralName
+ * as an OCTET STRING. Verify that the type is indeed that.
+ * This is an assertion because, if someone puts the wrong
+ * type of data there, then it will not even be recognized as
+ * an iPAddress, and this function will not be called.
+ *
+ * (Because GeneralName is defined in an implicitly tagged
+ * ASN.1 module, the OCTET STRING tag is not part of the DER
+ * encoding. BER also allows a constructed encoding where
+ * each substring begins with the OCTET STRING tag; but ITU-T
+ * Rec. X.690 (07/2002) subclause 8.21 says those would be
+ * OCTET STRING even if the outer string were of some other
+ * type. "A Layman's Guide to a Subset of ASN.1, BER, and
+ * DER" (Kaliski, 1993) claims otherwise, though.) */
+ assert(ASN1_STRING_type(cert_host_asn1) == V_ASN1_OCTET_STRING);
+ if_assert_failed return 0;
+
+ /* cert_host_addr, url_host_in, and url_host_in6 are all in
+ * network byte order. */
+ switch (ASN1_STRING_length(cert_host_asn1)) {
+ case 4:
+ return inet_aton(uri_host, &uri_host_in) != 0
+ && memcmp(cert_host_addr, &uri_host_in.s_addr, 4) == 0;
+
+#ifdef CONFIG_IPV6
+ case 16:
+ return inet_pton(AF_INET6, uri_host, &uri_host_in6) == 1
+ && memcmp(cert_host_addr, &uri_host_in6.s6_addr, 16) == 0;
+#endif
+
+ default:
+ return 0;
+ }
+}
+
+/** Verify one certificate in the server certificate chain.
+ * This callback is documented in SSL_set_verify(3). */
+static int
+verify_callback(int preverify_ok, X509_STORE_CTX *ctx)
+{
+ X509 *cert;
+ SSL *ssl;
+ struct socket *socket;
+ struct connection *conn;
+ unsigned char *host_in_uri;
+ GENERAL_NAMES *alts;
+ int saw_dns_name = 0;
+ int matched = 0;
+
+ /* If OpenSSL already found a problem, keep that. */
+ if (!preverify_ok)
+ return 0;
+
+ /* Examine only the server certificate, not CA certificates. */
+ if (X509_STORE_CTX_get_error_depth(ctx) != 0)
+ return preverify_ok;
+
+ cert = X509_STORE_CTX_get_current_cert(ctx);
+ ssl = X509_STORE_CTX_get_ex_data(ctx, SSL_get_ex_data_X509_STORE_CTX_idx());
+ socket = SSL_get_ex_data(ssl, socket_SSL_ex_data_idx);
+ conn = socket->conn;
+ host_in_uri = get_uri_string(conn->uri, URI_HOST | URI_IDN);
+ if (!host_in_uri)
+ return 0;
+
+ /* RFC 5280 section 4.2.1.6 describes the subjectAltName extension.
+ * RFC 2818 section 3.1 says Common Name must not be used
+ * if dNSName is present. */
+ alts = X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL);
+ if (alts != NULL) {
+ int alt_count;
+ int alt_pos;
+ GENERAL_NAME *alt;
+
+ alt_count = sk_GENERAL_NAME_num(alts);
+ for (alt_pos = 0; !matched && alt_pos < alt_count; ++alt_pos) {
+ alt = sk_GENERAL_NAME_value(alts, alt_pos);
+ if (alt->type == GEN_DNS) {
+ saw_dns_name = 1;
+ matched = match_uri_host_name(host_in_uri,
+ alt->d.dNSName);
+ } else if (alt->type == GEN_IPADD) {
+ matched = match_uri_host_ip(host_in_uri,
+ alt->d.iPAddress);
+ }
+ }
+
+ /* Free the GENERAL_NAMES list and each element. */
+ sk_GENERAL_NAME_pop_free(alts, GENERAL_NAME_free);
+ }
+
+ if (!matched && !saw_dns_name) {
+ X509_NAME *name;
+ int cn_index;
+ X509_NAME_ENTRY *entry = NULL;
+
+ name = X509_get_subject_name(cert);
+ cn_index = X509_NAME_get_index_by_NID(name, NID_commonName, -1);
+ if (cn_index >= 0)
+ entry = X509_NAME_get_entry(name, cn_index);
+ if (entry != NULL)
+ matched = match_uri_host_name(host_in_uri,
+ X509_NAME_ENTRY_get_data(entry));
+ }
+
+ mem_free(host_in_uri);
+ return matched;
+}
+
+#endif /* USE_OPENSSL */
+
static void
ssl_want_read(struct socket *socket)
{
@@ -149,7 +358,7 @@ ssl_connect(struct socket *socket)
if (get_opt_bool("connection.ssl.cert_verify"))
SSL_set_verify(socket->ssl, SSL_VERIFY_PEER
| SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
- NULL);
+ verify_callback);
if (get_opt_bool("connection.ssl.client_cert.enable")) {
unsigned char *client_cert;
diff --git a/src/network/ssl/ssl.c b/src/network/ssl/ssl.c
index 7767a71..d1881c8 100644
--- a/src/network/ssl/ssl.c
+++ b/src/network/ssl/ssl.c
@@ -39,7 +39,35 @@
#define PATH_MAX 256 /* according to my /usr/include/bits/posix1_lim.h */
#endif
-SSL_CTX *context = NULL;
+static SSL_CTX *context = NULL;
+int socket_SSL_ex_data_idx = -1;
+
+/** Prevent SSL_dup() if the SSL is associated with struct socket.
+ * We cannot copy struct socket and it doesn't have a reference count
+ * either. */
+static int
+socket_SSL_ex_data_dup(CRYPTO_EX_DATA *to, CRYPTO_EX_DATA *from,
+ void *from_d, int idx, long argl, void *argp)
+{
+ /* The documentation of from_d in RSA_get_ex_new_index(3)
+ * is a bit unclear. The caller does something like:
+ *
+ * void *data = CRYPTO_get_ex_data(from, idx);
+ * socket_SSL_dup(to, from, &data, idx, argl, argp);
+ * CRYPTO_set_ex_data(to, idx, data);
+ *
+ * i.e., from_d always points to a pointer, even though
+ * it is just a void * in the prototype. */
+ struct socket *socket = *(void **) from_d;
+
+ assert(idx == socket_SSL_ex_data_idx);
+ if_assert_failed return 0;
+
+ if (socket)
+ return 0; /* prevent SSL_dup() */
+ else
+ return 1; /* allow SSL_dup() */
+}
static void
init_openssl(struct module *module)
@@ -48,12 +76,17 @@ init_openssl(struct module *module)
context = SSL_CTX_new(SSLv23_client_method());
SSL_CTX_set_options(context, SSL_OP_ALL);
SSL_CTX_set_default_verify_paths(context);
+ socket_SSL_ex_data_idx = SSL_get_ex_new_index(0, NULL,
+ NULL,
+ socket_SSL_ex_data_dup,
+ NULL);
}
static void
done_openssl(struct module *module)
{
if (context) SSL_CTX_free(context);
+ /* There is no function that undoes SSL_get_ex_new_index. */
}
static union option_info openssl_options[] = {
@@ -219,6 +252,12 @@ init_ssl_connection(struct socket *socket,
socket->ssl = SSL_new(context);
if (!socket->ssl) return S_SSL_ERROR;
+ if (!SSL_set_ex_data(socket->ssl, socket_SSL_ex_data_idx, socket)) {
+ SSL_free(socket->ssl);
+ socket->ssl = NULL;
+ return S_SSL_ERROR;
+ }
+
/* If the server name is known, pass it to OpenSSL.
*
* The return value of SSL_set_tlsext_host_name is not
diff --git a/src/network/ssl/ssl.h b/src/network/ssl/ssl.h
index bfd94e1..480b4db 100644
--- a/src/network/ssl/ssl.h
+++ b/src/network/ssl/ssl.h
@@ -29,6 +29,9 @@ void done_ssl_connection(struct socket *socket);
unsigned char *get_ssl_connection_cipher(struct socket *socket);
+#if defined(CONFIG_OPENSSL) || defined(CONFIG_NSS_COMPAT_OSSL)
+extern int socket_SSL_ex_data_idx;
+#endif
/* Internal type used in ssl module. */
diff --git a/src/network/ssl/test/Makefile b/src/network/ssl/test/Makefile
new file mode 100644
index 0000000..f2196eb
--- /dev/null
+++ b/src/network/ssl/test/Makefile
@@ -0,0 +1,9 @@
+top_builddir=../../../..
+include $(top_builddir)/Makefile.config
+
+SUBDIRS =
+TEST_PROGS = match-hostname-test
+TESTDEPS += \
+ $(top_builddir)/src/network/ssl/match-hostname.o
+
+include $(top_srcdir)/Makefile.lib
diff --git a/src/network/ssl/test/match-hostname-test.c b/src/network/ssl/test/match-hostname-test.c
new file mode 100644
index 0000000..fbdf6fa
--- /dev/null
+++ b/src/network/ssl/test/match-hostname-test.c
@@ -0,0 +1,123 @@
+/* Test match_hostname_pattern() */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "elinks.h"
+
+#include "network/ssl/match-hostname.h"
+#include "util/string.h"
+
+struct match_hostname_pattern_test_case
+{
+ const unsigned char *pattern;
+ const unsigned char *hostname;
+ int match;
+};
+
+static const struct match_hostname_pattern_test_case match_hostname_pattern_test_cases[] = {
+ { "*r*.example.org", "random.example.org", 1 },
+ { "*r*.example.org", "history.example.org", 1 },
+ { "*r*.example.org", "frozen.fruit.example.org", 0 },
+ { "*r*.example.org", "steamed.fruit.example.org", 0 },
+
+ { "ABC.def.Ghi", "abc.DEF.gHI", 1 },
+
+ { "*", "localhost", 1 },
+ { "*", "example.org", 0 },
+ { "*.*", "example.org", 1 },
+ { "*.*.*", "www.example.org", 1 },
+ { "*.*.*", "example.org", 0 },
+
+ { "assign", "assignee", 0 },
+ { "*peg", "arpeggiator", 0 },
+ { "*peg*", "arpeggiator", 1 },
+ { "*r*gi*", "arpeggiator", 1 },
+ { "*r*git*", "arpeggiator", 0 },
+
+ { NULL, NULL, 0 }
+};
+
+int
+main(void)
+{
+ const struct match_hostname_pattern_test_case *test;
+ int count_ok = 0;
+ int count_fail = 0;
+ struct string hostname_str = NULL_STRING;
+ struct string pattern_str = NULL_STRING;
+
+ if (!init_string(&hostname_str) || !init_string(&pattern_str)) {
+ fputs("Out of memory.\n", stderr);
+ done_string(&hostname_str);
+ done_string(&pattern_str);
+ return EXIT_FAILURE;
+ }
+
+ for (test = match_hostname_pattern_test_cases; test->pattern; test++) {
+ int match;
+
+ match = match_hostname_pattern(
+ test->hostname,
+ strlen(test->hostname),
+ test->pattern,
+ strlen(test->pattern));
+ if (!match == !test->match) {
+ /* Test OK */
+ count_ok++;
+ } else {
+ fprintf(stderr, "match_hostname_pattern() test failed\n"
+ "\tHostname: %s\n"
+ "\tPattern: %s\n"
+ "\tActual result: %d\n"
+ "\tCorrect result: %d\n",
+ test->hostname,
+ test->pattern,
+ match,
+ test->match);
+ count_fail++;
+ }
+
+ /* Try with strings that are not null-terminated. */
+ hostname_str.length = 0;
+ add_to_string(&hostname_str, test->hostname);
+ add_to_string(&hostname_str, "ZZZ");
+ pattern_str.length = 0;
+ add_to_string(&pattern_str, test->pattern);
+ add_to_string(&hostname_str, "______");
+
+ match = match_hostname_pattern(
+ hostname_str.source,
+ strlen(test->hostname),
+ pattern_str.source,
+ strlen(test->pattern));
+ if (!match == !test->match) {
+ /* Test OK */
+ count_ok++;
+ } else {
+ fprintf(stderr, "match_hostname_pattern() test failed\n"
+ "\tVariant: Strings were not null-terminated.\n"
+ "\tHostname: %s\n"
+ "\tPattern: %s\n"
+ "\tActual result: %d\n"
+ "\tCorrect result: %d\n",
+ test->hostname,
+ test->pattern,
+ match,
+ test->match);
+ count_fail++;
+ }
+ }
+
+ printf("Summary of match_hostname_pattern() tests: %d OK, %d failed.\n",
+ count_ok, count_fail);
+
+ done_string(&hostname_str);
+ done_string(&pattern_str);
+ return count_fail ? EXIT_FAILURE : EXIT_SUCCESS;
+
+}
diff --git a/src/network/ssl/test/test-match-hostname b/src/network/ssl/test/test-match-hostname
new file mode 100755
index 0000000..01d7173
--- /dev/null
+++ b/src/network/ssl/test/test-match-hostname
@@ -0,0 +1,3 @@
+#! /bin/sh -e
+
+./match-hostname-test
--
2.1.0
From 0cb6967bb9ccabc583bbdc6ee76baf4fdf0f90cc Mon Sep 17 00:00:00 2001
From: mancha <mancha@mac.hush.com>
Date: Sun, 15 Jul 2012 23:27:53 +0200
Subject: [PATCH 3/4] Fix hostname verification code.
[ From bug 1123 attachment 569. --KON ]
Signed-off-by: Kamil Dudka <kdudka@redhat.com>
---
src/network/ssl/match-hostname.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/network/ssl/match-hostname.c b/src/network/ssl/match-hostname.c
index 9a64bb4..80d93b0 100644
--- a/src/network/ssl/match-hostname.c
+++ b/src/network/ssl/match-hostname.c
@@ -97,7 +97,7 @@ match_hostname_pattern(const unsigned char *hostname,
* '*' must not match such characters.
* Do the same if invalid UTF-8 is found.
* Cast away const. */
- uni = utf8_to_unicode((unsigned char **) hostname,
+ uni = utf8_to_unicode((unsigned char **) &hostname,
hostname_end);
if (uni == 0x002E
|| uni == 0x3002
--
2.1.0
From cf8586b0389911d944d767646d5a91c2e1bae86c Mon Sep 17 00:00:00 2001
From: Kamil Dudka <kdudka@redhat.com>
Date: Fri, 5 Jun 2015 17:08:46 +0200
Subject: [PATCH 4/4] ssl: use the OpenSSL-provided host name check
... if built against a new enough version of OpenSSL
Suggested-by: Christian Heimes
---
configure.in | 3 +++
src/network/ssl/socket.c | 50 +++++++++++++++++++++++++++++++++++++++++++++++-
2 files changed, 52 insertions(+), 1 deletion(-)
diff --git a/configure.in b/configure.in
index 91d0257..1d858bd 100644
--- a/configure.in
+++ b/configure.in
@@ -1044,6 +1044,9 @@ else
fi
AC_MSG_RESULT($cf_result)
+if test "$cf_result" = yes; then
+ AC_CHECK_FUNCS(X509_VERIFY_PARAM_set1_host)
+fi
# ---- GNU TLS
diff --git a/src/network/ssl/socket.c b/src/network/ssl/socket.c
index a67bbde..c9e2be4 100644
--- a/src/network/ssl/socket.c
+++ b/src/network/ssl/socket.c
@@ -7,6 +7,9 @@
#ifdef CONFIG_OPENSSL
#include <openssl/ssl.h>
#include <openssl/x509v3.h>
+#ifdef HAVE_X509_VERIFY_PARAM_SET1_HOST
+#include <openssl/x509_vfy.h>
+#endif
#define USE_OPENSSL
#elif defined(CONFIG_NSS_COMPAT_OSSL)
#include <nss_compat_ossl/nss_compat_ossl.h>
@@ -97,6 +100,30 @@ ssl_set_no_tls(struct socket *socket)
#ifdef USE_OPENSSL
+#ifdef HAVE_X509_VERIFY_PARAM_SET1_HOST
+/* activate the OpenSSL-provided host name check */
+static int
+ossl_set_hostname(void *ssl, unsigned char *server_name)
+{
+ int ret = -1;
+
+ X509_VERIFY_PARAM *vpm = X509_VERIFY_PARAM_new();
+ if (vpm) {
+ if (X509_VERIFY_PARAM_set1_host(vpm, (char *) server_name, 0)
+ && SSL_set1_param(ssl, vpm))
+ {
+ /* successfully activated the OpenSSL host name check */
+ ret = 0;
+ }
+
+ X509_VERIFY_PARAM_free(vpm);
+ }
+
+ return ret;
+}
+
+#else /* HAVE_X509_VERIFY_PARAM_SET1_HOST */
+
/** Checks whether the host component of a URI matches a host name in
* the server certificate.
*
@@ -289,6 +316,7 @@ verify_callback(int preverify_ok, X509_STORE_CTX *ctx)
mem_free(host_in_uri);
return matched;
}
+#endif /* HAVE_X509_VERIFY_PARAM_SET1_HOST */
#endif /* USE_OPENSSL */
@@ -329,6 +357,9 @@ ssl_connect(struct socket *socket)
int ret;
unsigned char *server_name;
struct connection *conn = socket->conn;
+#ifdef USE_OPENSSL
+ int (*verify_callback_ptr)(int, X509_STORE_CTX *);
+#endif /* USE_OPENSSL */
/* TODO: Recode server_name to UTF-8. */
server_name = get_uri_string(conn->proxied_uri, URI_HOST);
@@ -347,6 +378,23 @@ ssl_connect(struct socket *socket)
return -1;
}
+#ifdef USE_OPENSSL
+#ifdef HAVE_X509_VERIFY_PARAM_SET1_HOST
+ /* activate the OpenSSL-provided host name check */
+ if (ossl_set_hostname(socket->ssl, server_name)) {
+ mem_free_if(server_name);
+ socket->ops->done(socket, connection_state(S_SSL_ERROR));
+ return -1;
+ }
+
+ /* verify_callback() is not needed with X509_VERIFY_PARAM_set1_host() */
+ verify_callback_ptr = NULL;
+#else
+ /* use our own callback implementing the host name check */
+ verify_callback_ptr = verify_callback;
+#endif
+#endif /* USE_OPENSSL */
+
mem_free_if(server_name);
if (socket->no_tls)
@@ -358,7 +406,7 @@ ssl_connect(struct socket *socket)
if (get_opt_bool("connection.ssl.cert_verify"))
SSL_set_verify(socket->ssl, SSL_VERIFY_PEER
| SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
- verify_callback);
+ verify_callback_ptr);
if (get_opt_bool("connection.ssl.client_cert.enable")) {
unsigned char *client_cert;
--
2.4.3