Merge branch 'tmp-client-auth-decline' into 'master'

cert auth: reject auth if no signature algorithm is usable in TLS 1.3

Closes #730

See merge request gnutls/gnutls!967

8 files changed, 629 insertions, 29 deletions

diff --git a/.gitignore b/.gitignore
index aff3df9bcf..8953088ca4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -824,6 +824,7 @@ tests/tls13/no-psk-exts
 tests/tls13/ocsp-client
 tests/tls13/post-handshake-with-cert
 tests/tls13/post-handshake-with-cert-auto
+tests/tls13/post-handshake-with-cert-pkcs11
 tests/tls13/post-handshake-with-cert-ticket
 tests/tls13/post-handshake-with-psk
 tests/tls13/post-handshake-without-cert
diff --git a/lib/gnutls_int.h b/lib/gnutls_int.h
index f5c89c18cf..72d6c066b6 100644
--- a/lib/gnutls_int.h
+++ b/lib/gnutls_int.h
@@ -1320,7 +1320,6 @@ typedef struct {
 #define HSK_PSK_KE_MODES_RECEIVED (HSK_PSK_KE_MODE_PSK|HSK_PSK_KE_MODE_DHE_PSK|HSK_PSK_KE_MODE_INVALID)
 
 #define HSK_CRT_VRFY_EXPECTED 1
-#define HSK_CRT_SENT (1<<1)
 #define HSK_CRT_ASKED (1<<2)
 #define HSK_HRR_SENT (1<<3)
 #define HSK_HRR_RECEIVED (1<<4)
diff --git a/lib/tls13/certificate_request.c b/lib/tls13/certificate_request.c
index 002646ed6b..d56ce42738 100644
--- a/lib/tls13/certificate_request.c
+++ b/lib/tls13/certificate_request.c
@@ -128,17 +128,20 @@ int _gnutls13_recv_certificate_request_int(gnutls_session_t session, gnutls_buff
 {
 	int ret;
 	crt_req_ctx_st ctx;
+	gnutls_pcert_st *apr_cert_list;
+	gnutls_privkey_t apr_pkey;
+	int apr_cert_list_length;
 
 	_gnutls_handshake_log("HSK[%p]: parsing certificate request\n", session);
 
+	if (unlikely(session->security_parameters.entity == GNUTLS_SERVER))
+		return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
+
 	/* if initial negotiation is complete, this is a post-handshake auth */
-	if (!session->internals.initial_negotiation_completed ||
-	    session->security_parameters.entity == GNUTLS_SERVER) {
+	if (!session->internals.initial_negotiation_completed) {
 		if (buf->data[0] != 0) {
 			/* The context field must be empty during handshake */
-			ret = GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER;
-			gnutls_assert();
-			goto cleanup;
+			return gnutls_assert_val(GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER);
 		}
 
 		/* buf->length is positive */
@@ -162,10 +165,8 @@ int _gnutls13_recv_certificate_request_int(gnutls_session_t session, gnutls_buff
 	ctx.session = session;
 
 	ret = _gnutls_extv_parse(&ctx, parse_cert_extension, buf->data, buf->length);
-	if (ret < 0) {
-		gnutls_assert();
-		goto cleanup;
-	}
+	if (ret < 0)
+		return gnutls_assert_val(ret);
 
 	/* The "signature_algorithms" extension MUST be specified */
 	if (!ctx.got_sig_algo)
@@ -175,15 +176,28 @@ int _gnutls13_recv_certificate_request_int(gnutls_session_t session, gnutls_buff
 
 	ret = _gnutls_select_client_cert(session, ctx.rdn, ctx.rdn_size,
 					 ctx.pk_algos, ctx.pk_algos_length);
-	if (ret < 0) {
-		gnutls_assert();
-		goto cleanup;
-	}
+	if (ret < 0)
+		return gnutls_assert_val(ret);
 
-	ret = 0;
+	ret = _gnutls_get_selected_cert(session, &apr_cert_list,
+					&apr_cert_list_length, &apr_pkey);
+	if (ret < 0)
+		return gnutls_assert_val(ret);
 
- cleanup:
-	return ret;
+	if (apr_cert_list_length > 0) {
+		gnutls_sign_algorithm_t algo;
+
+		algo = _gnutls_session_get_sign_algo(session, &apr_cert_list[0], apr_pkey, 0);
+		if (algo == GNUTLS_SIGN_UNKNOWN) {
+			_gnutls_handshake_log("HSK[%p]: rejecting client auth because of no suitable signature algorithm\n", session);
+			_gnutls_selected_certs_deinit(session);
+			return gnutls_assert_val(0);
+		}
+
+		gnutls_sign_algorithm_set_client(session, algo);
+	}
+
+	return 0;
 }
 
 int _gnutls13_recv_certificate_request(gnutls_session_t session)
diff --git a/lib/tls13/certificate_verify.c b/lib/tls13/certificate_verify.c
index 72b4488115..7300f88f5d 100644
--- a/lib/tls13/certificate_verify.c
+++ b/lib/tls13/certificate_verify.c
@@ -179,22 +179,27 @@ int _gnutls13_send_certificate_verify(gnutls_session_t session, unsigned again)
 			if (server) {
 				return gnutls_assert_val(GNUTLS_E_INSUFFICIENT_CREDENTIALS);
 			} else {
-				/* if we didn't get a cert request there will not be any */
-				if (!(session->internals.hsk_flags & HSK_CRT_SENT))
-					return 0;
-				else
-					return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);
+				/* for client, this means either we
+				 * didn't get a cert request or we are
+				 * declining authentication; in either
+				 * case we don't send a cert verify */
+				return 0;
 			}
 		}
 
-		algo = _gnutls_session_get_sign_algo(session, &apr_cert_list[0], apr_pkey, 0);
-		if (algo == GNUTLS_SIGN_UNKNOWN)
-			return gnutls_assert_val(GNUTLS_E_INCOMPATIBLE_SIG_WITH_KEY);
+		if (server) {
+			algo = _gnutls_session_get_sign_algo(session, &apr_cert_list[0], apr_pkey, 0);
+			if (algo == GNUTLS_SIGN_UNKNOWN)
+				return gnutls_assert_val(GNUTLS_E_INCOMPATIBLE_SIG_WITH_KEY);
 
-		if (server)
 			gnutls_sign_algorithm_set_server(session, algo);
-		else
-			gnutls_sign_algorithm_set_client(session, algo);
+		} else {
+			/* for client, signature algorithm is already
+			 * determined from Certificate Request */
+			algo = gnutls_sign_algorithm_get_client(session);
+			if (unlikely(algo == GNUTLS_SIGN_UNKNOWN))
+				return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);
+		}
 
 		se = _gnutls_sign_to_entry(algo);
 
diff --git a/tests/Makefile.am b/tests/Makefile.am
index 97e63cdbae..96e10bfc5b 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -311,6 +311,11 @@ libpkcs11mock1_la_SOURCES = pkcs11/pkcs11-mock.c pkcs11/pkcs11-mock.h pkcs11/pkc
 libpkcs11mock1_la_LDFLAGS = -shared -rpath $(pkglibdir) -module -no-undefined -avoid-version
 libpkcs11mock1_la_LIBADD =  ../gl/libgnu.la
 
+noinst_LTLIBRARIES += libpkcs11mock2.la
+libpkcs11mock2_la_SOURCES = pkcs11/pkcs11-mock2.c
+libpkcs11mock2_la_LDFLAGS = -shared -rpath $(pkglibdir) -module -no-undefined -avoid-version
+libpkcs11mock2_la_LIBADD =  ../gl/libgnu.la
+
 pkcs11_cert_import_url_exts_SOURCES = pkcs11/pkcs11-cert-import-url-exts.c
 pkcs11_cert_import_url_exts_DEPENDENCIES = libpkcs11mock1.la libutils.la
 
@@ -445,6 +450,14 @@ tls13_anti_replay_CPPFLAGS = $(AM_CPPFLAGS) \
 	-I$(top_builddir)/gl	\
 	$(NETTLE_CFLAGS)
 
+if ENABLE_PKCS11
+if !WINDOWS
+ctests += tls13/post-handshake-with-cert-pkcs11
+tls13_post_handshake_with_cert_pkcs11_DEPENDENCIES = libpkcs11mock2.la libutils.la
+tls13_post_handshake_with_cert_pkcs11_LDADD = $(LDADD) $(LIBDL)
+endif
+endif
+
 dist_check_SCRIPTS = rfc2253-escape-test rsa-md5-collision/rsa-md5-collision.sh systemkey.sh
 
 if !WINDOWS
@@ -524,6 +537,7 @@ TESTS_ENVIRONMENT +=						\
 	LSAN_OPTIONS=suppressions=gnutls-asan.supp		\
 	CAFILE=$(srcdir)/cert-tests/data/ca-certs.pem		\
 	P11MOCKLIB1=$(abs_builddir)/.libs/libpkcs11mock1.so	\
+	P11MOCKLIB2=$(abs_builddir)/.libs/libpkcs11mock2.so	\
 	PKCS12_MANY_CERTS_FILE=$(srcdir)/cert-tests/data/pkcs12_5certs.p12	\
 	PKCS12FILE=$(srcdir)/cert-tests/data/client.p12		\
 	PKCS12PASSWORD=foobar					\
diff --git a/tests/pkcs11/pkcs11-mock2.c b/tests/pkcs11/pkcs11-mock2.c
new file mode 100644
index 0000000000..44bf517bc3
--- /dev/null
+++ b/tests/pkcs11/pkcs11-mock2.c
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2019 Red Hat, Inc.
+ *
+ * Author: Daiki Ueno
+ *
+ * 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 <https://www.gnu.org/licenses/>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <dlfcn.h>
+#include <p11-kit/pkcs11.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <assert.h>
+
+#include "softhsm.h"
+
+/* This provides a mock PKCS #11 module that delegates all the
+ * operations to SoftHSM except that it filters out CKM_RSA_PKCS_PSS
+ * mechanism.
+ */
+
+static void *dl;
+static CK_C_GetMechanismInfo base_C_GetMechanismInfo;
+static CK_FUNCTION_LIST override_funcs;
+
+#ifdef __sun
+# pragma fini(mock_deinit)
+# pragma init(mock_init)
+# define _CONSTRUCTOR
+# define _DESTRUCTOR
+#else
+# define _CONSTRUCTOR __attribute__((constructor))
+# define _DESTRUCTOR __attribute__((destructor))
+#endif
+
+static CK_RV
+override_C_GetMechanismInfo(CK_SLOT_ID slot_id,
+			    CK_MECHANISM_TYPE type,
+			    CK_MECHANISM_INFO *info)
+{
+	if (type == CKM_RSA_PKCS_PSS)
+		return CKR_MECHANISM_INVALID;
+
+	return base_C_GetMechanismInfo(slot_id, type, info);
+}
+
+CK_RV
+C_GetFunctionList(CK_FUNCTION_LIST **function_list)
+{
+	CK_C_GetFunctionList func;
+	CK_FUNCTION_LIST *funcs;
+
+	assert(dl);
+
+	func = dlsym(dl, "C_GetFunctionList");
+	if (func == NULL) {
+		return CKR_GENERAL_ERROR;
+	}
+
+	func(&funcs);
+	base_C_GetMechanismInfo = funcs->C_GetMechanismInfo;
+
+	memcpy(&override_funcs, funcs, sizeof(CK_FUNCTION_LIST));
+	override_funcs.C_GetMechanismInfo = override_C_GetMechanismInfo;
+	*function_list = &override_funcs;
+
+	return CKR_OK;
+}
+
+static _CONSTRUCTOR void
+mock_init(void)
+{
+	const char *lib;
+
+	/* suppress compiler warning */
+	(void) set_softhsm_conf;
+
+	lib = softhsm_lib();
+
+	dl = dlopen(lib, RTLD_NOW);
+	if (dl == NULL)
+		exit(77);
+}
+
+static _DESTRUCTOR void
+mock_deinit(void)
+{
+	dlclose(dl);
+}
diff --git a/tests/tls13-cert-key-exchange.c b/tests/tls13-cert-key-exchange.c
index d59811c760..0eae61c44f 100644
--- a/tests/tls13-cert-key-exchange.c
+++ b/tests/tls13-cert-key-exchange.c
@@ -135,7 +135,7 @@ void doit(void)
 
 	try_with_key_fail("TLS 1.3 with rsa-pss cert and rsa cli cert with only RSA-PSS sig algos",
 			"NORMAL:-VERS-ALL:+VERS-TLS1.3:-SIGN-ALL:+SIGN-RSA-PSS-SHA256:+SIGN-RSA-PSS-SHA384:+SIGN-RSA-PSS-SHA512",
-			GNUTLS_E_AGAIN, GNUTLS_E_INCOMPATIBLE_SIG_WITH_KEY,
+			GNUTLS_E_CERTIFICATE_REQUIRED, GNUTLS_E_SUCCESS,
 			&server_ca3_rsa_pss_cert, &server_ca3_rsa_pss_key, &cli_ca3_cert, &cli_ca3_key);
 
 	try_with_key_fail("TLS 1.3 with rsa encryption cert",
diff --git a/tests/tls13/post-handshake-with-cert-pkcs11.c b/tests/tls13/post-handshake-with-cert-pkcs11.c
new file mode 100644
index 0000000000..ca78ade689
--- /dev/null
+++ b/tests/tls13/post-handshake-with-cert-pkcs11.c
@@ -0,0 +1,459 @@
+/*
+ * Copyright (C) 2017-2019 Red Hat, Inc.
+ *
+ * Author: Daiki Ueno
+ *
+ * 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 <https://www.gnu.org/licenses/>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#if defined(_WIN32)
+
+int main()
+{
+	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/dtls.h>
+#include <signal.h>
+#include <assert.h>
+
+#include "cert-common.h"
+#include "tls13/ext-parse.h"
+#include "pkcs11/softhsm.h"
+#include "utils.h"
+
+/* This program tests whether the Post Handshake Auth extension is
+ * present in the client hello, and whether it is missing from server
+ * hello. In addition it contains basic functionality test for
+ * post handshake authentication.
+ */
+
+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);
+}
+
+#define MAX_BUF 1024
+
+#define P11LIB "libpkcs11mock2.so"
+
+#define PIN "1234"
+
+#define CONFIG_NAME "softhsm-post-handshake-with-cert-pkcs11"
+#define CONFIG CONFIG_NAME".config"
+
+static
+int pin_func(void *userdata, int attempt, const char *url, const char *label,
+	     unsigned flags, char *pin, size_t pin_max)
+{
+	if (attempt == 0) {
+		strcpy(pin, PIN);
+		return 0;
+	}
+	return -1;
+}
+
+static void client(int fd, int err)
+{
+	int ret;
+	gnutls_certificate_credentials_t x509_cred;
+	gnutls_session_t session;
+	gnutls_x509_crt_t crt;
+	gnutls_x509_privkey_t key;
+	gnutls_datum_t tmp;
+	const char *lib;
+	char buffer[MAX_BUF + 1];
+
+	global_init();
+
+	if (debug) {
+		gnutls_global_set_log_function(client_log_func);
+		gnutls_global_set_log_level(7);
+	}
+
+	/* point to SoftHSM token that libpkcs11mock2.so internally uses */
+	setenv(SOFTHSM_ENV, CONFIG, 1);
+
+	gnutls_pkcs11_set_pin_function(pin_func, NULL);
+
+	lib = getenv("P11MOCKLIB2");
+	if (lib == NULL)
+		lib = P11LIB;
+
+	ret = gnutls_pkcs11_init(GNUTLS_PKCS11_FLAG_MANUAL, NULL);
+	if (ret != 0) {
+		fail("%d: %s\n", ret, gnutls_strerror(ret));
+		exit(1);
+	}
+
+	ret = gnutls_pkcs11_add_provider(lib, NULL);
+	if (ret != 0) {
+		fail("%d: %s\n", ret, gnutls_strerror(ret));
+		exit(1);
+	}
+
+	ret = gnutls_x509_crt_init(&crt);
+	if (ret < 0) {
+		fprintf(stderr,
+			"gnutls_x509_crt_init: %s\n", gnutls_strerror(ret));
+		exit(1);
+	}
+
+	ret = gnutls_x509_crt_import(crt, &cli_ca3_cert, GNUTLS_X509_FMT_PEM);
+	if (ret < 0) {
+		fprintf(stderr,
+			"gnutls_x509_crt_import: %s\n", gnutls_strerror(ret));
+		exit(1);
+	}
+
+	if (debug) {
+		gnutls_x509_crt_print(crt, GNUTLS_CRT_PRINT_ONELINE, &tmp);
+
+		printf("\tCertificate: %.*s\n", tmp.size, tmp.data);
+		gnutls_free(tmp.data);
+	}
+
+	ret = gnutls_x509_privkey_init(&key);
+	if (ret < 0) {
+		fprintf(stderr,
+			"gnutls_x509_privkey_init: %s\n", gnutls_strerror(ret));
+		exit(1);
+	}
+
+	ret = gnutls_x509_privkey_import(key, &cli_ca3_key, GNUTLS_X509_FMT_PEM);
+	if (ret < 0) {
+		fprintf(stderr,
+			"gnutls_x509_privkey_import: %s\n",
+			gnutls_strerror(ret));
+		exit(1);
+	}
+
+	/* initialize softhsm token */
+	ret = gnutls_pkcs11_token_init(SOFTHSM_URL, PIN, "test");
+	if (ret < 0) {
+		fail("gnutls_pkcs11_token_init: %s\n", gnutls_strerror(ret));
+		exit(1);
+	}
+
+	ret =
+	    gnutls_pkcs11_token_set_pin(SOFTHSM_URL, NULL, PIN,
+					GNUTLS_PIN_USER);
+	if (ret < 0) {
+		fail("gnutls_pkcs11_token_set_pin: %s\n", gnutls_strerror(ret));
+		exit(1);
+	}
+
+	ret = gnutls_pkcs11_copy_x509_crt(SOFTHSM_URL, crt, "cert",
+					  GNUTLS_PKCS11_OBJ_FLAG_MARK_PRIVATE |
+					  GNUTLS_PKCS11_OBJ_FLAG_LOGIN);
+	if (ret < 0) {
+		fail("gnutls_pkcs11_copy_x509_crt: %s\n", gnutls_strerror(ret));
+		exit(1);
+	}
+
+	ret =
+	    gnutls_pkcs11_copy_x509_privkey(SOFTHSM_URL, key, "cert",
+					    GNUTLS_KEY_DIGITAL_SIGNATURE |
+					    GNUTLS_KEY_KEY_ENCIPHERMENT,
+					    GNUTLS_PKCS11_OBJ_FLAG_MARK_PRIVATE
+					    |
+					    GNUTLS_PKCS11_OBJ_FLAG_MARK_SENSITIVE
+					    | GNUTLS_PKCS11_OBJ_FLAG_LOGIN);
+	if (ret < 0) {
+		fail("gnutls_pkcs11_copy_x509_privkey: %s\n",
+		     gnutls_strerror(ret));
+		exit(1);
+	}
+
+	gnutls_x509_crt_deinit(crt);
+	gnutls_x509_privkey_deinit(key);
+
+	assert(gnutls_certificate_allocate_credentials(&x509_cred)>=0);
+
+	/* Initialize TLS session
+	 */
+	assert(gnutls_init(&session, GNUTLS_CLIENT|GNUTLS_POST_HANDSHAKE_AUTH|GNUTLS_AUTO_REAUTH)>=0);
+
+	gnutls_handshake_set_timeout(session, 20 * 1000);
+
+	ret = gnutls_priority_set_direct(session, "NORMAL:-VERS-ALL:+VERS-TLS1.3:-SIGN-RSA-SHA256", NULL);
+	if (ret < 0)
+		fail("cannot set TLS 1.3 priorities\n");
+
+
+	assert(gnutls_certificate_set_x509_key_file(x509_cred,
+						    SOFTHSM_URL
+						    ";object=cert;object-type=cert",
+						    SOFTHSM_URL
+						    ";object=cert;object-type=private;pin-value="
+						    PIN,
+						    GNUTLS_X509_FMT_DER)>=0);
+
+	gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE, x509_cred);
+
+	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("handshake failed: %s\n", gnutls_strerror(ret));
+
+	if (debug)
+		success("client handshake completed\n");
+
+	gnutls_record_set_timeout(session, 20 * 1000);
+
+	if (debug)
+		success("waiting for auth\n");
+
+	do {
+		ret = gnutls_record_recv(session, buffer, sizeof(buffer));
+	} while (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED);
+
+	if (err) {
+		if (ret != err)
+			fail("client: expected error %s, got: %s\n", gnutls_strerror(err),
+			     gnutls_strerror(ret));
+	} else if (ret < 0)
+		fail("client: gnutls_record_recv did not succeed as expected: %s\n", gnutls_strerror(ret));
+
+	do {
+		ret = gnutls_bye(session, GNUTLS_SHUT_WR);
+	} while (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED);
+
+	close(fd);
+
+	gnutls_deinit(session);
+
+	gnutls_certificate_free_credentials(x509_cred);
+
+	gnutls_global_deinit();
+}
+
+static unsigned client_hello_ok = 0;
+static unsigned server_hello_ok = 0;
+
+#define TLS_EXT_POST_HANDSHAKE 49
+
+static void parse_ext(void *priv, gnutls_datum_t *msg)
+{
+	if (msg->size != 0) {
+		fail("error in extension length: %d\n", (int)msg->size);
+	}
+}
+
+static int hellos_callback(gnutls_session_t session, unsigned int htype,
+	unsigned post, unsigned int incoming, const gnutls_datum_t *msg)
+{
+	if (htype == GNUTLS_HANDSHAKE_SERVER_HELLO && post == GNUTLS_HOOK_POST) {
+		if (find_server_extension(msg, TLS_EXT_POST_HANDSHAKE, NULL, NULL)) {
+			fail("Post handshake extension seen in server hello!\n");
+		}
+		server_hello_ok = 1;
+
+		return GNUTLS_E_INTERRUPTED;
+	}
+
+	if (htype != GNUTLS_HANDSHAKE_CLIENT_HELLO || post != GNUTLS_HOOK_PRE)
+		return 0;
+
+	if (find_client_extension(msg, TLS_EXT_POST_HANDSHAKE, NULL, parse_ext))
+		client_hello_ok = 1;
+	else
+		fail("Post handshake extension NOT seen in client hello!\n");
+
+	return 0;
+}
+
+static void server(int fd, int err, int type)
+{
+	int ret;
+	char buffer[MAX_BUF + 1];
+	gnutls_session_t session;
+	gnutls_certificate_credentials_t x509_cred;
+
+	/* this must be called once in the program
+	 */
+	global_init();
+	memset(buffer, 0, sizeof(buffer));
+
+	if (debug) {
+		gnutls_global_set_log_function(server_log_func);
+		gnutls_global_set_log_level(6);
+	}
+
+	gnutls_certificate_allocate_credentials(&x509_cred);
+	gnutls_certificate_set_x509_key_mem(x509_cred, &server_cert,
+					    &server_key,
+					    GNUTLS_X509_FMT_PEM);
+
+	gnutls_init(&session, GNUTLS_SERVER|GNUTLS_POST_HANDSHAKE_AUTH);
+
+	gnutls_handshake_set_timeout(session, 20 * 1000);
+	gnutls_handshake_set_hook_function(session, GNUTLS_HANDSHAKE_ANY,
+					   GNUTLS_HOOK_BOTH,
+					   hellos_callback);
+
+	/* avoid calling all the priority functions, since the defaults
+	 * are adequate.
+	 */
+	gnutls_priority_set_direct(session, "NORMAL:-VERS-ALL:+VERS-TLS1.3", NULL);
+
+	gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE, x509_cred);
+
+	gnutls_transport_set_int(session, fd);
+
+	do {
+		ret = gnutls_handshake(session);
+	} while (ret < 0 && gnutls_error_is_fatal(ret) == 0);
+
+	if (ret != 0)
+		fail("handshake failed: %s\n", gnutls_strerror(ret));
+
+	if (!(gnutls_session_get_flags(session) & GNUTLS_SFLAGS_POST_HANDSHAKE_AUTH)) {
+		fail("server: session flags did not contain GNUTLS_SFLAGS_POST_HANDSHAKE_AUTH\n");
+	}
+
+
+	if (client_hello_ok == 0) {
+		fail("server: did not verify the client hello\n");
+	}
+
+	if (server_hello_ok == 0) {
+		fail("server: did not verify the server hello contents\n");
+	}
+
+	if (debug)
+		success("server handshake completed\n");
+
+	gnutls_certificate_server_set_request(session, type);
+
+	/* ask peer for re-authentication */
+	do {
+		ret = gnutls_reauth(session, 0);
+	} while (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED);
+
+	if (err) {
+		if (ret != err)
+			fail("server: expected error %s, got: %s\n", gnutls_strerror(err),
+			     gnutls_strerror(ret));
+	} else if (ret != 0)
+		fail("server: gnutls_reauth did not succeed as expected: %s\n", gnutls_strerror(ret));
+
+	do {
+		ret = gnutls_bye(session, GNUTLS_SHUT_RDWR);
+	} while (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED);
+
+	close(fd);
+	gnutls_deinit(session);
+
+	gnutls_certificate_free_credentials(x509_cred);
+
+	gnutls_global_deinit();
+
+	if (debug)
+		success("server: client/server hello were verified\n");
+}
+
+static
+void start(const char *name, int err, int cli_err, int type)
+{
+	int fd[2];
+	int ret;
+	pid_t child;
+	int status = 0;
+
+	success("testing %s\n", name);
+
+	client_hello_ok = 0;
+	server_hello_ok = 0;
+
+	signal(SIGCHLD, SIG_IGN);
+	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) {
+		/* parent */
+		close(fd[1]);
+		client(fd[0], cli_err);
+		kill(child, SIGTERM);
+		wait(&status);
+		check_wait_status(status);
+	} else {
+		close(fd[0]);
+		server(fd[1], err, type);
+		exit(0);
+	}
+
+}
+
+void doit(void)
+{
+	const char *bin;
+	char buf[128];
+
+	/* initialize SoftHSM token that libpkcs11mock2.so internally uses */
+	bin = softhsm_bin();
+
+	set_softhsm_conf(CONFIG);
+	snprintf(buf, sizeof(buf),
+		 "%s --init-token --slot 0 --label test --so-pin " PIN " --pin "
+		 PIN, bin);
+	system(buf);
+
+	start("reauth-require", GNUTLS_E_CERTIFICATE_REQUIRED, GNUTLS_E_SUCCESS, GNUTLS_CERT_REQUIRE);
+	start("reauth-request", 0, GNUTLS_E_SUCCESS, GNUTLS_CERT_REQUEST);
+}
+#endif				/* _WIN32 */