gnutls_prf_rfc5705: calculate exporter using HKDF if TLS 1.3

Signed-off-by: Daiki Ueno <dueno@redhat.com>

3 files changed, 387 insertions, 19 deletions

diff --git a/lib/prf.c b/lib/prf.c
index 7ac1090d92..b5dd8888fa 100644
--- a/lib/prf.c
+++ b/lib/prf.c
@@ -27,10 +27,13 @@
 
 #include "gnutls_int.h"
 #include "errors.h"
+#include "secrets.h"
 #include <num.h>
 #include <state.h>
 #include <algorithms.h>
 
+#define EXPORTER_LABEL "exporter"
+
 /**
  * gnutls_prf_raw:
  * @session: is a #gnutls_session_t type.
@@ -44,6 +47,10 @@
  * Apply the TLS Pseudo-Random-Function (PRF) on the master secret
  * and the provided data.
  *
+ * This function only works with the TLS versions prior to 1.3.  In
+ * TLS 1.3, the use of PRF is replaced with HKDF (HMAC-based Key
+ * Derivation Function) based on the multi-stage key scheduling.
+ *
  * The @label variable usually contains a string denoting the purpose
  * for the generated data.  The @seed usually contains data such as the
  * client and server random, perhaps together with some additional
@@ -88,15 +95,18 @@ gnutls_prf_raw(gnutls_session_t session,
  * @outsize: size of pre-allocated output buffer to hold the output.
  * @out: pre-allocated buffer to hold the generated data.
  *
- * Applies the TLS Pseudo-Random-Function (PRF) on the master secret
- * and the provided data, seeded with the client and server random fields,
+ * Exports keyring material from TLS/DTLS session to an application,
  * as specified in RFC5705.
  *
+ * In the TLS versions prior to 1.3, it applies the TLS
+ * Pseudo-Random-Function (PRF) on the master secret and the provided
+ * data, seeded with the client and server random fields.
+ *
+ * In TLS 1.3, it applies HKDF on the exporter master secret derived
+ * from the master secret.
+ *
  * The @label variable usually contains a string denoting the purpose
- * for the generated data.  The @server_random_first indicates whether
- * the client random field or the server random field should be first
- * in the seed.  Non-zero indicates that the server random field is first,
- * 0 that the client random field is first.
+ * for the generated data.
  *
  * The @context variable can be used to add more data to the seed, after
  * the random variables.  It can be used to make sure the
@@ -118,7 +128,7 @@ gnutls_prf_rfc5705(gnutls_session_t session,
 		   size_t context_size, const char *context,
 		   size_t outsize, char *out)
 {
-	char *pctx = NULL;
+	const version_entry_st *vers = get_version(session);
 	int ret;
 
 	if (context != NULL && context_size > 65535)  {
@@ -126,22 +136,52 @@ gnutls_prf_rfc5705(gnutls_session_t session,
 		return GNUTLS_E_INVALID_REQUEST;
 	}
 
-	if (context != NULL) {
-		pctx = gnutls_malloc(context_size+2);
-		if (!pctx) {
+	if (vers && vers->tls13_sem) {
+		uint8_t secret[MAX_HASH_SIZE];
+		uint8_t digest[MAX_HASH_SIZE];
+		unsigned digest_size = session->security_parameters.prf->output_size;
+
+		/* exporter_master_secret might not be set, when
+		 * handshake is in progress */
+		if (session->internals.handshake_in_progress) {
 			gnutls_assert();
-			return GNUTLS_E_MEMORY_ERROR;
+			return GNUTLS_E_INVALID_REQUEST;
 		}
 
