tests: added unit tests with TLS1.3 key update

Relates #131

Signed-off-by: Nikos Mavrogiannopoulos <nmav@redhat.com>

3 files changed, 250 insertions, 0 deletions

diff --git a/tests/Makefile.am b/tests/Makefile.am
index 476c532cef..dab9ab659a 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -97,6 +97,8 @@ ctests = tls13/supported_versions tls13/tls12-no-tls13-exts \
 	tls12-rollback-detection tls11-rollback-detection \
 	tls12-check-rollback-val tls11-check-rollback-val tls13/hello_random_value
 
+ctests += tls13/key_update
+
 ctests += mini-record-2 simple gc set_pkcs12_cred cert certuniqueid tls-neg-ext-key \
 	 mpi certificate_set_x509_crl dn parse_ca x509-dn x509-dn-decode record-sizes \
 	 hostname-check cve-2008-4989 pkcs12_s2k chainverify record-sizes-range \
diff --git a/tests/eagain-common.h b/tests/eagain-common.h
index b0e89e867d..2e856db171 100644
--- a/tests/eagain-common.h
+++ b/tests/eagain-common.h
@@ -133,6 +133,30 @@ extern const char *side;
     } \
   while (transferred < 70000)
 
+#define EMPTY_BUF(s, c, buf, buflen) \
+    { \
+      side = "client"; ret = 0; \
+      while((ret == GNUTLS_E_AGAIN && to_server_len > 0) || to_server_len > 0) \
+	{ \
+	  side = "server"; \
+	  ret = gnutls_record_recv (s, buf, buflen); \
+	} \
+      if (ret < 0 && ret !=GNUTLS_E_AGAIN) \
+	{ \
+	  fail ("server: error: %s\n", gnutls_strerror (ret)); \
+	} \
+      side = "server"; ret = 0; \
+      while((to_client_len > 0 && ret == GNUTLS_E_AGAIN) || to_client_len > 0) \
+	{ \
+	  side = "client"; \
+	  ret = gnutls_record_recv (client, buf, buflen); \
+	} \
+      if (ret < 0 && ret !=GNUTLS_E_AGAIN) \
+	{ \
+	  fail ("client: Error: %s\n", gnutls_strerror (ret)); \
+	} \
+    }
+
 #define TRANSFER(c, s, msg, msglen, buf, buflen) \
   TRANSFER2(c, s, msg, msglen, buf, buflen, 0); \
   TRANSFER2(c, s, msg, msglen, buf, buflen, 1)
