tests: added unit tests with TLS1.3 key update

Relates #131

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

diff --git a/tests/Makefile.am b/tests/Makefile.am
index 30f1c8147076175e113caafc0110d3130aabf627..f8ed05e917f1e1487aaf6b43763be4e4bc995e79 100644 (file)
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -102,6 +102,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 gnutls_hmac_fast 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 b0e89e867d3b4229416d6fdb10e12450125cda12..2e856db171e113f46b0a1962342ccbcdcf0a3cbe 100644 (file)
--- 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 (file)
index 0000000..1e54fc4
--- /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 */
+}