-		memcpy(pctx+2, context, context_size);
-		_gnutls_write_uint16(context_size, (void*)pctx);
-		context_size += 2;
-	}
+		ret = _tls13_derive_secret(session, label, label_size, NULL, 0,
+					   session->key.ap_expkey, secret);
+		if (ret < 0)
+			return gnutls_assert_val(ret);
+
+		ret = gnutls_hash_fast((gnutls_digest_algorithm_t)session->security_parameters.prf->id,
+				       context, context_size, digest);
+		if (ret < 0)
+			return gnutls_assert_val(ret);
+
+		ret = _tls13_expand_secret(session, EXPORTER_LABEL, sizeof(EXPORTER_LABEL)-1,
+					   digest, digest_size,
+					   secret, outsize, out);
+	} else {
+		char *pctx = NULL;
 
-	ret = gnutls_prf(session, label_size, label, 0,
-			 context_size, pctx, outsize, out);
+		if (context != NULL) {
+			pctx = gnutls_malloc(context_size+2);
+			if (!pctx) {
+				gnutls_assert();
+				return GNUTLS_E_MEMORY_ERROR;
+			}
+
+			memcpy(pctx+2, context, context_size);
+			_gnutls_write_uint16(context_size, (void*)pctx);
+			context_size += 2;
+		}
+
+		ret = gnutls_prf(session, label_size, label, 0,
+				 context_size, pctx, outsize, out);
+
+		gnutls_free(pctx);
+	}
 
-	gnutls_free(pctx);
 	return ret;
 }
 