diff --git a/tests/tls13/key_update.c b/tests/tls13/key_update.c
new file mode 100644
index 0000000000..1e54fc4bc1
--- /dev/null
+++ b/tests/tls13/key_update.c
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2017 Red Hat, Inc.
+ *
+ * Author: Nikos Mavrogiannopoulos
+ *
+ * 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>
+#include <string.h>
+#include <errno.h>
+#include <gnutls/gnutls.h>
+#include <gnutls/crypto.h>
+#include <assert.h>
+#include "cert-common.h"
+
+#include "utils.h"
+#define RANDOMIZE
+#include "eagain-common.h"
+
+const char *side = "";
+
+static void tls_log_func(int level, const char *str)
+{
+	fprintf(stderr, "%s|<%d>| %s", side, level, str);
+}
+
+#define MAX_BUF 1024
+#define MSG "Hello TLS, and hi and how are you and more data here... and more... and even more and even more more data..."
+
+static void run(const char *name, unsigned test)
+{
+	/* Server stuff. */
+	gnutls_certificate_credentials_t ccred;
+	gnutls_certificate_credentials_t scred;
+	gnutls_session_t server;
+	int sret, cret;
+	/* Client stuff. */
+	gnutls_session_t client;
+	/* Need to enable anonymous KX specifically. */
+	char buffer[MAX_BUF + 1];
+	ssize_t ns;
+	int ret, transferred = 0;
+
+	/* General init. */
+	global_init();
+	gnutls_global_set_log_function(tls_log_func);
+	if (debug)
+		gnutls_global_set_log_level(9);
+
+	/* Init server */
+	assert(gnutls_certificate_allocate_credentials(&scred) >= 0);
+	assert(gnutls_certificate_set_x509_key_mem(scred,
+						   &server_ca3_localhost_cert,
+						   &server_ca3_key,
+						   GNUTLS_X509_FMT_PEM) >= 0);
+
+	assert(gnutls_init(&server, GNUTLS_SERVER) >= 0);
+	ret =
+	    gnutls_priority_set_direct(server,
+				       "NORMAL:-VERS-TLS-ALL:+VERS-TLS1.3",
+				       NULL);
+	if (ret < 0)
+		exit(1);
+
+	gnutls_credentials_set(server, GNUTLS_CRD_CERTIFICATE, scred);
+	gnutls_transport_set_push_function(server, server_push);
+	gnutls_transport_set_pull_function(server, server_pull);
+	gnutls_transport_set_ptr(server, server);
+
+	/* Init client */
+	assert(gnutls_certificate_allocate_credentials(&ccred) >= 0);
+	assert(gnutls_certificate_set_x509_trust_mem
+	       (ccred, &ca3_cert, GNUTLS_X509_FMT_PEM) >= 0);
+
+	gnutls_init(&client, GNUTLS_CLIENT);
+	ret =
+	    gnutls_priority_set_direct(client,
+				       "NORMAL:-VERS-TLS-ALL:+VERS-TLS1.3",
+				       NULL);
+	assert(ret >= 0);
+
+	ret = gnutls_credentials_set(client, GNUTLS_CRD_CERTIFICATE, ccred);
+	if (ret < 0)
+		exit(1);
+
+	gnutls_transport_set_push_function(client, client_push);
+	gnutls_transport_set_pull_function(client, client_pull);
+	gnutls_transport_set_ptr(client, client);
+
+	HANDSHAKE(client, server);
+	if (debug)
+		success("Handshake established\n");
+
+	switch (test) {
+	case 0:
+	case 1:
+		success("%s: updating client's key\n", name);
+		do {
+			ret = gnutls_session_key_update(client, 0);
+		} while (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED);
+
+		/* server receives the client key update and sends data */
+		TRANSFER(client, server, MSG, strlen(MSG), buffer, MAX_BUF);
+		TRANSFER(server, client, MSG, strlen(MSG), buffer, MAX_BUF);
+		EMPTY_BUF(server, client, buffer, MAX_BUF);
+		if (test != 0)
+			break;
+		sec_sleep(1);
+		/* fall-through */
+	case 2:
+		success("%s: updating server's key\n", name);
+
+		do {
+			ret = gnutls_session_key_update(server, 0);
+		} while (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED);
+
+		/* client receives the key update and sends data */
+		TRANSFER(client, server, MSG, strlen(MSG), buffer, MAX_BUF);
+		TRANSFER(server, client, MSG, strlen(MSG), buffer, MAX_BUF);
+		EMPTY_BUF(server, client, buffer, MAX_BUF);
+		if (test != 0)
+			break;
+		sec_sleep(1);
+		/* fall-through */
+	case 3:
+		success("%s: updating client's key and asking server\n", name);
+		do {
+			ret = gnutls_session_key_update(client, GNUTLS_KU_PEER);
+		} while (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED);
+
+		/* server receives the client key update and sends data */
+		TRANSFER(client, server, MSG, strlen(MSG), buffer, MAX_BUF);
+		TRANSFER(server, client, MSG, strlen(MSG), buffer, MAX_BUF);
+		EMPTY_BUF(server, client, buffer, MAX_BUF);
+		if (test != 0)
+			break;
+		sec_sleep(1);
+		/* fall-through */
+	case 4:
+		success("%s: updating server's key and asking client\n", name);
+		do {
+			ret = gnutls_session_key_update(server, GNUTLS_KU_PEER);
+		} while (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED);
+
+		TRANSFER(client, server, MSG, strlen(MSG), buffer, MAX_BUF);
+		TRANSFER(server, client, MSG, strlen(MSG), buffer, MAX_BUF);
+		EMPTY_BUF(server, client, buffer, MAX_BUF);
+		break;
+	case 5:
+		success("%s: client cork\n", name);
+		gnutls_record_cork(client);
+
+		/* server sends key update */
+		do {
+			ret = gnutls_session_key_update(server, GNUTLS_KU_PEER);
+		} while (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED);
+		if (ret < 0)
+			fail("cannot recv: %s\n", gnutls_strerror(ret));
+
+		/* client has data in the corked buffer */
+		do {
+			ret = gnutls_record_send(client, MSG, strlen(MSG));
+		} while (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED);
+		if (ret < 0)
+			fail("cannot send: %s\n", gnutls_strerror(ret));
+
+		/* client receives key update */
+		EMPTY_BUF(server, client, buffer, MAX_BUF);
+
+		/* client uncorks and sends key update */
+		do {
+			ret = gnutls_record_uncork(client, GNUTLS_RECORD_WAIT);
+		} while (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED);
+		if (ret < 0)
+			fail("cannot send: %s\n", gnutls_strerror(ret));
+
+		EMPTY_BUF(server, client, buffer, MAX_BUF);
+		break;
+	}
+
+	if (debug)
+		fputs("\n", stdout);
+
+	gnutls_bye(client, GNUTLS_SHUT_WR);
+	gnutls_bye(server, GNUTLS_SHUT_WR);
+
+	gnutls_deinit(client);
+	gnutls_deinit(server);
+
+	gnutls_certificate_free_credentials(scred);
+	gnutls_certificate_free_credentials(ccred);
+
+	gnutls_global_deinit();
+	reset_buffers();
+}
+
+void doit(void)
+{
+	run("single", 1);
+	run("single", 2);
+	run("single", 3);
+	run("single", 4);
+	run("single", 5);
+	run("all", 0);			/* all one after each other */
+}