aws-crt 0.1.9 → 0.2.0

data/aws-crt-ffi/crt/s2n/bindings/rust/s2n-tls-tokio/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "s2n-tls-tokio"
 description = "An implementation of TLS streams for Tokio built on top of s2n-tls"
-version = "0.0.38"
+version = "0.0.40"
 authors = ["AWS s2n"]
 edition = "2021"
 rust-version = "1.63.0"
@@ -15,7 +15,7 @@ default = []
 errno = { version = "0.3" }
 libc = { version = "0.2" }
 pin-project-lite = { version = "0.2" }
-s2n-tls = { version = "=0.0.38", path = "../s2n-tls" }
+s2n-tls = { version = "=0.0.40", path = "../s2n-tls" }
 tokio = { version = "1", features = ["net", "time"] }
 
 [dev-dependencies]

data/aws-crt-ffi/crt/s2n/tests/cbmc/sources/make_common_datastructures.c

@@ -518,6 +518,13 @@ void cbmc_populate_s2n_signature_scheme(struct s2n_signature_scheme *s2n_signatu
     s2n_signature_scheme->signature_curve = cbmc_allocate_s2n_ecc_named_curve();
 }
 
+struct s2n_signature_scheme *cbmc_allocate_s2n_signature_scheme()
+{
+    struct s2n_signature_scheme *s2n_signature_scheme = malloc(sizeof(*s2n_signature_scheme));
+    cbmc_populate_s2n_signature_scheme(s2n_signature_scheme);
+    return s2n_signature_scheme;
+}
+
 struct s2n_kex *cbmc_allocate_s2n_kex()
 {
     struct s2n_kex *s2n_kex = malloc(sizeof(*s2n_kex));
@@ -660,10 +667,10 @@ void cbmc_populate_s2n_handshake_parameters(struct s2n_handshake_parameters *s2n
     CBMC_ENSURE_REF(s2n_handshake_parameters);
     cbmc_populate_s2n_pkey(&(s2n_handshake_parameters->server_public_key));
     cbmc_populate_s2n_pkey(&(s2n_handshake_parameters->client_public_key));
-    cbmc_populate_s2n_signature_scheme(&(s2n_handshake_parameters->conn_sig_scheme));
     cbmc_populate_s2n_blob(&(s2n_handshake_parameters->client_cert_chain));
-    cbmc_populate_s2n_signature_scheme(&(s2n_handshake_parameters->client_cert_sig_scheme));
     cbmc_populate_s2n_cert_chain_and_key(s2n_handshake_parameters->our_chain_and_key);
+    s2n_handshake_parameters->server_cert_sig_scheme = cbmc_allocate_s2n_signature_scheme();
+    s2n_handshake_parameters->client_cert_sig_scheme = cbmc_allocate_s2n_signature_scheme();
     /* `s2n_handshake_parameters->exact_sni_matches`
      * `s2n_handshake_parameters->wc_sni_matches` are never allocated.
      * If required, these initializations should be done in the proof harness.

data/aws-crt-ffi/crt/s2n/tests/fuzz/s2n_client_cert_verify_recv_test.c

@@ -13,7 +13,7 @@
  * permissions and limitations under the License.
  */
 
-/* Target Functions: s2n_client_cert_verify_recv s2n_get_and_validate_negotiated_signature_scheme s2n_pkey_verify */
+/* Target Functions: s2n_client_cert_verify_recv s2n_signature_algorithm_recv s2n_pkey_verify */
 
 #include <openssl/crypto.h>
 #include <openssl/err.h>

data/aws-crt-ffi/crt/s2n/tests/fuzz/s2n_hybrid_ecdhe_kyber_r3_fuzz_test.c

@@ -55,7 +55,7 @@ static int setup_connection(struct s2n_connection *server_conn, struct s2n_kem_p
     server_conn->kex_params.server_ecc_evp_params.evp_pkey = NULL;
     server_conn->kex_params.kem_params.kem = &s2n_kyber_512_r3;
     server_conn->secure->cipher_suite = &s2n_ecdhe_kyber_rsa_with_aes_256_gcm_sha384;
-    server_conn->handshake_params.conn_sig_scheme = s2n_rsa_pkcs1_sha384;
+    server_conn->handshake_params.server_cert_sig_scheme = &s2n_rsa_pkcs1_sha384;
 
     POSIX_GUARD(s2n_dup(&params->private_key, &server_conn->kex_params.kem_params.private_key));
     POSIX_GUARD(s2n_ecc_evp_generate_ephemeral_key(&server_conn->kex_params.server_ecc_evp_params));

data/aws-crt-ffi/crt/s2n/tests/fuzz/s2n_tls13_cert_verify_recv_test.c

@@ -13,7 +13,7 @@
  * permissions and limitations under the License.
  */
 
-/* Target Functions: s2n_tls13_cert_verify_recv s2n_get_and_validate_negotiated_signature_scheme
+/* Target Functions: s2n_tls13_cert_verify_recv s2n_signature_algorithm_recv
                      s2n_tls13_cert_read_and_verify_signature */
 
 #include <stdint.h>

data/aws-crt-ffi/crt/s2n/tests/integrationv2/test_version_negotiation.py

@@ -77,12 +77,12 @@ def test_s2nc_tls13_negotiates_tls12(managed_process, cipher, curve, certificate
 
     for results in server.get_results():
         results.assert_success()
+        # This check only cares about S2N. Trying to maintain expected output of other providers doesn't add benefit to
+        # whether the S2N client was able to negotiate a lower TLS version.
         if provider is S2N:
-            # The server is only TLS12, so it reads the version from the CLIENT_HELLO, which is never above TLS12
-            # This check only cares about S2N. Trying to maintain expected output of other providers doesn't
-            # add benefit to whether the S2N client was able to negotiate a lower TLS version.
+            # The client sends a TLS 1.3 client hello so a client protocol version of TLS 1.3 should always be expected.
             assert to_bytes("Client protocol version: {}".format(
-                actual_version)) in results.stdout
+                Protocols.TLS13.value)) in results.stdout
             assert to_bytes("Actual protocol version: {}".format(
                 actual_version)) in results.stdout
 

data/aws-crt-ffi/crt/s2n/tests/unit/s2n_auth_selection_test.c

@@ -53,7 +53,7 @@ static int s2n_test_auth_combo(struct s2n_connection *conn,
     conn->secure->cipher_suite = cipher_suite;
 
     POSIX_GUARD(s2n_is_sig_scheme_valid_for_auth(conn, sig_scheme));
-    conn->handshake_params.conn_sig_scheme.sig_alg = sig_scheme->sig_alg;
+    conn->handshake_params.server_cert_sig_scheme = sig_scheme;
 
     POSIX_GUARD(s2n_select_certs_for_server_auth(conn, &actual_cert_chain));
     POSIX_ENSURE_EQ(actual_cert_chain, expected_cert_chain);
@@ -303,38 +303,48 @@ int main(int argc, char **argv)
         /* Requested cert chain exists */
         s2n_connection_set_config(conn, all_certs_config);
 
-        conn->handshake_params.conn_sig_scheme.sig_alg = S2N_SIGNATURE_RSA;
+        struct s2n_signature_scheme test_sig_scheme = { 0 };
+        conn->handshake_params.server_cert_sig_scheme = &test_sig_scheme;
+
+        test_sig_scheme.sig_alg = S2N_SIGNATURE_RSA;
         EXPECT_SUCCESS(s2n_select_certs_for_server_auth(conn, &chosen_certs));
         EXPECT_EQUAL(chosen_certs, rsa_cert_chain);
 
-        conn->handshake_params.conn_sig_scheme.sig_alg = S2N_SIGNATURE_RSA_PSS_PSS;
+        /* cppcheck-suppress redundantAssignment */
+        test_sig_scheme.sig_alg = S2N_SIGNATURE_RSA_PSS_PSS;
         EXPECT_SUCCESS_IF_RSA_PSS_CERTS_SUPPORTED(s2n_select_certs_for_server_auth(conn, &chosen_certs));
         EXPECT_EQUAL(chosen_certs, rsa_pss_cert_chain);
 
-        conn->handshake_params.conn_sig_scheme.sig_alg = S2N_SIGNATURE_RSA_PSS_RSAE;
+        /* cppcheck-suppress redundantAssignment */
+        test_sig_scheme.sig_alg = S2N_SIGNATURE_RSA_PSS_RSAE;
         EXPECT_SUCCESS(s2n_select_certs_for_server_auth(conn, &chosen_certs));
         EXPECT_EQUAL(chosen_certs, rsa_cert_chain);
 
-        conn->handshake_params.conn_sig_scheme.sig_alg = S2N_SIGNATURE_ECDSA;
+        /* cppcheck-suppress redundantAssignment */
+        test_sig_scheme.sig_alg = S2N_SIGNATURE_ECDSA;
         EXPECT_SUCCESS(s2n_select_certs_for_server_auth(conn, &chosen_certs));
         EXPECT_EQUAL(chosen_certs, ecdsa_cert_chain);
 
         /* Requested cert chain does NOT exist */
         s2n_connection_set_config(conn, no_certs_config);
 
-        conn->handshake_params.conn_sig_scheme.sig_alg = S2N_SIGNATURE_RSA;
+        /* cppcheck-suppress redundantAssignment */
+        test_sig_scheme.sig_alg = S2N_SIGNATURE_RSA;
         EXPECT_FAILURE(s2n_select_certs_for_server_auth(conn, &chosen_certs));
         EXPECT_NULL(chosen_certs);
 
-        conn->handshake_params.conn_sig_scheme.sig_alg = S2N_SIGNATURE_RSA_PSS_PSS;
+        /* cppcheck-suppress redundantAssignment */
+        test_sig_scheme.sig_alg = S2N_SIGNATURE_RSA_PSS_PSS;
         EXPECT_FAILURE(s2n_select_certs_for_server_auth(conn, &chosen_certs));
         EXPECT_NULL(chosen_certs);
 
-        conn->handshake_params.conn_sig_scheme.sig_alg = S2N_SIGNATURE_RSA_PSS_RSAE;
+        /* cppcheck-suppress redundantAssignment */
+        test_sig_scheme.sig_alg = S2N_SIGNATURE_RSA_PSS_RSAE;
         EXPECT_FAILURE(s2n_select_certs_for_server_auth(conn, &chosen_certs));
         EXPECT_NULL(chosen_certs);
 
-        conn->handshake_params.conn_sig_scheme.sig_alg = S2N_SIGNATURE_ECDSA;
+        /* cppcheck-suppress redundantAssignment */
+        test_sig_scheme.sig_alg = S2N_SIGNATURE_ECDSA;
         EXPECT_FAILURE(s2n_select_certs_for_server_auth(conn, &chosen_certs));
         EXPECT_NULL(chosen_certs);
 

data/aws-crt-ffi/crt/s2n/tests/unit/s2n_client_auth_handshake_test.c

@@ -47,8 +47,8 @@ int s2n_test_client_auth_negotiation(struct s2n_config *server_config, struct s2
     client_conn->server_protocol_version = S2N_TLS13;
     client_conn->client_protocol_version = S2N_TLS13;
     client_conn->actual_protocol_version = S2N_TLS13;
-    client_conn->handshake_params.conn_sig_scheme = s2n_ecdsa_secp256r1_sha256;
-    client_conn->handshake_params.client_cert_sig_scheme = s2n_ecdsa_secp256r1_sha256;
+    client_conn->handshake_params.server_cert_sig_scheme = &s2n_ecdsa_secp256r1_sha256;
+    client_conn->handshake_params.client_cert_sig_scheme = &s2n_ecdsa_secp256r1_sha256;
     client_conn->secure->cipher_suite = &s2n_tls13_aes_128_gcm_sha256;
     if (!no_cert) {
         client_conn->handshake_params.our_chain_and_key = ecdsa_cert;
@@ -58,7 +58,7 @@ int s2n_test_client_auth_negotiation(struct s2n_config *server_config, struct s2
     server_conn->server_protocol_version = S2N_TLS13;
     server_conn->client_protocol_version = S2N_TLS13;
     server_conn->actual_protocol_version = S2N_TLS13;
-    server_conn->handshake_params.conn_sig_scheme = s2n_ecdsa_secp256r1_sha256;
+    server_conn->handshake_params.server_cert_sig_scheme = &s2n_ecdsa_secp256r1_sha256;
     server_conn->secure->cipher_suite = &s2n_tls13_aes_128_gcm_sha256;
 
     if (no_cert) {

data/aws-crt-ffi/crt/s2n/tests/unit/s2n_client_cert_verify_test.c

@@ -169,7 +169,7 @@ int main(int argc, char **argv)
         EXPECT_NOT_NULL(conn);
 
         /* Set any signature scheme. Our test pkey methods ignore it. */
-        conn->handshake_params.client_cert_sig_scheme = s2n_rsa_pkcs1_md5_sha1;
+        conn->handshake_params.client_cert_sig_scheme = &s2n_rsa_pkcs1_md5_sha1;
 
         struct s2n_cert_chain_and_key *chain_and_key;
         EXPECT_SUCCESS(s2n_test_cert_chain_and_key_new(&chain_and_key,

data/aws-crt-ffi/crt/s2n/tests/unit/s2n_client_hello_recv_test.c

@@ -453,7 +453,7 @@ int main(int argc, char **argv)
         server_conn->psk_params.chosen_psk = &chosen_psk;
         EXPECT_SUCCESS(s2n_client_hello_recv(server_conn));
 
-        EXPECT_EQUAL(server_conn->handshake_params.conn_sig_scheme.iana_value, 0);
+        EXPECT_EQUAL(server_conn->handshake_params.server_cert_sig_scheme->iana_value, 0);
         EXPECT_NULL(server_conn->handshake_params.our_chain_and_key);
 
         EXPECT_SUCCESS(s2n_connection_free(client_conn));

data/aws-crt-ffi/crt/s2n/tests/unit/s2n_client_hello_test.c

@@ -1480,10 +1480,10 @@ int main(int argc, char **argv)
 
         EXPECT_EQUAL(server_conn->secure->cipher_suite, &s2n_ecdhe_ecdsa_with_aes_128_cbc_sha);
         EXPECT_EQUAL(client_conn->secure->cipher_suite, &s2n_ecdhe_ecdsa_with_aes_128_cbc_sha);
-        EXPECT_EQUAL(server_conn->handshake_params.conn_sig_scheme.sig_alg, S2N_SIGNATURE_ECDSA);
-        EXPECT_EQUAL(server_conn->handshake_params.conn_sig_scheme.hash_alg, S2N_HASH_SHA1);
-        EXPECT_EQUAL(client_conn->handshake_params.conn_sig_scheme.sig_alg, S2N_SIGNATURE_ECDSA);
-        EXPECT_EQUAL(client_conn->handshake_params.conn_sig_scheme.hash_alg, S2N_HASH_SHA1);
+        EXPECT_EQUAL(server_conn->handshake_params.server_cert_sig_scheme->sig_alg, S2N_SIGNATURE_ECDSA);
+        EXPECT_EQUAL(server_conn->handshake_params.server_cert_sig_scheme->hash_alg, S2N_HASH_SHA1);
+        EXPECT_EQUAL(client_conn->handshake_params.server_cert_sig_scheme->sig_alg, S2N_SIGNATURE_ECDSA);
+        EXPECT_EQUAL(client_conn->handshake_params.server_cert_sig_scheme->hash_alg, S2N_HASH_SHA1);
 
         /* Free the data */
         EXPECT_SUCCESS(s2n_connection_free(server_conn));

data/aws-crt-ffi/crt/s2n/tests/unit/s2n_client_signature_algorithms_extension_test.c

@@ -64,8 +64,7 @@ int main(int argc, char **argv)
         EXPECT_SUCCESS(s2n_client_signature_algorithms_extension.recv(server_conn, &io));
         EXPECT_EQUAL(s2n_stuffer_data_available(&io), 0);
 
-        EXPECT_EQUAL(server_conn->handshake_params.client_sig_hash_algs.len,
-                s2n_supported_sig_schemes_count(client_conn));
+        EXPECT_TRUE(server_conn->handshake_params.client_sig_hash_algs.len > 0);
 
         s2n_stuffer_free(&io);
         s2n_connection_free(client_conn);
@@ -93,7 +92,7 @@ int main(int argc, char **argv)
         EXPECT_SUCCESS(s2n_client_signature_algorithms_extension.recv(conn, &signature_algorithms_extension));
         EXPECT_EQUAL(conn->handshake_params.client_sig_hash_algs.len, sig_hash_algs.len);
         EXPECT_FAILURE(s2n_choose_sig_scheme_from_peer_preference_list(conn, &conn->handshake_params.client_sig_hash_algs,
-                &conn->handshake_params.conn_sig_scheme));
+                &conn->handshake_params.server_cert_sig_scheme));
 
         EXPECT_SUCCESS(s2n_stuffer_free(&signature_algorithms_extension));
         EXPECT_SUCCESS(s2n_connection_free(conn));
@@ -121,8 +120,8 @@ int main(int argc, char **argv)
         EXPECT_SUCCESS(s2n_client_signature_algorithms_extension.recv(conn, &signature_algorithms_extension));
         EXPECT_EQUAL(conn->handshake_params.client_sig_hash_algs.len, sig_hash_algs.len);
         EXPECT_SUCCESS(s2n_choose_sig_scheme_from_peer_preference_list(conn, &conn->handshake_params.client_sig_hash_algs,
-                &conn->handshake_params.conn_sig_scheme));
-        EXPECT_EQUAL(conn->handshake_params.conn_sig_scheme.iana_value, TLS_SIGNATURE_SCHEME_RSA_PKCS1_SHA384);
+                &conn->handshake_params.server_cert_sig_scheme));
+        EXPECT_EQUAL(conn->handshake_params.server_cert_sig_scheme->iana_value, TLS_SIGNATURE_SCHEME_RSA_PKCS1_SHA384);
 
         EXPECT_SUCCESS(s2n_stuffer_free(&signature_algorithms_extension));
         EXPECT_SUCCESS(s2n_connection_free(conn));

data/aws-crt-ffi/crt/s2n/tests/unit/s2n_connection_protocol_versions_test.c

@@ -0,0 +1,390 @@
+/*
+* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+*
+* Licensed under the Apache License, Version 2.0 (the "License").
+* You may not use this file except in compliance with the License.
+* A copy of the License is located at
+*
+*  http://aws.amazon.com/apache2.0
+*
+* or in the "license" file accompanying this file. This file is distributed
+* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+* express or implied. See the License for the specific language governing
+* permissions and limitations under the License.
+*/
+
+#include "api/s2n.h"
+#include "s2n_test.h"
+#include "testlib/s2n_testlib.h"
+#include "tls/s2n_tls.h"
+
+static S2N_RESULT s2n_write_test_supported_versions_extension(struct s2n_blob *supported_versions_blob, uint8_t version,
+        uint8_t extension_length)
+{
+    RESULT_ENSURE_REF(supported_versions_blob);
+
+    struct s2n_stuffer supported_versions_stuffer = { 0 };
+    RESULT_GUARD_POSIX(s2n_stuffer_init(&supported_versions_stuffer, supported_versions_blob));
+
+    /* Write the length byte. */
+    RESULT_GUARD_POSIX(s2n_stuffer_write_uint8(&supported_versions_stuffer, extension_length));
+    /* Write the supported version. */
+    RESULT_GUARD_POSIX(s2n_stuffer_write_uint8(&supported_versions_stuffer, version / 10));
+    RESULT_GUARD_POSIX(s2n_stuffer_write_uint8(&supported_versions_stuffer, version % 10));
+
+    return S2N_RESULT_OK;
+}
+
+struct s2n_overwrite_client_hello_ctx {
+    uint8_t client_hello_version;
+    uint8_t client_supported_version;
+    uint8_t extension_length;
+
+    uint8_t supported_versions_data[3];
+    int invoked_count;
+};
+
+static int s2n_overwrite_client_hello_cb(struct s2n_connection *conn, void *ctx)
+{
+    EXPECT_NOT_NULL(conn);
+    EXPECT_NOT_NULL(ctx);
+
+    struct s2n_overwrite_client_hello_ctx *context = (struct s2n_overwrite_client_hello_ctx *) ctx;
+    context->invoked_count += 1;
+
+    if (context->extension_length) {
+        struct s2n_blob supported_versions_blob = { 0 };
+        EXPECT_SUCCESS(s2n_blob_init(&supported_versions_blob, context->supported_versions_data,
+                sizeof(context->supported_versions_data)));
+
+        struct s2n_client_hello *client_hello = s2n_connection_get_client_hello(conn);
+        EXPECT_NOT_NULL(client_hello);
+
+        s2n_extension_type_id supported_versions_id = 0;
+        EXPECT_SUCCESS(s2n_extension_supported_iana_value_to_id(S2N_EXTENSION_SUPPORTED_VERSIONS, &supported_versions_id));
+        s2n_parsed_extension *extension = &client_hello->extensions.parsed_extensions[supported_versions_id];
+
+        EXPECT_OK(s2n_write_test_supported_versions_extension(&supported_versions_blob,
+                context->client_supported_version, context->extension_length));
+
+        extension->extension_type = S2N_EXTENSION_SUPPORTED_VERSIONS;
+        extension->extension = supported_versions_blob;
+    }
+
+    /* The client version fields are set when parsing the client hello before the client hello
+     * callback is invoked. The version fields are overridden to emulate receiving a client hello
+     * with a different version.
+     */
+    if (context->client_hello_version) {
+        conn->client_hello_version = context->client_hello_version;
+        conn->client_protocol_version = context->client_hello_version;
+    }
+
+    return S2N_SUCCESS;
+}
+
+int main(int argc, char **argv)
+{
+    BEGIN_TEST();
+
+    DEFER_CLEANUP(struct s2n_cert_chain_and_key *chain_and_key = NULL, s2n_cert_chain_and_key_ptr_free);
+    EXPECT_SUCCESS(s2n_test_cert_chain_and_key_new(&chain_and_key,
+            S2N_DEFAULT_TEST_CERT_CHAIN, S2N_DEFAULT_TEST_PRIVATE_KEY));
+
+    /* Safety */
+    {
+        EXPECT_FAILURE_WITH_ERRNO(s2n_connection_get_client_protocol_version(NULL), S2N_ERR_NULL);
+        EXPECT_FAILURE_WITH_ERRNO(s2n_connection_get_client_hello_version(NULL), S2N_ERR_NULL);
+        EXPECT_FAILURE_WITH_ERRNO(s2n_connection_get_server_protocol_version(NULL), S2N_ERR_NULL);
+        EXPECT_FAILURE_WITH_ERRNO(s2n_connection_get_actual_protocol_version(NULL), S2N_ERR_NULL);
+    }
+
+    /* Test protocol version getters on the server when a supported versions extension is received */
+    for (uint8_t server_version = S2N_TLS12; server_version <= S2N_TLS13; server_version++) {
+        for (uint8_t client_hello_version = S2N_SSLv3; client_hello_version <= S2N_TLS12; client_hello_version++) {
+            for (uint8_t client_supported_version = S2N_SSLv3; client_supported_version <= S2N_TLS13; client_supported_version++) {
+                DEFER_CLEANUP(struct s2n_config *config = s2n_config_new(), s2n_config_ptr_free);
+                EXPECT_SUCCESS(s2n_config_add_cert_chain_and_key_to_store(config, chain_and_key));
+
+                if (server_version == S2N_TLS12) {
+                    EXPECT_SUCCESS(s2n_config_set_cipher_preferences(config, "test_all_tls12"));
+                } else if (s2n_is_tls13_fully_supported()) {
+                    EXPECT_SUCCESS(s2n_config_set_cipher_preferences(config, "test_all"));
+                } else {
+                    continue;
+                }
+
+                struct s2n_overwrite_client_hello_ctx context = {
+                    .client_hello_version = client_hello_version,
+                    .client_supported_version = client_supported_version,
+                    .extension_length = 2,
+                };
+                EXPECT_SUCCESS(s2n_config_set_client_hello_cb(config, s2n_overwrite_client_hello_cb, &context));
+
+                DEFER_CLEANUP(struct s2n_connection *client = s2n_connection_new(S2N_CLIENT),
+                        s2n_connection_ptr_free);
+                EXPECT_NOT_NULL(client);
+                EXPECT_SUCCESS(s2n_connection_set_config(client, config));
+
+                DEFER_CLEANUP(struct s2n_connection *server = s2n_connection_new(S2N_SERVER),
+                        s2n_connection_ptr_free);
+                EXPECT_NOT_NULL(server);
+                EXPECT_SUCCESS(s2n_connection_set_config(server, config));
+
+                DEFER_CLEANUP(struct s2n_test_io_pair io_pair = { 0 }, s2n_io_pair_close);
+                EXPECT_SUCCESS(s2n_io_pair_init_non_blocking(&io_pair));
+                EXPECT_SUCCESS(s2n_connections_set_io_pair(client, server, &io_pair));
+
+                EXPECT_OK(s2n_negotiate_test_server_and_client_until_message(server, client, SERVER_HELLO));
+                EXPECT_EQUAL(context.invoked_count, 1);
+
+                /* Ensure that a supported versions extension was received. */
+                bool supported_versions_received = false;
+                EXPECT_SUCCESS(s2n_client_hello_has_extension(&server->client_hello, S2N_EXTENSION_SUPPORTED_VERSIONS,
+                        &supported_versions_received));
+                EXPECT_TRUE(supported_versions_received);
+
+                EXPECT_EQUAL(s2n_connection_get_server_protocol_version(server), server_version);
+                EXPECT_EQUAL(s2n_connection_get_client_hello_version(server), client_hello_version);
+
+                /* The reported client protocol version should always match the version specified
+                 * in the supported versions extension, even for TLS 1.2 servers which don't
+                 * process the extension for version selection.
+                 */
+                EXPECT_EQUAL(s2n_connection_get_client_protocol_version(server), client_supported_version);
+
+                uint8_t actual_protocol_version = s2n_connection_get_actual_protocol_version(server);
+                if (server_version == S2N_TLS12) {
+                    /* For backwards compatibility, TLS 1.2 servers always use the client hello
+                     * version to determine the client's maximum version, even if a supported
+                     * versions extension was received.
+                     */
+                    EXPECT_EQUAL(actual_protocol_version, MIN(server_version, client_hello_version));
+                } else {
+                    /* TLS 1.3 servers always use the version in the supported versions extension,
+                     * regardless of the client hello version.
+                     */
+                    EXPECT_EQUAL(actual_protocol_version, MIN(server_version, client_supported_version));
+                }
+            }
+        }
+    }
+
+    /* Test protocol version getters on the server when a supported versions extension isn't received */
+    for (uint8_t server_version = S2N_TLS12; server_version <= S2N_TLS13; server_version++) {
+        for (uint8_t client_hello_version = S2N_SSLv3; client_hello_version <= S2N_TLS12; client_hello_version++) {
+            DEFER_CLEANUP(struct s2n_config *client_config = s2n_config_new(), s2n_config_ptr_free);
+
+            /* A TLS 1.2 security policy is set to prevent the client from sending a supported
+             * versions extension.
+             */
+            EXPECT_SUCCESS(s2n_config_set_cipher_preferences(client_config, "test_all_tls12"));
+
+            DEFER_CLEANUP(struct s2n_config *server_config = s2n_config_new(), s2n_config_ptr_free);
+            EXPECT_SUCCESS(s2n_config_add_cert_chain_and_key_to_store(server_config, chain_and_key));
+
+            if (server_version == S2N_TLS12) {
+                EXPECT_SUCCESS(s2n_config_set_cipher_preferences(server_config, "test_all_tls12"));
+            } else if (s2n_is_tls13_fully_supported()) {
+                EXPECT_SUCCESS(s2n_config_set_cipher_preferences(server_config, "test_all"));
+            } else {
+                continue;
+            }
+
+            struct s2n_overwrite_client_hello_ctx context = {
+                .client_hello_version = client_hello_version,
+            };
+            EXPECT_SUCCESS(s2n_config_set_client_hello_cb(server_config, s2n_overwrite_client_hello_cb, &context));
+
+            DEFER_CLEANUP(struct s2n_connection *client = s2n_connection_new(S2N_CLIENT),
+                    s2n_connection_ptr_free);
+            EXPECT_NOT_NULL(client);
+            EXPECT_SUCCESS(s2n_connection_set_config(client, client_config));
+
+            DEFER_CLEANUP(struct s2n_connection *server = s2n_connection_new(S2N_SERVER),
+                    s2n_connection_ptr_free);
+            EXPECT_NOT_NULL(server);
+            EXPECT_SUCCESS(s2n_connection_set_config(server, server_config));
+
+            DEFER_CLEANUP(struct s2n_test_io_pair io_pair = { 0 }, s2n_io_pair_close);
+            EXPECT_SUCCESS(s2n_io_pair_init_non_blocking(&io_pair));
+            EXPECT_SUCCESS(s2n_connections_set_io_pair(client, server, &io_pair));
+
+            EXPECT_OK(s2n_negotiate_test_server_and_client_until_message(server, client, SERVER_HELLO));
+            EXPECT_EQUAL(context.invoked_count, 1);
+
+            /* Ensure that a supported versions extension wasn't received. */
+            bool supported_versions_received = false;
+            EXPECT_SUCCESS(s2n_client_hello_has_extension(&server->client_hello, S2N_EXTENSION_SUPPORTED_VERSIONS,
+                    &supported_versions_received));
+            EXPECT_FALSE(supported_versions_received);
+
+            EXPECT_EQUAL(s2n_connection_get_server_protocol_version(server), server_version);
+            EXPECT_EQUAL(s2n_connection_get_client_protocol_version(server), client_hello_version);
+            EXPECT_EQUAL(s2n_connection_get_client_hello_version(server), client_hello_version);
+            EXPECT_EQUAL(s2n_connection_get_actual_protocol_version(server), client_hello_version);
+        }
+    }
+
+    /* Test protocol version getters on the client */
+    for (uint8_t server_version = S2N_SSLv3; server_version <= S2N_TLS13; server_version++) {
+        if (server_version == S2N_TLS13 && !s2n_is_tls13_fully_supported()) {
+            continue;
+        }
+
+        DEFER_CLEANUP(struct s2n_config *config = s2n_config_new(), s2n_config_ptr_free);
+        EXPECT_SUCCESS(s2n_config_add_cert_chain_and_key_to_store(config, chain_and_key));
+        EXPECT_SUCCESS(s2n_config_set_cipher_preferences(config, "test_all"));
+
+        DEFER_CLEANUP(struct s2n_connection *client = s2n_connection_new(S2N_CLIENT), s2n_connection_ptr_free);
+        EXPECT_NOT_NULL(client);
+        EXPECT_SUCCESS(s2n_connection_set_config(client, config));
+
+        DEFER_CLEANUP(struct s2n_connection *server = s2n_connection_new(S2N_SERVER), s2n_connection_ptr_free);
+        EXPECT_NOT_NULL(server);
+        EXPECT_SUCCESS(s2n_connection_set_config(server, config));
+        server->server_protocol_version = server_version;
+
+        DEFER_CLEANUP(struct s2n_test_io_pair io_pair = { 0 }, s2n_io_pair_close);
+        EXPECT_SUCCESS(s2n_io_pair_init_non_blocking(&io_pair));
+        EXPECT_SUCCESS(s2n_connections_set_io_pair(client, server, &io_pair));
+
+        EXPECT_OK(s2n_negotiate_test_server_and_client_until_message(server, client, SERVER_CERT));
+
+        EXPECT_EQUAL(s2n_connection_get_server_protocol_version(client), server_version);
+        EXPECT_EQUAL(s2n_connection_get_client_protocol_version(client), s2n_get_highest_fully_supported_tls_version());
+        EXPECT_EQUAL(s2n_connection_get_client_hello_version(client), S2N_TLS12);
+        EXPECT_EQUAL(s2n_connection_get_actual_protocol_version(client), server_version);
+    }
+
+    /* Ensure that TLS 1.2 servers report the client hello version as the client protocol version
+     * if a malformed supported versions extension was received
+     */
+    for (uint8_t client_hello_version = S2N_SSLv3; client_hello_version <= S2N_TLS12; client_hello_version++) {
+        DEFER_CLEANUP(struct s2n_config *config = s2n_config_new(), s2n_config_ptr_free);
+        EXPECT_SUCCESS(s2n_config_add_cert_chain_and_key_to_store(config, chain_and_key));
+        EXPECT_SUCCESS(s2n_config_set_cipher_preferences(config, "test_all_tls12"));
+
+        struct s2n_overwrite_client_hello_ctx context = {
+            .client_hello_version = client_hello_version,
+            .client_supported_version = S2N_TLS13,
+            /* Write an invalid length */
+            .extension_length = 11,
+        };
+        EXPECT_SUCCESS(s2n_config_set_client_hello_cb(config, s2n_overwrite_client_hello_cb, &context));
+
+        DEFER_CLEANUP(struct s2n_connection *client = s2n_connection_new(S2N_CLIENT),
+                s2n_connection_ptr_free);
+        EXPECT_NOT_NULL(client);
+        EXPECT_SUCCESS(s2n_connection_set_config(client, config));
+
+        DEFER_CLEANUP(struct s2n_connection *server = s2n_connection_new(S2N_SERVER),
+                s2n_connection_ptr_free);
+        EXPECT_NOT_NULL(server);
+        EXPECT_SUCCESS(s2n_connection_set_config(server, config));
+
+        DEFER_CLEANUP(struct s2n_test_io_pair io_pair = { 0 }, s2n_io_pair_close);
+        EXPECT_SUCCESS(s2n_io_pair_init_non_blocking(&io_pair));
+        EXPECT_SUCCESS(s2n_connections_set_io_pair(client, server, &io_pair));
+
+        EXPECT_OK(s2n_negotiate_test_server_and_client_until_message(server, client, SERVER_HELLO));
+        EXPECT_EQUAL(context.invoked_count, 1);
+
+        /* Ensure that a supported versions extension was received. */
+        bool supported_versions_received = false;
+        EXPECT_SUCCESS(s2n_client_hello_has_extension(&server->client_hello, S2N_EXTENSION_SUPPORTED_VERSIONS,
+                &supported_versions_received));
+        EXPECT_TRUE(supported_versions_received);
+
+        EXPECT_EQUAL(s2n_connection_get_client_protocol_version(server), client_hello_version);
+    }
+
+    /* Ensure that TLS 1.2 servers report the client hello version as the client protocol version
+     * if an invalid supported version is received
+     */
+    for (uint8_t client_hello_version = S2N_SSLv3; client_hello_version <= S2N_TLS12; client_hello_version++) {
+        DEFER_CLEANUP(struct s2n_config *config = s2n_config_new(), s2n_config_ptr_free);
+        EXPECT_SUCCESS(s2n_config_add_cert_chain_and_key_to_store(config, chain_and_key));
+        EXPECT_SUCCESS(s2n_config_set_cipher_preferences(config, "test_all_tls12"));
+
+        struct s2n_overwrite_client_hello_ctx context = {
+            .client_hello_version = client_hello_version,
+            /* Write an invalid version */
+            .client_supported_version = S2N_TLS13 + 10,
+            .extension_length = 2,
+        };
+        EXPECT_SUCCESS(s2n_config_set_client_hello_cb(config, s2n_overwrite_client_hello_cb, &context));
+
+        DEFER_CLEANUP(struct s2n_connection *client = s2n_connection_new(S2N_CLIENT),
+                s2n_connection_ptr_free);
+        EXPECT_NOT_NULL(client);
+        EXPECT_SUCCESS(s2n_connection_set_config(client, config));
+
+        DEFER_CLEANUP(struct s2n_connection *server = s2n_connection_new(S2N_SERVER),
+                s2n_connection_ptr_free);
+        EXPECT_NOT_NULL(server);
+        EXPECT_SUCCESS(s2n_connection_set_config(server, config));
+
+        DEFER_CLEANUP(struct s2n_test_io_pair io_pair = { 0 }, s2n_io_pair_close);
+        EXPECT_SUCCESS(s2n_io_pair_init_non_blocking(&io_pair));
+        EXPECT_SUCCESS(s2n_connections_set_io_pair(client, server, &io_pair));
+
+        EXPECT_OK(s2n_negotiate_test_server_and_client_until_message(server, client, SERVER_HELLO));
+        EXPECT_EQUAL(context.invoked_count, 1);
+
+        /* Ensure that a supported versions extension was received. */
+        bool supported_versions_received = false;
+        EXPECT_SUCCESS(s2n_client_hello_has_extension(&server->client_hello, S2N_EXTENSION_SUPPORTED_VERSIONS,
+                &supported_versions_received));
+        EXPECT_TRUE(supported_versions_received);
+
+        EXPECT_EQUAL(s2n_connection_get_client_protocol_version(server), client_hello_version);
+    }
+
+    /* Ensure that TLS 1.3 servers report an unknown protocol version if a supported versions
+     * extension can't be processed
+     */
+    if (s2n_is_tls13_fully_supported()) {
+        DEFER_CLEANUP(struct s2n_config *config = s2n_config_new(), s2n_config_ptr_free);
+        EXPECT_SUCCESS(s2n_config_add_cert_chain_and_key_to_store(config, chain_and_key));
+        EXPECT_SUCCESS(s2n_config_set_cipher_preferences(config, "test_all"));
+
+        struct s2n_overwrite_client_hello_ctx context = {
+            .client_supported_version = S2N_TLS13,
+            /* Write an invalid length */
+            .extension_length = 11,
+        };
+        EXPECT_SUCCESS(s2n_config_set_client_hello_cb(config, s2n_overwrite_client_hello_cb, &context));
+
+        DEFER_CLEANUP(struct s2n_connection *client = s2n_connection_new(S2N_CLIENT),
+                s2n_connection_ptr_free);
+        EXPECT_NOT_NULL(client);
+        EXPECT_SUCCESS(s2n_connection_set_config(client, config));
+
+        DEFER_CLEANUP(struct s2n_connection *server = s2n_connection_new(S2N_SERVER),
+                s2n_connection_ptr_free);
+        EXPECT_NOT_NULL(server);
+        EXPECT_SUCCESS(s2n_connection_set_config(server, config));
+        EXPECT_SUCCESS(s2n_connection_set_blinding(server, S2N_SELF_SERVICE_BLINDING));
+
+        DEFER_CLEANUP(struct s2n_test_io_pair io_pair = { 0 }, s2n_io_pair_close);
+        EXPECT_SUCCESS(s2n_io_pair_init_non_blocking(&io_pair));
+        EXPECT_SUCCESS(s2n_connections_set_io_pair(client, server, &io_pair));
+
+        EXPECT_ERROR_WITH_ERRNO(s2n_negotiate_test_server_and_client_until_message(server, client, SERVER_HELLO),
+                S2N_ERR_BAD_MESSAGE);
+        EXPECT_EQUAL(context.invoked_count, 1);
+
+        /* Ensure that a supported versions extension was received. */
+        bool supported_versions_received = false;
+        EXPECT_SUCCESS(s2n_client_hello_has_extension(&server->client_hello, S2N_EXTENSION_SUPPORTED_VERSIONS,
+                &supported_versions_received));
+        EXPECT_TRUE(supported_versions_received);
+
+        EXPECT_EQUAL(s2n_connection_get_server_protocol_version(server), S2N_TLS13);
+        EXPECT_EQUAL(s2n_connection_get_client_protocol_version(server), s2n_unknown_protocol_version);
+        EXPECT_EQUAL(s2n_connection_get_actual_protocol_version(server), s2n_unknown_protocol_version);
+    }
+
+    END_TEST();
+}