@@ -160,6 +200,10 @@ gnutls_prf_rfc5705(gnutls_session_t session,
  * and the provided data, seeded with the client and server random fields.
  * For the key expansion specified in RFC5705 see gnutls_prf_rfc5705().
  *
+ * This function only works with the TLS versions prior to 1.3.  In
+ * TLS 1.3, the use of PRF is replaced with HKDF (HMAC-based Key
+ * Derivation Function) based on the multi-stage key scheduling.
+ *
  * The @label variable usually contains a string denoting the purpose
  * for the generated data.  The @server_random_first indicates whether
  * the client random field or the server random field should be first
diff --git a/tests/Makefile.am b/tests/Makefile.am
index e7c5a12340..476c532cef 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -93,7 +93,8 @@ indirect_tests =
 
 ctests = tls13/supported_versions tls13/tls12-no-tls13-exts \
 	tls13/post-handshake-with-cert tls13/post-handshake-without-cert \
-	tls13/cookie tls13/key_share tls12-rollback-detection tls11-rollback-detection \
+	tls13/cookie tls13/key_share tls13/prf \
+	tls12-rollback-detection tls11-rollback-detection \
 	tls12-check-rollback-val tls11-check-rollback-val tls13/hello_random_value
 
 ctests += mini-record-2 simple gc set_pkcs12_cred cert certuniqueid tls-neg-ext-key \
diff --git a/tests/tls13/prf.c b/tests/tls13/prf.c
new file mode 100644
index 0000000000..16cca4c5e9
--- /dev/null
+++ b/tests/tls13/prf.c
@@ -0,0 +1,323 @@
+/*
+ * Copyright (C) 2015-2017 Red Hat, Inc.
+ *
+ * This file is part of GnuTLS.
+ *
+ * GnuTLS is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GnuTLS is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#if !defined(__linux__) || !defined(__GNUC__)
+
+int main(int argc, char **argv)
+{
+	exit(77);
+}
+
+#else
+
+#include <string.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <sys/wait.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <gnutls/gnutls.h>
+#include <gnutls/crypto.h>
+
+#include "cert-common.h"
+#include "utils.h"
+
+static void terminate(void);
+
+/* This program tests whether the gnutls_prf() works as
+ * expected.
+ */
+
+static void server_log_func(int level, const char *str)
+{
+	fprintf(stderr, "server|<%d>| %s", level, str);
+}
+
+static void client_log_func(int level, const char *str)
+{
+	fprintf(stderr, "client|<%d>| %s", level, str);
+}
+
+/* These are global */
+static pid_t child;
+
+static const
+gnutls_datum_t hrnd = {(void*)"\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 32};
+static const
+gnutls_datum_t hsrnd = {(void*)"\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 32};
+
+int __attribute__ ((visibility ("protected")))
+gnutls_rnd(gnutls_rnd_level_t level, void *data, size_t len)
+{
+	memset(data, 0xff, len);
+
+	/* Flip the first byte to avoid infinite loop in the RSA
+	 * blinding code of Nettle */
+	if (len > 0)
+		memset(data, 0x0, 1);
+	return 0;
+}
+
+static void dump(const char *name, const uint8_t *data, unsigned data_size)
+{
+	unsigned i;
+
+	fprintf(stderr, "%s", name);
+	for (i=0;i<data_size;i++)
+		fprintf(stderr, "\\x%.2x", (unsigned)data[i]);
+	fprintf(stderr, "\n");
+}
+
+#define TRY(label_size, label, extra_size, extra, size, exp) \
+	{ \
+	ret = gnutls_prf_rfc5705(session, label_size, label, extra_size, extra, size, \
+			 (void*)key_material); \
+	if (ret < 0) { \
+		fprintf(stderr, "gnutls_prf_rfc5705: error in %d\n", __LINE__); \
+		gnutls_perror(ret); \
+		exit(1); \
+	} \
+	if (memcmp(key_material, exp, size) != 0) { \
+		fprintf(stderr, "gnutls_prf_rfc5705: output doesn't match for '%s'\n", label); \
+		dump("got ", key_material, size); \
+		dump("expected ", exp, size); \
+		exit(1); \
+	} \
+	}
+
+static void check_prfs(gnutls_session_t session)
+{
+	unsigned char key_material[512];
+	int ret;
+
+	TRY(13, "key expansion", 0, NULL, 34, (uint8_t*)"\xb1\xc3\x5e\x95\x9f\xf7\x5f\x91\x40\x85\xd7\xe8\xe7\x87\x0f\xb3\x78\xec\xbf\x40\x22\xcb\x24\x6e\x85\x91\xa4\xda\xa0\x48\xa5\xb9\x17\x65");
+	TRY(6, "hello", 0, NULL, 31, (uint8_t*)"\x85\x18\x53\x95\xa8\x60\xa5\x75\xd9\xc3\x34\xa3\x45\xa4\x90\xf0\x9c\x3a\xe3\xcf\x9a\x56\x4c\xcc\xeb\xba\x62\x2f\x36\x68\x84");
+	TRY(7, "context", 5, "abcd\xfa", 31, (uint8_t*)"\xf4\x49\x53\xf2\x8a\xcc\x59\x52\xa2\x29\x7d\xf4\x2f\x41\x92\x27\x6f\xc5\x1f\x52\xdb\x9a\xa5\x28\x33\x90\x28\x25\x52\x9f\x03");
+	TRY(12, "null-context", 0, "", 31, (uint8_t*)"\x91\xb6\xe5\xaf\x3c\x7d\x75\x0a\x66\xe2\xd9\x3d\x57\x2c\x70\x73\x6f\xe2\x8f\x44\x5a\x22\x86\x46\x6b\xe9\x30\xc4\xf4\x0b\x7c");
+}
+
+static void client(int fd)
+{
+	gnutls_session_t session;
+	int ret;
+	gnutls_certificate_credentials_t clientx509cred;
+	const char *err;
+	/* Need to enable anonymous KX specifically. */
+
+	global_init();
+
+	if (debug) {
+		gnutls_global_set_log_function(client_log_func);
+		gnutls_global_set_log_level(4711);
+	}
+
+	gnutls_certificate_allocate_credentials(&clientx509cred);
+
+	/* Initialize TLS session
+	 */
+	gnutls_init(&session, GNUTLS_CLIENT);
+
+	/* Use default priorities */
+	ret = gnutls_priority_set_direct(session,
+				   "NONE:+VERS-TLS1.3:+AES-256-GCM:+AEAD:+SIGN-RSA-PSS-SHA384:+GROUP-SECP256R1",
+				   &err);
+	if (ret < 0) {
+		fail("client: priority set failed (%s): %s\n",
+		     gnutls_strerror(ret), err);
+		exit(1);
+	}
+
+	ret = gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE,
+				clientx509cred);
+	if (ret < 0)
+		exit(1);
+
+	gnutls_handshake_set_random(session, &hrnd);
+	gnutls_transport_set_int(session, fd);
+
+	/* Perform the TLS handshake
+	 */
+	do {
+		ret = gnutls_handshake(session);
+	}
+	while (ret < 0 && gnutls_error_is_fatal(ret) == 0);
+
+	if (ret < 0) {
+		fail("client: Handshake failed: %s\n", strerror(ret));
+		exit(1);
+	} else {
+		if (debug)
+			success("client: Handshake was completed\n");
+	}
+
+	if (debug)
+		success("client: TLS version is: %s\n",
+			gnutls_protocol_get_name
+			(gnutls_protocol_get_version(session)));
+
+	ret = gnutls_cipher_get(session);
+	if (ret != GNUTLS_CIPHER_AES_256_GCM) {
+		fprintf(stderr, "negotiated unexpected cipher: %s\n", gnutls_cipher_get_name(ret));
+		exit(1);
+	}
+
+	ret = gnutls_mac_get(session);
+	if (ret != GNUTLS_MAC_AEAD) {
+		fprintf(stderr, "negotiated unexpected mac: %s\n", gnutls_mac_get_name(ret));
+		exit(1);
+	}
+
+	check_prfs(session);
+
+	gnutls_bye(session, GNUTLS_SHUT_WR);
+
+	close(fd);
+
+	gnutls_deinit(session);
+
+	gnutls_certificate_free_credentials(clientx509cred);
+
+	gnutls_global_deinit();
+}
+
+static void terminate(void)
+{
+	int status = 0;
+
+	kill(child, SIGTERM);
+	wait(&status);
+	exit(1);
+}
+
+static void server(int fd)
+{
+	int ret;
+	gnutls_session_t session;
+	gnutls_certificate_credentials_t serverx509cred;
+
+	/* this must be called once in the program
+	 */
+	global_init();
+
+	if (debug) {
+		gnutls_global_set_log_function(server_log_func);
+		gnutls_global_set_log_level(4711);
+	}
+
+	gnutls_certificate_allocate_credentials(&serverx509cred);
+
+	gnutls_init(&session, GNUTLS_SERVER);
+
+	/* avoid calling all the priority functions, since the defaults
+	 * are adequate.
+	 */
+	ret = gnutls_priority_set_direct(session,
+				   "NORMAL:-VERS-ALL:+VERS-TLS1.3:-KX-ALL", NULL);
+	if (ret < 0) {
+		fail("server: priority set failed (%s)\n\n",
+		     gnutls_strerror(ret));
+		terminate();
+	}
+
+	gnutls_certificate_set_x509_key_mem(serverx509cred,
+					    &server_cert, &server_key,
+					    GNUTLS_X509_FMT_PEM);
+	gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE,
+				serverx509cred);
+
+	gnutls_handshake_set_random(session, &hsrnd);
+	gnutls_transport_set_int(session, fd);
+
+	do {
+		ret = gnutls_handshake(session);
+	}
+	while (ret < 0 && gnutls_error_is_fatal(ret) == 0);
+	if (ret < 0) {
+		close(fd);
+		gnutls_deinit(session);
+		fail("server: Handshake has failed (%s)\n\n",
+		     gnutls_strerror(ret));
+		terminate();
+	}
+	if (debug)
+		success("server: Handshake was completed\n");
+
+	if (debug)
+		success("server: TLS version is: %s\n",
+			gnutls_protocol_get_name
+			(gnutls_protocol_get_version(session)));
+
+	/* do not wait for the peer to close the connection.
+	 */
+	gnutls_bye(session, GNUTLS_SHUT_WR);
+
+	close(fd);
+	gnutls_deinit(session);
+
+	gnutls_certificate_free_credentials(serverx509cred);
+
+	gnutls_global_deinit();
+
+	if (debug)
+		success("server: finished\n");
+}
+
+void doit(void)
+{
+	int fd[2];
+	int ret;
+
+	signal(SIGPIPE, SIG_IGN);
+
+	ret = socketpair(AF_UNIX, SOCK_STREAM, 0, fd);
+	if (ret < 0) {
+		perror("socketpair");
+		exit(1);
+	}
+
+	child = fork();
+	if (child < 0) {
+		perror("fork");
+		fail("fork");
+		exit(1);
+	}
+
+	if (child) {
+		int status;
+		/* parent */
+
+		server(fd[0]);
+		wait(&status);
+		check_wait_status(status);
+	} else {
+		close(fd[0]);
+		client(fd[1]);
+		exit(0);
+	}
+}
+
+#endif				/* _WIN32 */