lib/mbedtls
1
0
Fork 0
mirror of https://github.com/Mbed-TLS/mbedtls.git synced 2025-07-04 08:02:28 +03:00
Code Activity

Use TEST_EQUAL(a,b) instead of TEST_ASSERT(a==b)

Browse Source 
Regexp replacement then `code_style.py --fix`.

Signed-off-by: Gilles Peskine <Gilles.Peskine@arm.com>
This commit is contained in:
Gilles Peskine
2025-05-14 17:42:53 +02:00
parent 2439c4c14a
commit 353eb33d0c
2 changed files with 795 additions and 802 deletions
Download Patch File Download Diff File Expand all files Collapse all files

304
tests/src/test_helpers/ssl_helpers.c
View File

@ -637,7 +637,7 @@ int mbedtls_test_ssl_endpoint_certificate_init(mbedtls_test_ssl_endpoint *ep,
cert->ca_cert,
(const unsigned char *) mbedtls_test_cas_der[i],
mbedtls_test_cas_der_len[i]);
TEST_ASSERT(ret == 0);
TEST_EQUAL(ret, 0);
}
/* Load own certificate and private key */
@ -648,25 +648,25 @@ int mbedtls_test_ssl_endpoint_certificate_init(mbedtls_test_ssl_endpoint *ep,
cert->cert,
(const unsigned char *) mbedtls_test_srv_crt_rsa_sha256_der,
mbedtls_test_srv_crt_rsa_sha256_der_len);
TEST_ASSERT(ret == 0);
TEST_EQUAL(ret, 0);
ret = mbedtls_pk_parse_key(
cert->pkey,
(const unsigned char *) mbedtls_test_srv_key_rsa_der,
mbedtls_test_srv_key_rsa_der_len, NULL, 0);
TEST_ASSERT(ret == 0);
TEST_EQUAL(ret, 0);
} else {
ret = mbedtls_x509_crt_parse(
cert->cert,
(const unsigned char *) mbedtls_test_srv_crt_ec_der,
mbedtls_test_srv_crt_ec_der_len);
TEST_ASSERT(ret == 0);
TEST_EQUAL(ret, 0);
ret = mbedtls_pk_parse_key(
cert->pkey,
(const unsigned char *) mbedtls_test_srv_key_ec_der,
mbedtls_test_srv_key_ec_der_len, NULL, 0);
TEST_ASSERT(ret == 0);
TEST_EQUAL(ret, 0);
}
} else {
if (pk_alg == MBEDTLS_PK_RSA) {
@ -674,25 +674,25 @@ int mbedtls_test_ssl_endpoint_certificate_init(mbedtls_test_ssl_endpoint *ep,
cert->cert,
(const unsigned char *) mbedtls_test_cli_crt_rsa_der,
mbedtls_test_cli_crt_rsa_der_len);
TEST_ASSERT(ret == 0);
TEST_EQUAL(ret, 0);
ret = mbedtls_pk_parse_key(
cert->pkey,
(const unsigned char *) mbedtls_test_cli_key_rsa_der,
mbedtls_test_cli_key_rsa_der_len, NULL, 0);
TEST_ASSERT(ret == 0);
TEST_EQUAL(ret, 0);
} else {
ret = mbedtls_x509_crt_parse(
cert->cert,
(const unsigned char *) mbedtls_test_cli_crt_ec_der,
mbedtls_test_cli_crt_ec_len);
TEST_ASSERT(ret == 0);
TEST_EQUAL(ret, 0);
ret = mbedtls_pk_parse_key(
cert->pkey,
(const unsigned char *) mbedtls_test_cli_key_ec_der,
mbedtls_test_cli_key_ec_der_len, NULL, 0);
TEST_ASSERT(ret == 0);
TEST_EQUAL(ret, 0);
}
}
@ -723,16 +723,16 @@ int mbedtls_test_ssl_endpoint_certificate_init(mbedtls_test_ssl_endpoint *ep,
ret = mbedtls_ssl_conf_own_cert(&(ep->conf), cert->cert,
cert->pkey);
TEST_ASSERT(ret == 0);
TEST_EQUAL(ret, 0);
TEST_ASSERT(ep->conf.key_cert != NULL);
ret = mbedtls_ssl_conf_own_cert(&(ep->conf), NULL, NULL);
TEST_ASSERT(ret == 0);
TEST_EQUAL(ret, 0);
TEST_ASSERT(ep->conf.key_cert == NULL);
ret = mbedtls_ssl_conf_own_cert(&(ep->conf), cert->cert,
cert->pkey);
TEST_ASSERT(ret == 0);
TEST_EQUAL(ret, 0);
ok = 1;
@ -787,9 +787,9 @@ int mbedtls_test_ssl_endpoint_init(
mbedtls_ssl_set_user_data_n(&ep->ssl, user_data_n);
if (dtls_context != NULL) {
TEST_ASSERT(mbedtls_test_message_socket_setup(input_queue, output_queue,
100, &(ep->socket),
dtls_context) == 0);
TEST_EQUAL(mbedtls_test_message_socket_setup(input_queue, output_queue,
100, &(ep->socket),
dtls_context), 0);
} else {
mbedtls_test_mock_socket_init(&(ep->socket));
}
@ -812,7 +812,7 @@ int mbedtls_test_ssl_endpoint_init(
MBEDTLS_SSL_TRANSPORT_DATAGRAM :
MBEDTLS_SSL_TRANSPORT_STREAM,
MBEDTLS_SSL_PRESET_DEFAULT);
TEST_ASSERT(ret == 0);
TEST_EQUAL(ret, 0);
if (MBEDTLS_SSL_IS_CLIENT == endpoint_type) {
if (options->client_min_version != MBEDTLS_SSL_VERSION_UNKNOWN) {
@ -868,7 +868,7 @@ int mbedtls_test_ssl_endpoint_init(
#endif
ret = mbedtls_ssl_setup(&(ep->ssl), &(ep->conf));
TEST_ASSERT(ret == 0);
TEST_EQUAL(ret, 0);
if (MBEDTLS_SSL_IS_CLIENT == endpoint_type) {
ret = mbedtls_ssl_set_hostname(&(ep->ssl), "localhost");
@ -902,7 +902,7 @@ int mbedtls_test_ssl_endpoint_init(
options->opaque_alg,
options->opaque_alg2,
options->opaque_usage);
TEST_ASSERT(ret == 0);
TEST_EQUAL(ret, 0);
TEST_EQUAL(mbedtls_ssl_conf_get_user_data_n(&ep->conf), user_data_n);
mbedtls_ssl_conf_set_user_data_p(&ep->conf, ep);
@ -985,7 +985,7 @@ static int mbedtls_ssl_write_fragment(mbedtls_ssl_context *ssl,
/* Verify that calling mbedtls_ssl_write with a NULL buffer and zero length is
* a valid no-op for TLS connections. */
if (ssl->conf->transport != MBEDTLS_SSL_TRANSPORT_DATAGRAM) {
TEST_ASSERT(mbedtls_ssl_write(ssl, NULL, 0) == 0);
TEST_EQUAL(mbedtls_ssl_write(ssl, NULL, 0), 0);
}
ret = mbedtls_ssl_write(ssl, buf + *written, buf_len - *written);
@ -1032,7 +1032,7 @@ static int mbedtls_ssl_read_fragment(mbedtls_ssl_context *ssl,
/* Verify that calling mbedtls_ssl_write with a NULL buffer and zero length is
* a valid no-op for TLS connections. */
if (ssl->conf->transport != MBEDTLS_SSL_TRANSPORT_DATAGRAM) {
TEST_ASSERT(mbedtls_ssl_read(ssl, NULL, 0) == 0);
TEST_EQUAL(mbedtls_ssl_read(ssl, NULL, 0), 0);
}
ret = mbedtls_ssl_read(ssl, buf + *read, buf_len - *read);
@ -1042,7 +1042,7 @@ static int mbedtls_ssl_read_fragment(mbedtls_ssl_context *ssl,
}
if (expected_fragments == 0) {
TEST_ASSERT(ret == 0);
TEST_EQUAL(ret, 0);
} else if (expected_fragments == 1) {
TEST_ASSERT(ret == buf_len ||
ret == MBEDTLS_ERR_SSL_WANT_READ ||
@ -1929,10 +1929,10 @@ int mbedtls_test_ssl_exchange_data(
if (expected_fragments_1 == 0) {
/* This error is expected when the message is too large and
* cannot be fragmented */
TEST_ASSERT(ret == MBEDTLS_ERR_SSL_BAD_INPUT_DATA);
TEST_EQUAL(ret, MBEDTLS_ERR_SSL_BAD_INPUT_DATA);
msg_len_1 = 0;
} else {
TEST_ASSERT(ret == 0);
TEST_EQUAL(ret, 0);
}
}
@ -1944,10 +1944,10 @@ int mbedtls_test_ssl_exchange_data(
if (expected_fragments_2 == 0) {
/* This error is expected when the message is too large and
* cannot be fragmented */
TEST_ASSERT(ret == MBEDTLS_ERR_SSL_BAD_INPUT_DATA);
TEST_EQUAL(ret, MBEDTLS_ERR_SSL_BAD_INPUT_DATA);
msg_len_2 = 0;
} else {
TEST_ASSERT(ret == 0);
TEST_EQUAL(ret, 0);
}
}
@ -1957,7 +1957,7 @@ int mbedtls_test_ssl_exchange_data(
msg_len_2, &read_1,
&fragments_2,
expected_fragments_2);
TEST_ASSERT(ret == 0);
TEST_EQUAL(ret, 0);
}
/* ssl_2 reading */
@ -1966,15 +1966,15 @@ int mbedtls_test_ssl_exchange_data(
msg_len_1, &read_2,
&fragments_1,
expected_fragments_1);
TEST_ASSERT(ret == 0);
TEST_EQUAL(ret, 0);
}
}
ret = -1;
TEST_ASSERT(0 == memcmp(msg_buf_1, in_buf_2, msg_len_1));
TEST_ASSERT(0 == memcmp(msg_buf_2, in_buf_1, msg_len_2));
TEST_ASSERT(fragments_1 == expected_fragments_1);
TEST_ASSERT(fragments_2 == expected_fragments_2);
TEST_EQUAL(0, memcmp(msg_buf_1, in_buf_2, msg_len_1));
TEST_EQUAL(0, memcmp(msg_buf_2, in_buf_1, msg_len_2));
TEST_EQUAL(fragments_1, expected_fragments_1);
TEST_EQUAL(fragments_2, expected_fragments_2);
}
ret = 0;
@ -2026,12 +2026,12 @@ static int check_ssl_version(
switch (expected_negotiated_version) {
case MBEDTLS_SSL_VERSION_TLS1_2:
TEST_EQUAL(version_number, MBEDTLS_SSL_VERSION_TLS1_2);
TEST_ASSERT(strcmp(version_string, "TLSv1.2") == 0);
TEST_EQUAL(strcmp(version_string, "TLSv1.2"), 0);
break;
case MBEDTLS_SSL_VERSION_TLS1_3:
TEST_EQUAL(version_number, MBEDTLS_SSL_VERSION_TLS1_3);
TEST_ASSERT(strcmp(version_string, "TLSv1.3") == 0);
TEST_EQUAL(strcmp(version_string, "TLSv1.3"), 0);
break;
default:
@ -2142,21 +2142,21 @@ void mbedtls_test_ssl_perform_handshake(
/* Client side */
if (options->dtls != 0) {
TEST_ASSERT(mbedtls_test_ssl_endpoint_init(&client,
MBEDTLS_SSL_IS_CLIENT,
options, &client_context,
&client_queue,
&server_queue) == 0);
TEST_EQUAL(mbedtls_test_ssl_endpoint_init(&client,
MBEDTLS_SSL_IS_CLIENT,
options, &client_context,
&client_queue,
&server_queue), 0);
#if defined(MBEDTLS_TIMING_C)
mbedtls_ssl_set_timer_cb(&client.ssl, &timer_client,
mbedtls_timing_set_delay,
mbedtls_timing_get_delay);
#endif
} else {
TEST_ASSERT(mbedtls_test_ssl_endpoint_init(&client,
MBEDTLS_SSL_IS_CLIENT,
options, NULL, NULL,
NULL) == 0);
TEST_EQUAL(mbedtls_test_ssl_endpoint_init(&client,
MBEDTLS_SSL_IS_CLIENT,
options, NULL, NULL,
NULL), 0);
}
if (strlen(options->cipher) > 0) {
@ -2165,49 +2165,49 @@ void mbedtls_test_ssl_perform_handshake(
/* Server side */
if (options->dtls != 0) {
TEST_ASSERT(mbedtls_test_ssl_endpoint_init(&server,
MBEDTLS_SSL_IS_SERVER,
options, &server_context,
&server_queue,
&client_queue) == 0);
TEST_EQUAL(mbedtls_test_ssl_endpoint_init(&server,
MBEDTLS_SSL_IS_SERVER,
options, &server_context,
&server_queue,
&client_queue), 0);
#if defined(MBEDTLS_TIMING_C)
mbedtls_ssl_set_timer_cb(&server.ssl, &timer_server,
mbedtls_timing_set_delay,
mbedtls_timing_get_delay);
#endif
} else {
TEST_ASSERT(mbedtls_test_ssl_endpoint_init(&server,
MBEDTLS_SSL_IS_SERVER,
options, NULL, NULL,
NULL) == 0);
TEST_EQUAL(mbedtls_test_ssl_endpoint_init(&server,
MBEDTLS_SSL_IS_SERVER,
options, NULL, NULL,
NULL), 0);
}
mbedtls_ssl_conf_authmode(&server.conf, options->srv_auth_mode);
#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
TEST_ASSERT(mbedtls_ssl_conf_max_frag_len(&(server.conf),
(unsigned char) options->mfl)
== 0);
TEST_ASSERT(mbedtls_ssl_conf_max_frag_len(&(client.conf),
(unsigned char) options->mfl)
== 0);
TEST_EQUAL(mbedtls_ssl_conf_max_frag_len(&(server.conf),
(unsigned char) options->mfl),
0);
TEST_EQUAL(mbedtls_ssl_conf_max_frag_len(&(client.conf),
(unsigned char) options->mfl),
0);
#else
TEST_ASSERT(MBEDTLS_SSL_MAX_FRAG_LEN_NONE == options->mfl);
TEST_EQUAL(MBEDTLS_SSL_MAX_FRAG_LEN_NONE, options->mfl);
#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
#if defined(MBEDTLS_SSL_HANDSHAKE_WITH_PSK_ENABLED)
if (options->psk_str != NULL && options->psk_str->len > 0) {
TEST_ASSERT(mbedtls_ssl_conf_psk(
&client.conf, options->psk_str->x,
options->psk_str->len,
(const unsigned char *) psk_identity,
strlen(psk_identity)) == 0);
TEST_EQUAL(mbedtls_ssl_conf_psk(
&client.conf, options->psk_str->x,
options->psk_str->len,
(const unsigned char *) psk_identity,
strlen(psk_identity)), 0);
TEST_ASSERT(mbedtls_ssl_conf_psk(
&server.conf, options->psk_str->x,
options->psk_str->len,
(const unsigned char *) psk_identity,
strlen(psk_identity)) == 0);
TEST_EQUAL(mbedtls_ssl_conf_psk(
&server.conf, options->psk_str->x,
options->psk_str->len,
(const unsigned char *) psk_identity,
strlen(psk_identity)), 0);
#if defined(MBEDTLS_SSL_SRV_C)
mbedtls_ssl_conf_psk_cb(&server.conf, psk_dummy_callback, NULL);
#endif
@ -2227,17 +2227,17 @@ void mbedtls_test_ssl_perform_handshake(
}
#endif /* MBEDTLS_SSL_RENEGOTIATION */
TEST_ASSERT(mbedtls_test_mock_socket_connect(&(client.socket),
&(server.socket),
BUFFSIZE) == 0);
TEST_EQUAL(mbedtls_test_mock_socket_connect(&(client.socket),
&(server.socket),
BUFFSIZE), 0);
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
if (options->resize_buffers != 0) {
/* Ensure that the buffer sizes are appropriate before resizes */
TEST_ASSERT(client.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN);
TEST_ASSERT(client.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN);
TEST_ASSERT(server.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN);
TEST_ASSERT(server.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN);
TEST_EQUAL(client.ssl.out_buf_len, MBEDTLS_SSL_OUT_BUFFER_LEN);
TEST_EQUAL(client.ssl.in_buf_len, MBEDTLS_SSL_IN_BUFFER_LEN);
TEST_EQUAL(server.ssl.out_buf_len, MBEDTLS_SSL_OUT_BUFFER_LEN);
TEST_EQUAL(server.ssl.in_buf_len, MBEDTLS_SSL_IN_BUFFER_LEN);
}
#endif
@ -2245,17 +2245,17 @@ void mbedtls_test_ssl_perform_handshake(
expected_handshake_result = MBEDTLS_ERR_SSL_BAD_PROTOCOL_VERSION;
}
TEST_ASSERT(mbedtls_test_move_handshake_to_state(&(client.ssl),
&(server.ssl),
MBEDTLS_SSL_HANDSHAKE_OVER)
== expected_handshake_result);
TEST_EQUAL(mbedtls_test_move_handshake_to_state(&(client.ssl),
&(server.ssl),
MBEDTLS_SSL_HANDSHAKE_OVER),
expected_handshake_result);
if (expected_handshake_result != 0) {
/* Connection will have failed by this point, skip to cleanup */
goto exit;
}
TEST_ASSERT(mbedtls_ssl_is_handshake_over(&client.ssl) == 1);
TEST_EQUAL(mbedtls_ssl_is_handshake_over(&client.ssl), 1);
/* Make sure server state is moved to HANDSHAKE_OVER also. */
TEST_EQUAL(mbedtls_test_move_handshake_to_state(&(server.ssl),
@ -2263,7 +2263,7 @@ void mbedtls_test_ssl_perform_handshake(
MBEDTLS_SSL_HANDSHAKE_OVER),
0);
TEST_ASSERT(mbedtls_ssl_is_handshake_over(&server.ssl) == 1);
TEST_EQUAL(mbedtls_ssl_is_handshake_over(&server.ssl), 1);
/* Check that both sides have negotiated the expected version. */
mbedtls_test_set_step(0);
if (!check_ssl_version(options->expected_negotiated_version,
@ -2286,48 +2286,48 @@ void mbedtls_test_ssl_perform_handshake(
if (options->resize_buffers != 0) {
/* A server, when using DTLS, might delay a buffer resize to happen
* after it receives a message, so we force it. */
TEST_ASSERT(exchange_data(&(client.ssl), &(server.ssl)) == 0);
TEST_EQUAL(exchange_data(&(client.ssl), &(server.ssl)), 0);
TEST_ASSERT(client.ssl.out_buf_len ==
mbedtls_ssl_get_output_buflen(&client.ssl));
TEST_ASSERT(client.ssl.in_buf_len ==
mbedtls_ssl_get_input_buflen(&client.ssl));
TEST_ASSERT(server.ssl.out_buf_len ==
mbedtls_ssl_get_output_buflen(&server.ssl));
TEST_ASSERT(server.ssl.in_buf_len ==
mbedtls_ssl_get_input_buflen(&server.ssl));
TEST_EQUAL(client.ssl.out_buf_len,
mbedtls_ssl_get_output_buflen(&client.ssl));
TEST_EQUAL(client.ssl.in_buf_len,
mbedtls_ssl_get_input_buflen(&client.ssl));
TEST_EQUAL(server.ssl.out_buf_len,
mbedtls_ssl_get_output_buflen(&server.ssl));
TEST_EQUAL(server.ssl.in_buf_len,
mbedtls_ssl_get_input_buflen(&server.ssl));
}
#endif
if (options->cli_msg_len != 0 || options->srv_msg_len != 0) {
/* Start data exchanging test */
TEST_ASSERT(mbedtls_test_ssl_exchange_data(
&(client.ssl), options->cli_msg_len,
options->expected_cli_fragments,
&(server.ssl), options->srv_msg_len,
options->expected_srv_fragments)
== 0);
TEST_EQUAL(mbedtls_test_ssl_exchange_data(
&(client.ssl), options->cli_msg_len,
options->expected_cli_fragments,
&(server.ssl), options->srv_msg_len,
options->expected_srv_fragments),
0);
}
#if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
if (options->serialize == 1) {
TEST_ASSERT(options->dtls == 1);
TEST_EQUAL(options->dtls, 1);
TEST_ASSERT(mbedtls_ssl_context_save(&(server.ssl), NULL,
0, &context_buf_len)
== MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
TEST_EQUAL(mbedtls_ssl_context_save(&(server.ssl), NULL,
0, &context_buf_len),
MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
context_buf = mbedtls_calloc(1, context_buf_len);
TEST_ASSERT(context_buf != NULL);
TEST_ASSERT(mbedtls_ssl_context_save(&(server.ssl), context_buf,
context_buf_len,
&context_buf_len)
== 0);
TEST_EQUAL(mbedtls_ssl_context_save(&(server.ssl), context_buf,
context_buf_len,
&context_buf_len),
0);
mbedtls_ssl_free(&(server.ssl));
mbedtls_ssl_init(&(server.ssl));
TEST_ASSERT(mbedtls_ssl_setup(&(server.ssl), &(server.conf)) == 0);
TEST_EQUAL(mbedtls_ssl_setup(&(server.ssl), &(server.conf)), 0);
mbedtls_ssl_set_bio(&(server.ssl), &server_context,
mbedtls_test_mock_tcp_send_msg,
@ -2344,30 +2344,30 @@ void mbedtls_test_ssl_perform_handshake(
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
if (options->resize_buffers != 0) {
/* Ensure that the buffer sizes are appropriate before resizes */
TEST_ASSERT(server.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN);
TEST_ASSERT(server.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN);
TEST_EQUAL(server.ssl.out_buf_len, MBEDTLS_SSL_OUT_BUFFER_LEN);
TEST_EQUAL(server.ssl.in_buf_len, MBEDTLS_SSL_IN_BUFFER_LEN);
}
#endif
TEST_ASSERT(mbedtls_ssl_context_load(&(server.ssl), context_buf,
context_buf_len) == 0);
TEST_EQUAL(mbedtls_ssl_context_load(&(server.ssl), context_buf,
context_buf_len), 0);
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
/* Validate buffer sizes after context deserialization */
if (options->resize_buffers != 0) {
TEST_ASSERT(server.ssl.out_buf_len ==
mbedtls_ssl_get_output_buflen(&server.ssl));
TEST_ASSERT(server.ssl.in_buf_len ==
mbedtls_ssl_get_input_buflen(&server.ssl));
TEST_EQUAL(server.ssl.out_buf_len,
mbedtls_ssl_get_output_buflen(&server.ssl));
TEST_EQUAL(server.ssl.in_buf_len,
mbedtls_ssl_get_input_buflen(&server.ssl));
}
#endif
/* Retest writing/reading */
if (options->cli_msg_len != 0 || options->srv_msg_len != 0) {
TEST_ASSERT(mbedtls_test_ssl_exchange_data(
&(client.ssl), options->cli_msg_len,
options->expected_cli_fragments,
&(server.ssl), options->srv_msg_len,
options->expected_srv_fragments)
== 0);
TEST_EQUAL(mbedtls_test_ssl_exchange_data(
&(client.ssl), options->cli_msg_len,
options->expected_cli_fragments,
&(server.ssl), options->srv_msg_len,
options->expected_srv_fragments),
0);
}
}
#endif /* MBEDTLS_SSL_CONTEXT_SERIALIZATION */
@ -2375,24 +2375,24 @@ void mbedtls_test_ssl_perform_handshake(
#if defined(MBEDTLS_SSL_RENEGOTIATION)
if (options->renegotiate) {
/* Start test with renegotiation */
TEST_ASSERT(server.ssl.renego_status ==
MBEDTLS_SSL_INITIAL_HANDSHAKE);
TEST_ASSERT(client.ssl.renego_status ==
MBEDTLS_SSL_INITIAL_HANDSHAKE);
TEST_EQUAL(server.ssl.renego_status,
MBEDTLS_SSL_INITIAL_HANDSHAKE);
TEST_EQUAL(client.ssl.renego_status,
MBEDTLS_SSL_INITIAL_HANDSHAKE);
/* After calling this function for the server, it only sends a handshake
* request. All renegotiation should happen during data exchanging */
TEST_ASSERT(mbedtls_ssl_renegotiate(&(server.ssl)) == 0);
TEST_ASSERT(server.ssl.renego_status ==
MBEDTLS_SSL_RENEGOTIATION_PENDING);
TEST_ASSERT(client.ssl.renego_status ==
MBEDTLS_SSL_INITIAL_HANDSHAKE);
TEST_EQUAL(mbedtls_ssl_renegotiate(&(server.ssl)), 0);
TEST_EQUAL(server.ssl.renego_status,
MBEDTLS_SSL_RENEGOTIATION_PENDING);
TEST_EQUAL(client.ssl.renego_status,
MBEDTLS_SSL_INITIAL_HANDSHAKE);
TEST_ASSERT(exchange_data(&(client.ssl), &(server.ssl)) == 0);
TEST_ASSERT(server.ssl.renego_status ==
MBEDTLS_SSL_RENEGOTIATION_DONE);
TEST_ASSERT(client.ssl.renego_status ==
MBEDTLS_SSL_RENEGOTIATION_DONE);
TEST_EQUAL(exchange_data(&(client.ssl), &(server.ssl)), 0);
TEST_EQUAL(server.ssl.renego_status,
MBEDTLS_SSL_RENEGOTIATION_DONE);
TEST_EQUAL(client.ssl.renego_status,
MBEDTLS_SSL_RENEGOTIATION_DONE);
/* After calling mbedtls_ssl_renegotiate for the client,
* all renegotiation should happen inside this function.
@ -2404,34 +2404,34 @@ void mbedtls_test_ssl_perform_handshake(
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
if (options->resize_buffers != 0) {
/* Ensure that the buffer sizes are appropriate before resizes */
TEST_ASSERT(client.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN);
TEST_ASSERT(client.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN);
TEST_EQUAL(client.ssl.out_buf_len, MBEDTLS_SSL_OUT_BUFFER_LEN);
TEST_EQUAL(client.ssl.in_buf_len, MBEDTLS_SSL_IN_BUFFER_LEN);
}
#endif
TEST_ASSERT(ret == 0 ||
ret == MBEDTLS_ERR_SSL_WANT_READ ||
ret == MBEDTLS_ERR_SSL_WANT_WRITE);
TEST_ASSERT(server.ssl.renego_status ==
MBEDTLS_SSL_RENEGOTIATION_DONE);
TEST_ASSERT(client.ssl.renego_status ==
MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS);
TEST_EQUAL(server.ssl.renego_status,
MBEDTLS_SSL_RENEGOTIATION_DONE);
TEST_EQUAL(client.ssl.renego_status,
MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS);
TEST_ASSERT(exchange_data(&(client.ssl), &(server.ssl)) == 0);
TEST_ASSERT(server.ssl.renego_status ==
MBEDTLS_SSL_RENEGOTIATION_DONE);
TEST_ASSERT(client.ssl.renego_status ==
MBEDTLS_SSL_RENEGOTIATION_DONE);
TEST_EQUAL(exchange_data(&(client.ssl), &(server.ssl)), 0);
TEST_EQUAL(server.ssl.renego_status,
MBEDTLS_SSL_RENEGOTIATION_DONE);
TEST_EQUAL(client.ssl.renego_status,
MBEDTLS_SSL_RENEGOTIATION_DONE);
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
/* Validate buffer sizes after renegotiation */
if (options->resize_buffers != 0) {
TEST_ASSERT(client.ssl.out_buf_len ==
mbedtls_ssl_get_output_buflen(&client.ssl));
TEST_ASSERT(client.ssl.in_buf_len ==
mbedtls_ssl_get_input_buflen(&client.ssl));
TEST_ASSERT(server.ssl.out_buf_len ==
mbedtls_ssl_get_output_buflen(&server.ssl));
TEST_ASSERT(server.ssl.in_buf_len ==
mbedtls_ssl_get_input_buflen(&server.ssl));
TEST_EQUAL(client.ssl.out_buf_len,
mbedtls_ssl_get_output_buflen(&client.ssl));
TEST_EQUAL(client.ssl.in_buf_len,
mbedtls_ssl_get_input_buflen(&client.ssl));
TEST_EQUAL(server.ssl.out_buf_len,
mbedtls_ssl_get_output_buflen(&server.ssl));
TEST_EQUAL(server.ssl.in_buf_len,
mbedtls_ssl_get_input_buflen(&server.ssl));
}
#endif /* MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH */
}

1293
tests/suites/test_suite_ssl.function
View File

File diff suppressed because it is too large Load Diff