poky/meta/recipes-connectivity/openssl/openssl/0001-Added-handshake-history-reporting-when-test-fails.patch - openbmc/openbmc - Gitiles

 From 5ba65051fea0513db0d997f0ab7cafb9826ed74a Mon Sep 17 00:00:00 2001
 From: William Lyu <William.Lyu@windriver.com>
 Date: Fri, 20 Oct 2023 16:22:37 -0400
 Subject: [PATCH] Added handshake history reporting when test fails

 Upstream-Status: Submitted [https://github.com/openssl/openssl/pull/22481]

 Signed-off-by: William Lyu <William.Lyu@windriver.com>
 ---
  test/helpers/handshake.c | 139 +++++++++++++++++++++++++++++----------
  test/helpers/handshake.h |  70 +++++++++++++++++++-
  test/ssl_test.c          |  44 +++++++++++++
  3 files changed, 218 insertions(+), 35 deletions(-)

 diff --git a/test/helpers/handshake.c b/test/helpers/handshake.c
 index e0422469e4..ae2ad59dd4 100644
 --- a/test/helpers/handshake.c
 +++ b/test/helpers/handshake.c
 @@ -1,5 +1,5 @@
  /*
 - * Copyright 2016-2022 The OpenSSL Project Authors. All Rights Reserved.
 + * Copyright 2016-2023 The OpenSSL Project Authors. All Rights Reserved.
   *
   * Licensed under the Apache License 2.0 (the "License").  You may not use
   * this file except in compliance with the License.  You can obtain a copy
 @@ -24,6 +24,102 @@
  #include <netinet/sctp.h>
  #endif

 +/* Shamelessly copied from test/helpers/ssl_test_ctx.c */
 +/* Maps string names to various enumeration type */
 +typedef struct {
 +    const char *name;
 +    int value;
 +} enum_name_map;
 +
 +static const enum_name_map connect_phase_names[] = {
 +    {"Handshake", HANDSHAKE},
 +    {"RenegAppData", RENEG_APPLICATION_DATA},
 +    {"RenegSetup", RENEG_SETUP},
 +    {"RenegHandshake", RENEG_HANDSHAKE},
 +    {"AppData", APPLICATION_DATA},
 +    {"Shutdown", SHUTDOWN},
 +    {"ConnectionDone", CONNECTION_DONE}
 +};
 +
 +static const enum_name_map peer_status_names[] = {
 +    {"PeerSuccess", PEER_SUCCESS},
 +    {"PeerRetry", PEER_RETRY},
 +    {"PeerError", PEER_ERROR},
 +    {"PeerWaiting", PEER_WAITING},
 +    {"PeerTestFail", PEER_TEST_FAILURE}
 +};
 +
 +static const enum_name_map handshake_status_names[] = {
 +    {"HandshakeSuccess", HANDSHAKE_SUCCESS},
 +    {"ClientError", CLIENT_ERROR},
 +    {"ServerError", SERVER_ERROR},
 +    {"InternalError", INTERNAL_ERROR},
 +    {"HandshakeRetry", HANDSHAKE_RETRY}
 +};
 +
 +/* Shamelessly copied from test/helpers/ssl_test_ctx.c */
 +static const char *enum_name(const enum_name_map *enums, size_t num_enums,
 +                             int value)
 +{
 +    size_t i;
 +    for (i = 0; i < num_enums; i++) {
 +        if (enums[i].value == value) {
 +            return enums[i].name;
 +        }
 +    }
 +    return "InvalidValue";
 +}
 +
 +const char *handshake_connect_phase_name(connect_phase_t phase)
 +{
 +    return enum_name(connect_phase_names, OSSL_NELEM(connect_phase_names),
 +                     (int)phase);
 +}
 +
 +const char *handshake_status_name(handshake_status_t handshake_status)
 +{
 +    return enum_name(handshake_status_names, OSSL_NELEM(handshake_status_names),
 +                     (int)handshake_status);
 +}
 +
 +const char *handshake_peer_status_name(peer_status_t peer_status)
 +{
 +    return enum_name(peer_status_names, OSSL_NELEM(peer_status_names),
 +                     (int)peer_status);
 +}
 +
 +static void save_loop_history(HANDSHAKE_HISTORY *history,
 +                              connect_phase_t phase,
 +                              handshake_status_t handshake_status,
 +                              peer_status_t server_status,
 +                              peer_status_t client_status,
 +                              int client_turn_count,
 +                              int is_client_turn)
 +{
 +    HANDSHAKE_HISTORY_ENTRY *new_entry = NULL;
 +
 +    /*
 +     * Create a new history entry for a handshake loop with statuses given in
 +     * the arguments. Potentially evicting the oldest entry when the
 +     * ring buffer is full.
 +     */
 +    ++(history->last_idx);
 +    history->last_idx &= MAX_HANDSHAKE_HISTORY_ENTRY_IDX_MASK;
 +
 +    new_entry = &((history->entries)[history->last_idx]);
 +    new_entry->phase = phase;
 +    new_entry->handshake_status = handshake_status;
 +    new_entry->server_status = server_status;
 +    new_entry->client_status = client_status;
 +    new_entry->client_turn_count = client_turn_count;
 +    new_entry->is_client_turn = is_client_turn;
 +
 +    /* Evict the oldest handshake loop entry when the ring buffer is full. */
 +    if (history->entry_count < MAX_HANDSHAKE_HISTORY_ENTRY) {
 +        ++(history->entry_count);
 +    }
 +}
 +
  HANDSHAKE_RESULT *HANDSHAKE_RESULT_new(void)
  {
      HANDSHAKE_RESULT *ret;
 @@ -719,15 +815,6 @@ static void configure_handshake_ssl(SSL *server, SSL *client,
          SSL_set_post_handshake_auth(client, 1);
  }

 -/* The status for each connection phase. */
 -typedef enum {
 -    PEER_SUCCESS,
 -    PEER_RETRY,
 -    PEER_ERROR,
 -    PEER_WAITING,
 -    PEER_TEST_FAILURE
 -} peer_status_t;
 -
  /* An SSL object and associated read-write buffers. */
  typedef struct peer_st {
      SSL *ssl;
 @@ -1074,17 +1161,6 @@ static void do_shutdown_step(PEER *peer)
      }
  }

 -typedef enum {
 -    HANDSHAKE,
 -    RENEG_APPLICATION_DATA,
 -    RENEG_SETUP,
 -    RENEG_HANDSHAKE,
 -    APPLICATION_DATA,
 -    SHUTDOWN,
 -    CONNECTION_DONE
 -} connect_phase_t;
 -
 -
  static int renegotiate_op(const SSL_TEST_CTX *test_ctx)
  {
      switch (test_ctx->handshake_mode) {
 @@ -1162,19 +1238,6 @@ static void do_connect_step(const SSL_TEST_CTX *test_ctx, PEER *peer,
      }
  }

 -typedef enum {
 -    /* Both parties succeeded. */
 -    HANDSHAKE_SUCCESS,
 -    /* Client errored. */
 -    CLIENT_ERROR,
 -    /* Server errored. */
 -    SERVER_ERROR,
 -    /* Peers are in inconsistent state. */
 -    INTERNAL_ERROR,
 -    /* One or both peers not done. */
 -    HANDSHAKE_RETRY
 -} handshake_status_t;
 -
  /*
   * Determine the handshake outcome.
   * last_status: the status of the peer to have acted last.
 @@ -1539,6 +1602,10 @@ static HANDSHAKE_RESULT *do_handshake_internal(

      start = time(NULL);

 +    save_loop_history(&(ret->history),
 +                      phase, status, server.status, client.status,
 +                      client_turn_count, client_turn);
 +
      /*
       * Half-duplex handshake loop.
       * Client and server speak to each other synchronously in the same process.
 @@ -1560,6 +1627,10 @@ static HANDSHAKE_RESULT *do_handshake_internal(
                                        0 /* server went last */);
          }

 +        save_loop_history(&(ret->history),
 +                          phase, status, server.status, client.status,
 +                          client_turn_count, client_turn);
 +
          switch (status) {
          case HANDSHAKE_SUCCESS:
              client_turn_count = 0;
 diff --git a/test/helpers/handshake.h b/test/helpers/handshake.h
 index 78b03f9f4b..b9967c2623 100644
 --- a/test/helpers/handshake.h
 +++ b/test/helpers/handshake.h
 @@ -1,5 +1,5 @@
  /*
 - * Copyright 2016-2021 The OpenSSL Project Authors. All Rights Reserved.
 + * Copyright 2016-2023 The OpenSSL Project Authors. All Rights Reserved.
   *
   * Licensed under the Apache License 2.0 (the "License").  You may not use
   * this file except in compliance with the License.  You can obtain a copy
 @@ -12,6 +12,11 @@

  #include "ssl_test_ctx.h"

 +#define MAX_HANDSHAKE_HISTORY_ENTRY_BIT 4
 +#define MAX_HANDSHAKE_HISTORY_ENTRY (1 << MAX_HANDSHAKE_HISTORY_ENTRY_BIT)
 +#define MAX_HANDSHAKE_HISTORY_ENTRY_IDX_MASK \
 +    ((1 << MAX_HANDSHAKE_HISTORY_ENTRY_BIT) - 1)
 +
  typedef struct ctx_data_st {
      unsigned char *npn_protocols;
      size_t npn_protocols_len;
 @@ -22,6 +27,63 @@ typedef struct ctx_data_st {
      char *session_ticket_app_data;
  } CTX_DATA;

 +typedef enum {
 +    HANDSHAKE,
 +    RENEG_APPLICATION_DATA,
 +    RENEG_SETUP,
 +    RENEG_HANDSHAKE,
 +    APPLICATION_DATA,
 +    SHUTDOWN,
 +    CONNECTION_DONE
 +} connect_phase_t;
 +
 +/* The status for each connection phase. */
 +typedef enum {
 +    PEER_SUCCESS,
 +    PEER_RETRY,
 +    PEER_ERROR,
 +    PEER_WAITING,
 +    PEER_TEST_FAILURE
 +} peer_status_t;
 +
 +typedef enum {
 +    /* Both parties succeeded. */
 +    HANDSHAKE_SUCCESS,
 +    /* Client errored. */
 +    CLIENT_ERROR,
 +    /* Server errored. */
 +    SERVER_ERROR,
 +    /* Peers are in inconsistent state. */
 +    INTERNAL_ERROR,
 +    /* One or both peers not done. */
 +    HANDSHAKE_RETRY
 +} handshake_status_t;
 +
 +/* Stores the various status information in a handshake loop. */
 +typedef struct handshake_history_entry_st {
 +    connect_phase_t phase;
 +    handshake_status_t handshake_status;
 +    peer_status_t server_status;
 +    peer_status_t client_status;
 +    int client_turn_count;
 +    int is_client_turn;
 +} HANDSHAKE_HISTORY_ENTRY;
 +
 +typedef struct handshake_history_st {
 +    /* Implemented using ring buffer. */
 +    /*
 +     * The valid entries are |entries[last_idx]|, |entries[last_idx-1]|,
 +     * ..., etc., going up to |entry_count| number of entries. Note that when
 +     * the index into the array |entries| becomes < 0, we wrap around to
 +     * the end of |entries|.
 +     */
 +    HANDSHAKE_HISTORY_ENTRY entries[MAX_HANDSHAKE_HISTORY_ENTRY];
 +    /* The number of valid entries in |entries| array. */
 +    size_t entry_count;
 +    /* The index of the last valid entry in the |entries| array. */
 +    size_t last_idx;
 +} HANDSHAKE_HISTORY;
 +
  typedef struct handshake_result {
      ssl_test_result_t result;
      /* These alerts are in the 2-byte format returned by the info_callback. */
 @@ -77,6 +139,8 @@ typedef struct handshake_result {
      char *cipher;
      /* session ticket application data */
      char *result_session_ticket_app_data;
 +    /* handshake loop history */
 +    HANDSHAKE_HISTORY history;
  } HANDSHAKE_RESULT;

  HANDSHAKE_RESULT *HANDSHAKE_RESULT_new(void);
 @@ -95,4 +159,8 @@ int configure_handshake_ctx_for_srp(SSL_CTX *server_ctx, SSL_CTX *server2_ctx,
                                      CTX_DATA *server2_ctx_data,
                                      CTX_DATA *client_ctx_data);

 +const char *handshake_connect_phase_name(connect_phase_t phase);
 +const char *handshake_status_name(handshake_status_t handshake_status);
 +const char *handshake_peer_status_name(peer_status_t peer_status);
 +
  #endif  /* OSSL_TEST_HANDSHAKE_HELPER_H */
 diff --git a/test/ssl_test.c b/test/ssl_test.c
 index ea608518f9..9d6b093c81 100644
 --- a/test/ssl_test.c
 +++ b/test/ssl_test.c
 @@ -26,6 +26,44 @@ static OSSL_LIB_CTX *libctx = NULL;
  /* Currently the section names are of the form test-<number>, e.g. test-15. */
  #define MAX_TESTCASE_NAME_LENGTH 100

 +static void print_handshake_history(const HANDSHAKE_HISTORY *history)
 +{
 +    size_t first_idx;
 +    size_t i;
 +    size_t cur_idx;
 +    const HANDSHAKE_HISTORY_ENTRY *cur_entry;
 +    const char header_template[] = "|%14s|%16s|%16s|%16s|%17s|%14s|";
 +    const char body_template[]   = "|%14s|%16s|%16s|%16s|%17d|%14s|";
 +
 +    TEST_info("The following is the server/client state "
 +              "in the most recent %d handshake loops.",
 +              MAX_HANDSHAKE_HISTORY_ENTRY);
 +
 +    TEST_note("=================================================="
 +              "==================================================");
 +    TEST_note(header_template,
 +              "phase", "handshake status", "server status",
 +              "client status", "client turn count", "is client turn");
 +    TEST_note("+--------------+----------------+----------------"
 +              "+----------------+-----------------+--------------+");
 +
 +    first_idx = (history->last_idx - history->entry_count + 1) &
 +                MAX_HANDSHAKE_HISTORY_ENTRY_IDX_MASK;
 +    for (i = 0; i < history->entry_count; ++i) {
 +        cur_idx = (first_idx + i) & MAX_HANDSHAKE_HISTORY_ENTRY_IDX_MASK;
 +        cur_entry = &(history->entries)[cur_idx];
 +        TEST_note(body_template,
 +                  handshake_connect_phase_name(cur_entry->phase),
 +                  handshake_status_name(cur_entry->handshake_status),
 +                  handshake_peer_status_name(cur_entry->server_status),
 +                  handshake_peer_status_name(cur_entry->client_status),
 +                  cur_entry->client_turn_count,
 +                  cur_entry->is_client_turn ? "true" : "false");
 +    }
 +    TEST_note("=================================================="
 +              "==================================================");
 +}
 +
  static const char *print_alert(int alert)
  {
      return alert ? SSL_alert_desc_string_long(alert) : "no alert";
 @@ -388,6 +426,12 @@ static int check_test(HANDSHAKE_RESULT *result, SSL_TEST_CTX *test_ctx)
          ret &= check_client_sign_type(result, test_ctx);
          ret &= check_client_ca_names(result, test_ctx);
      }
 +
 +    /* Print handshake loop history if any check fails. */
 +    if (!ret) {
 +        print_handshake_history(&(result->history));
 +    }
 +
      return ret;
  }

 --
 2.25.1
	From 5ba65051fea0513db0d997f0ab7cafb9826ed74a Mon Sep 17 00:00:00 2001
	From: William Lyu <William.Lyu@windriver.com>
	Date: Fri, 20 Oct 2023 16:22:37 -0400
	Subject: [PATCH] Added handshake history reporting when test fails

	Upstream-Status: Submitted [https://github.com/openssl/openssl/pull/22481]

	Signed-off-by: William Lyu <William.Lyu@windriver.com>
	---
	test/helpers/handshake.c \| 139 +++++++++++++++++++++++++++++----------
	test/helpers/handshake.h \| 70 +++++++++++++++++++-
	test/ssl_test.c \| 44 +++++++++++++
	3 files changed, 218 insertions(+), 35 deletions(-)

	diff --git a/test/helpers/handshake.c b/test/helpers/handshake.c
	index e0422469e4..ae2ad59dd4 100644
	--- a/test/helpers/handshake.c
	+++ b/test/helpers/handshake.c
	@@ -1,5 +1,5 @@
	/*
	- * Copyright 2016-2022 The OpenSSL Project Authors. All Rights Reserved.
	+ * Copyright 2016-2023 The OpenSSL Project Authors. All Rights Reserved.
	*
	* Licensed under the Apache License 2.0 (the "License"). You may not use
	* this file except in compliance with the License. You can obtain a copy
	@@ -24,6 +24,102 @@
	#include <netinet/sctp.h>
	#endif

	+/* Shamelessly copied from test/helpers/ssl_test_ctx.c */
	+/* Maps string names to various enumeration type */
	+typedef struct {
	+ const char *name;
	+ int value;
	+} enum_name_map;
	+
	+static const enum_name_map connect_phase_names[] = {
	+ {"Handshake", HANDSHAKE},
	+ {"RenegAppData", RENEG_APPLICATION_DATA},
	+ {"RenegSetup", RENEG_SETUP},
	+ {"RenegHandshake", RENEG_HANDSHAKE},
	+ {"AppData", APPLICATION_DATA},
	+ {"Shutdown", SHUTDOWN},
	+ {"ConnectionDone", CONNECTION_DONE}
	+};
	+
	+static const enum_name_map peer_status_names[] = {
	+ {"PeerSuccess", PEER_SUCCESS},
	+ {"PeerRetry", PEER_RETRY},
	+ {"PeerError", PEER_ERROR},
	+ {"PeerWaiting", PEER_WAITING},
	+ {"PeerTestFail", PEER_TEST_FAILURE}
	+};
	+
	+static const enum_name_map handshake_status_names[] = {
	+ {"HandshakeSuccess", HANDSHAKE_SUCCESS},
	+ {"ClientError", CLIENT_ERROR},
	+ {"ServerError", SERVER_ERROR},
	+ {"InternalError", INTERNAL_ERROR},
	+ {"HandshakeRetry", HANDSHAKE_RETRY}
	+};
	+
	+/* Shamelessly copied from test/helpers/ssl_test_ctx.c */
	+static const char enum_name(const enum_name_map enums, size_t num_enums,
	+ int value)
	+{
	+ size_t i;
	+ for (i = 0; i < num_enums; i++) {
	+ if (enums[i].value == value) {
	+ return enums[i].name;
	+ }
	+ }
	+ return "InvalidValue";
	+}
	+
	+const char *handshake_connect_phase_name(connect_phase_t phase)
	+{
	+ return enum_name(connect_phase_names, OSSL_NELEM(connect_phase_names),
	+ (int)phase);
	+}
	+
	+const char *handshake_status_name(handshake_status_t handshake_status)
	+{
	+ return enum_name(handshake_status_names, OSSL_NELEM(handshake_status_names),
	+ (int)handshake_status);
	+}
	+
	+const char *handshake_peer_status_name(peer_status_t peer_status)
	+{
	+ return enum_name(peer_status_names, OSSL_NELEM(peer_status_names),
	+ (int)peer_status);
	+}
	+
	+static void save_loop_history(HANDSHAKE_HISTORY *history,
	+ connect_phase_t phase,
	+ handshake_status_t handshake_status,
	+ peer_status_t server_status,
	+ peer_status_t client_status,
	+ int client_turn_count,
	+ int is_client_turn)
	+{
	+ HANDSHAKE_HISTORY_ENTRY *new_entry = NULL;
	+
	+ /*
	+ * Create a new history entry for a handshake loop with statuses given in
	+ * the arguments. Potentially evicting the oldest entry when the
	+ * ring buffer is full.
	+ */
	+ ++(history->last_idx);
	+ history->last_idx &= MAX_HANDSHAKE_HISTORY_ENTRY_IDX_MASK;
	+
	+ new_entry = &((history->entries)[history->last_idx]);
	+ new_entry->phase = phase;
	+ new_entry->handshake_status = handshake_status;
	+ new_entry->server_status = server_status;
	+ new_entry->client_status = client_status;
	+ new_entry->client_turn_count = client_turn_count;
	+ new_entry->is_client_turn = is_client_turn;
	+
	+ /* Evict the oldest handshake loop entry when the ring buffer is full. */
	+ if (history->entry_count < MAX_HANDSHAKE_HISTORY_ENTRY) {
	+ ++(history->entry_count);
	+ }
	+}
	+
	HANDSHAKE_RESULT *HANDSHAKE_RESULT_new(void)
	{
	HANDSHAKE_RESULT *ret;
	@@ -719,15 +815,6 @@ static void configure_handshake_ssl(SSL server, SSL client,
	SSL_set_post_handshake_auth(client, 1);
	}

	-/* The status for each connection phase. */
	-typedef enum {
	- PEER_SUCCESS,
	- PEER_RETRY,
	- PEER_ERROR,
	- PEER_WAITING,
	- PEER_TEST_FAILURE
	-} peer_status_t;
	-
	/* An SSL object and associated read-write buffers. */
	typedef struct peer_st {
	SSL *ssl;
	@@ -1074,17 +1161,6 @@ static void do_shutdown_step(PEER *peer)
	}
	}

	-typedef enum {
	- HANDSHAKE,
	- RENEG_APPLICATION_DATA,
	- RENEG_SETUP,
	- RENEG_HANDSHAKE,
	- APPLICATION_DATA,
	- SHUTDOWN,
	- CONNECTION_DONE
	-} connect_phase_t;
	-
	-
	static int renegotiate_op(const SSL_TEST_CTX *test_ctx)
	{
	switch (test_ctx->handshake_mode) {
	@@ -1162,19 +1238,6 @@ static void do_connect_step(const SSL_TEST_CTX test_ctx, PEER peer,
	}
	}

	-typedef enum {
	- /* Both parties succeeded. */
	- HANDSHAKE_SUCCESS,
	- /* Client errored. */
	- CLIENT_ERROR,
	- /* Server errored. */
	- SERVER_ERROR,
	- /* Peers are in inconsistent state. */
	- INTERNAL_ERROR,
	- /* One or both peers not done. */
	- HANDSHAKE_RETRY
	-} handshake_status_t;
	-
	/*
	* Determine the handshake outcome.
	* last_status: the status of the peer to have acted last.
	@@ -1539,6 +1602,10 @@ static HANDSHAKE_RESULT *do_handshake_internal(

	start = time(NULL);

	+ save_loop_history(&(ret->history),
	+ phase, status, server.status, client.status,
	+ client_turn_count, client_turn);
	+
	/*
	* Half-duplex handshake loop.
	* Client and server speak to each other synchronously in the same process.
	@@ -1560,6 +1627,10 @@ static HANDSHAKE_RESULT *do_handshake_internal(
	0 /* server went last */);
	}

	+ save_loop_history(&(ret->history),
	+ phase, status, server.status, client.status,
	+ client_turn_count, client_turn);
	+
	switch (status) {
	case HANDSHAKE_SUCCESS:
	client_turn_count = 0;
	diff --git a/test/helpers/handshake.h b/test/helpers/handshake.h
	index 78b03f9f4b..b9967c2623 100644
	--- a/test/helpers/handshake.h
	+++ b/test/helpers/handshake.h
	@@ -1,5 +1,5 @@
	/*
	- * Copyright 2016-2021 The OpenSSL Project Authors. All Rights Reserved.
	+ * Copyright 2016-2023 The OpenSSL Project Authors. All Rights Reserved.
	*
	* Licensed under the Apache License 2.0 (the "License"). You may not use
	* this file except in compliance with the License. You can obtain a copy
	@@ -12,6 +12,11 @@

	#include "ssl_test_ctx.h"

	+#define MAX_HANDSHAKE_HISTORY_ENTRY_BIT 4
	+#define MAX_HANDSHAKE_HISTORY_ENTRY (1 << MAX_HANDSHAKE_HISTORY_ENTRY_BIT)
	+#define MAX_HANDSHAKE_HISTORY_ENTRY_IDX_MASK \
	+ ((1 << MAX_HANDSHAKE_HISTORY_ENTRY_BIT) - 1)
	+
	typedef struct ctx_data_st {
	unsigned char *npn_protocols;
	size_t npn_protocols_len;
	@@ -22,6 +27,63 @@ typedef struct ctx_data_st {
	char *session_ticket_app_data;
	} CTX_DATA;

	+typedef enum {
	+ HANDSHAKE,
	+ RENEG_APPLICATION_DATA,
	+ RENEG_SETUP,
	+ RENEG_HANDSHAKE,
	+ APPLICATION_DATA,
	+ SHUTDOWN,
	+ CONNECTION_DONE
	+} connect_phase_t;
	+
	+/* The status for each connection phase. */
	+typedef enum {
	+ PEER_SUCCESS,
	+ PEER_RETRY,
	+ PEER_ERROR,
	+ PEER_WAITING,
	+ PEER_TEST_FAILURE
	+} peer_status_t;
	+
	+typedef enum {
	+ /* Both parties succeeded. */
	+ HANDSHAKE_SUCCESS,
	+ /* Client errored. */
	+ CLIENT_ERROR,
	+ /* Server errored. */
	+ SERVER_ERROR,
	+ /* Peers are in inconsistent state. */
	+ INTERNAL_ERROR,
	+ /* One or both peers not done. */
	+ HANDSHAKE_RETRY
	+} handshake_status_t;
	+
	+/* Stores the various status information in a handshake loop. */
	+typedef struct handshake_history_entry_st {
	+ connect_phase_t phase;
	+ handshake_status_t handshake_status;
	+ peer_status_t server_status;
	+ peer_status_t client_status;
	+ int client_turn_count;
	+ int is_client_turn;
	+} HANDSHAKE_HISTORY_ENTRY;
	+
	+typedef struct handshake_history_st {
	+ /* Implemented using ring buffer. */
	+ /*
	+ * The valid entries are \|entries[last_idx]\|, \|entries[last_idx-1]\|,
	+ * ..., etc., going up to \|entry_count\| number of entries. Note that when
	+ * the index into the array \|entries\| becomes < 0, we wrap around to
	+ * the end of \|entries\|.
	+ */
	+ HANDSHAKE_HISTORY_ENTRY entries[MAX_HANDSHAKE_HISTORY_ENTRY];
	+ /* The number of valid entries in \|entries\| array. */
	+ size_t entry_count;
	+ /* The index of the last valid entry in the \|entries\| array. */
	+ size_t last_idx;
	+} HANDSHAKE_HISTORY;
	+
	typedef struct handshake_result {
	ssl_test_result_t result;
	/* These alerts are in the 2-byte format returned by the info_callback. */
	@@ -77,6 +139,8 @@ typedef struct handshake_result {
	char *cipher;
	/* session ticket application data */
	char *result_session_ticket_app_data;
	+ /* handshake loop history */
	+ HANDSHAKE_HISTORY history;
	} HANDSHAKE_RESULT;

	HANDSHAKE_RESULT *HANDSHAKE_RESULT_new(void);
	@@ -95,4 +159,8 @@ int configure_handshake_ctx_for_srp(SSL_CTX server_ctx, SSL_CTX server2_ctx,
	CTX_DATA *server2_ctx_data,
	CTX_DATA *client_ctx_data);

	+const char *handshake_connect_phase_name(connect_phase_t phase);
	+const char *handshake_status_name(handshake_status_t handshake_status);
	+const char *handshake_peer_status_name(peer_status_t peer_status);
	+
	#endif /* OSSL_TEST_HANDSHAKE_HELPER_H */
	diff --git a/test/ssl_test.c b/test/ssl_test.c
	index ea608518f9..9d6b093c81 100644
	--- a/test/ssl_test.c
	+++ b/test/ssl_test.c
	@@ -26,6 +26,44 @@ static OSSL_LIB_CTX *libctx = NULL;
	/* Currently the section names are of the form test-<number>, e.g. test-15. */
	#define MAX_TESTCASE_NAME_LENGTH 100

	+static void print_handshake_history(const HANDSHAKE_HISTORY *history)
	+{
	+ size_t first_idx;
	+ size_t i;
	+ size_t cur_idx;
	+ const HANDSHAKE_HISTORY_ENTRY *cur_entry;
	+ const char header_template[] = "\|%14s\|%16s\|%16s\|%16s\|%17s\|%14s\|";
	+ const char body_template[] = "\|%14s\|%16s\|%16s\|%16s\|%17d\|%14s\|";
	+
	+ TEST_info("The following is the server/client state "
	+ "in the most recent %d handshake loops.",
	+ MAX_HANDSHAKE_HISTORY_ENTRY);
	+
	+ TEST_note("=================================================="
	+ "==================================================");
	+ TEST_note(header_template,
	+ "phase", "handshake status", "server status",
	+ "client status", "client turn count", "is client turn");
	+ TEST_note("+--------------+----------------+----------------"
	+ "+----------------+-----------------+--------------+");
	+
	+ first_idx = (history->last_idx - history->entry_count + 1) &
	+ MAX_HANDSHAKE_HISTORY_ENTRY_IDX_MASK;
	+ for (i = 0; i < history->entry_count; ++i) {
	+ cur_idx = (first_idx + i) & MAX_HANDSHAKE_HISTORY_ENTRY_IDX_MASK;
	+ cur_entry = &(history->entries)[cur_idx];
	+ TEST_note(body_template,
	+ handshake_connect_phase_name(cur_entry->phase),
	+ handshake_status_name(cur_entry->handshake_status),
	+ handshake_peer_status_name(cur_entry->server_status),
	+ handshake_peer_status_name(cur_entry->client_status),
	+ cur_entry->client_turn_count,
	+ cur_entry->is_client_turn ? "true" : "false");
	+ }
	+ TEST_note("=================================================="
	+ "==================================================");
	+}
	+
	static const char *print_alert(int alert)
	{
	return alert ? SSL_alert_desc_string_long(alert) : "no alert";
	@@ -388,6 +426,12 @@ static int check_test(HANDSHAKE_RESULT result, SSL_TEST_CTX test_ctx)
	ret &= check_client_sign_type(result, test_ctx);
	ret &= check_client_ca_names(result, test_ctx);
	}
	+
	+ /* Print handshake loop history if any check fails. */
	+ if (!ret) {
	+ print_handshake_history(&(result->history));
	+ }
	+
	return ret;
	}

	--
	2.25.1