From b27b1c5db0536496541d28b84c52de2a2852774b Mon Sep 17 00:00:00 2001 From: Gabor Mezei Date: Mon, 12 Sep 2022 16:36:48 +0200 Subject: [PATCH] Add tests for conditional assign and swap functions Signed-off-by: Gabor Mezei --- tests/suites/test_suite_mpi.data | 102 +++++++++ tests/suites/test_suite_mpi.function | 320 +++++++++++++++++++++++++++ 2 files changed, 422 insertions(+) diff --git a/tests/suites/test_suite_mpi.data b/tests/suites/test_suite_mpi.data index 85812f5080..124c8519b0 100644 --- a/tests/suites/test_suite_mpi.data +++ b/tests/suites/test_suite_mpi.data @@ -681,6 +681,108 @@ mpi_core_lt_ct:"11FFFFFFFFFFFFFFFF":"FF1111111111111111":1 mbedtls_mpi_core_lt_ct: x>y (alternating limbs) mpi_core_lt_ct:"FF1111111111111111":"11FFFFFFFFFFFFFFFF":0 +mbedtls_mpi_core_cond_assign: same size, true condition +mpi_core_cond_assign:"FFFFFFFF":"11111111":1:0 + +mbedtls_mpi_core_cond_assign: same size, false condition +mpi_core_cond_assign:"FFFFFFFF":"11111111":0:0 + +mbedtls_mpi_core_cond_assign: target larger, true condition +mpi_core_cond_assign:"FFFFFFFFEEEEEEEEDDDDDDDD":"11111111":1:0 + +mbedtls_mpi_core_cond_assign: target larger, false condition +mpi_core_cond_assign:"FFFFFFFFEEEEEEEEDDDDDDDD":"11111111":0:0 + +#mbedtls_mpi_core_cond_assign: target smaller, true condition +#mpi_core_cond_assign:"FFFFFFFF":"111111112222222233333333":1:MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL + +#mbedtls_mpi_core_cond_assign: target smaller, false condition +#mpi_core_cond_assign:"FFFFFFFF":"111111112222222233333333":0:MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL + +#mbedtls_mpi_core_cond_assign: target invalid, true condition +#mpi_core_cond_assign:"":"11111111":1:MBEDTLS_ERR_MPI_BAD_INPUT_DATA + +#mbedtls_mpi_core_cond_assign: target invalid, false condition +#mpi_core_cond_assign:"":"11111111":0:MBEDTLS_ERR_MPI_BAD_INPUT_DATA + +#mbedtls_mpi_core_cond_assign: source invalid, true condition +#mpi_core_cond_assign:"FFFFFFFF":"":1:MBEDTLS_ERR_MPI_BAD_INPUT_DATA + +#mbedtls_mpi_core_cond_assign: source invalid, false condition +#mpi_core_cond_assign:"FFFFFFFF":"":0:MBEDTLS_ERR_MPI_BAD_INPUT_DATA + +mbedtls_mpi_core_cond_swap: same value, true condition +mpi_core_cond_swap:"FFFFFFFF":"FFFFFFFF":1:0 + +mbedtls_mpi_core_cond_swap: same size, true condition +mpi_core_cond_swap:"FFFFFFFF":"11111111":1:0 + +mbedtls_mpi_core_cond_swap: same size, false condition +mpi_core_cond_swap:"FFFFFFFF":"11111111":0:0 + +#mbedtls_mpi_core_cond_swap: first larger, true condition +#mpi_core_cond_swap:"FFFFFFFFEEEEEEEEDDDDDDDD":"11111111":1:MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL + +#mbedtls_mpi_core_cond_swap: first larger, false condition +#mpi_core_cond_swap:"FFFFFFFFEEEEEEEEDDDDDDDD":"11111111":0:MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL + +#mbedtls_mpi_core_cond_swap: first smaller, true condition +#mpi_core_cond_swap:"FFFFFFFF":"111111112222222233333333":1:MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL + +#mbedtls_mpi_core_cond_swap: first smaller, false condition +#mpi_core_cond_swap:"FFFFFFFF":"111111112222222233333333":0:MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL + +#mbedtls_mpi_core_cond_swap: first invalid, true condition +#mpi_core_cond_swap:"":"11111111":1:MBEDTLS_ERR_MPI_BAD_INPUT_DATA + +#mbedtls_mpi_core_cond_swap: first invalid, false condition +#mpi_core_cond_swap:"":"11111111":0:MBEDTLS_ERR_MPI_BAD_INPUT_DATA + +#mbedtls_mpi_core_cond_swap: second invalid, true condition +#mpi_core_cond_swap:"FFFFFFFF":"":1:MBEDTLS_ERR_MPI_BAD_INPUT_DATA + +#mbedtls_mpi_core_cond_swap: second invalid, false condition +#mpi_core_cond_swap:"FFFFFFFF":"":0:MBEDTLS_ERR_MPI_BAD_INPUT_DATA + +mbedtls_mpi_mod_raw_cond_assign: same size, true condition +mpi_mod_raw_cond_assign:"FFFFFFFF":"11111111":1:0 + +mbedtls_mpi_mod_raw_cond_assign: same size, false condition +mpi_mod_raw_cond_assign:"FFFFFFFF":"11111111":0:0 + +#mbedtls_mpi_mod_raw_cond_assign: target invalid, true condition +#mpi_mod_raw_cond_assign:"":"11111111":1:MBEDTLS_ERR_MPI_BAD_INPUT_DATA + +#mbedtls_mpi_mod_raw_cond_assign: target invalid, false condition +#mpi_mod_raw_cond_assign:"":"11111111":0:MBEDTLS_ERR_MPI_BAD_INPUT_DATA + +#mbedtls_mpi_mod_raw_cond_assign: source invalid, true condition +#mpi_mod_raw_cond_assign:"FFFFFFFF":"":1:MBEDTLS_ERR_MPI_BAD_INPUT_DATA + +#mbedtls_mpi_mod_raw_cond_assign: source invalid, false condition +#mpi_mod_raw_cond_assign:"FFFFFFFF":"":0:MBEDTLS_ERR_MPI_BAD_INPUT_DATA + +mbedtls_mpi_mod_raw_cond_swap: same value, true condition +mpi_mod_raw_cond_swap:"FFFFFFFF":"FFFFFFFF":1:0 + +mbedtls_mpi_mod_raw_cond_swap: same size, true condition +mpi_mod_raw_cond_swap:"FFFFFFFF":"11111111":1:0 + +mbedtls_mpi_mod_raw_cond_swap: same size, false condition +mpi_mod_raw_cond_swap:"FFFFFFFF":"11111111":0:0 + +#mbedtls_mpi_mod_raw_cond_swap: first invalid, true condition +#mpi_mod_raw_cond_swap:"":"11111111":1:MBEDTLS_ERR_MPI_BAD_INPUT_DATA + +#mbedtls_mpi_mod_raw_cond_swap: first invalid, false condition +#mpi_mod_raw_cond_swap:"":"11111111":0:MBEDTLS_ERR_MPI_BAD_INPUT_DATA + +#mbedtls_mpi_mod_raw_cond_swap: second invalid, true condition +#mpi_mod_raw_cond_swap:"FFFFFFFF":"":1:MBEDTLS_ERR_MPI_BAD_INPUT_DATA + +#mbedtls_mpi_mod_raw_cond_swap: second invalid, false condition +#mpi_mod_raw_cond_swap:"FFFFFFFF":"":0:MBEDTLS_ERR_MPI_BAD_INPUT_DATA + Base test mbedtls_mpi_lt_mpi_ct #1 mpi_lt_mpi_ct:1:"2B5":1:"2B5":0:0 diff --git a/tests/suites/test_suite_mpi.function b/tests/suites/test_suite_mpi.function index ff2eaac4ba..b8c7864245 100644 --- a/tests/suites/test_suite_mpi.function +++ b/tests/suites/test_suite_mpi.function @@ -763,6 +763,326 @@ exit: } /* END_CASE */ +/* BEGIN_CASE */ +void mpi_core_cond_assign( data_t * input_X, + data_t * input_Y, + int cond, + int input_ret ) +{ + #define MAX_LEN 64 + mbedtls_mpi_uint buff_X[MAX_LEN]; + mbedtls_mpi_uint buff_Y[MAX_LEN]; + mbedtls_mpi_uint *X = buff_X; + mbedtls_mpi_uint *Y = buff_Y; + unsigned exp_ret = input_ret; + unsigned ret; + size_t len_X = CHARS_TO_LIMBS( input_X->len ); + size_t len_Y = CHARS_TO_LIMBS( input_Y->len ); + + TEST_ASSERT( len_X <= MAX_LEN ); + TEST_ASSERT( len_Y <= MAX_LEN ); + + if( len_X == 0 ) + { + X = NULL; + len_X = len_Y; + } + else + TEST_ASSERT( mbedtls_mpi_core_read_be( X, len_X, input_X->x, input_X->len ) + == 0 ); + + if( len_Y == 0 ) + { + Y = NULL; + len_Y = len_X; + } + else + TEST_ASSERT( mbedtls_mpi_core_read_be( Y, len_Y, input_Y->x, input_Y->len ) + == 0 ); + + TEST_CF_SECRET( X, len_X * sizeof( mbedtls_mpi_uint ) ); + TEST_CF_SECRET( Y, len_Y * sizeof( mbedtls_mpi_uint ) ); + + ret = mbedtls_mpi_core_cond_assign( X, len_X, Y, len_Y, cond ); + + TEST_CF_PUBLIC( X, len_X * sizeof( mbedtls_mpi_uint ) ); + TEST_CF_PUBLIC( Y, len_Y * sizeof( mbedtls_mpi_uint ) ); + TEST_CF_PUBLIC( &ret, sizeof( ret ) ); + + TEST_EQUAL( ret, exp_ret ); + + if( !ret ) + { + if( cond ) + ASSERT_COMPARE( X, len_Y * sizeof( mbedtls_mpi_uint ), + Y, len_Y * sizeof( mbedtls_mpi_uint ) ); + + else + TEST_ASSERT( memcmp( X, Y, len_X * sizeof( mbedtls_mpi_uint ) ) != 0 ); + } + +exit: + ; + + #undef MAX_LEN +} +/* END_CASE */ + +/* BEGIN_CASE */ +void mpi_core_cond_swap( data_t * input_X, + data_t * input_Y, + int cond, + int input_ret ) +{ + #define MAX_LEN 64 + mbedtls_mpi_uint tmp_X[MAX_LEN]; + mbedtls_mpi_uint tmp_Y[MAX_LEN]; + mbedtls_mpi_uint buff_X[MAX_LEN]; + mbedtls_mpi_uint buff_Y[MAX_LEN]; + mbedtls_mpi_uint *X = buff_X; + mbedtls_mpi_uint *Y = buff_Y; + unsigned exp_ret = input_ret; + unsigned ret; + size_t len_X = CHARS_TO_LIMBS( input_X->len ); + size_t len_Y = CHARS_TO_LIMBS( input_Y->len ); + + TEST_ASSERT( len_X <= MAX_LEN ); + TEST_ASSERT( len_Y <= MAX_LEN ); + + if( len_X == 0 ) + { + X = NULL; + len_X = len_Y; + } + else + { + TEST_ASSERT( mbedtls_mpi_core_read_be( tmp_X, len_X, + input_X->x, input_X->len ) + == 0 ); + memcpy( X, tmp_X, len_X * sizeof( mbedtls_mpi_uint ) ); + } + + if( len_Y == 0 ) + { + Y = NULL; + len_Y = len_X; + } + else + { + TEST_ASSERT( mbedtls_mpi_core_read_be( tmp_Y, len_Y, + input_Y->x, input_Y->len ) + == 0 ); + memcpy( Y, tmp_Y, len_Y * sizeof( mbedtls_mpi_uint ) ); + } + + TEST_CF_SECRET( X, len_X * sizeof( mbedtls_mpi_uint ) ); + TEST_CF_SECRET( Y, len_Y * sizeof( mbedtls_mpi_uint ) ); + + ret = mbedtls_mpi_core_cond_swap( X, len_X, Y, len_Y, cond ); + + TEST_CF_PUBLIC( X, len_X * sizeof( mbedtls_mpi_uint ) ); + TEST_CF_PUBLIC( Y, len_Y * sizeof( mbedtls_mpi_uint ) ); + TEST_CF_PUBLIC( &ret, sizeof( ret ) ); + + TEST_EQUAL( ret, exp_ret ); + + if( !ret ) + { + if( cond ) + { + ASSERT_COMPARE( X, len_Y * sizeof( mbedtls_mpi_uint ), + tmp_Y, len_Y * sizeof( mbedtls_mpi_uint ) ); + ASSERT_COMPARE( Y, len_X * sizeof( mbedtls_mpi_uint ), + tmp_X, len_X * sizeof( mbedtls_mpi_uint ) ); + } + + else + { + ASSERT_COMPARE( X, len_X * sizeof( mbedtls_mpi_uint ), + tmp_X, len_X * sizeof( mbedtls_mpi_uint ) ); + ASSERT_COMPARE( Y, len_Y * sizeof( mbedtls_mpi_uint ), + tmp_Y, len_Y * sizeof( mbedtls_mpi_uint ) ); + } + } + +exit: + ; + + #undef MAX_LEN +} +/* END_CASE */ + +/* BEGIN_CASE */ +void mpi_mod_raw_cond_assign( data_t * input_X, + data_t * input_Y, + int cond, + int input_ret ) +{ + #define MAX_LEN 64 + mbedtls_mpi_uint buff_X[MAX_LEN]; + mbedtls_mpi_uint buff_Y[MAX_LEN]; + mbedtls_mpi_uint buff_m[MAX_LEN]; + mbedtls_mpi_uint *X = buff_X; + mbedtls_mpi_uint *Y = buff_Y; + mbedtls_mpi_mod_modulus m; + unsigned exp_ret = input_ret; + unsigned ret; + size_t len_X = CHARS_TO_LIMBS( input_X->len ); + size_t len_Y = CHARS_TO_LIMBS( input_Y->len ); + + TEST_ASSERT( len_X <= MAX_LEN ); + TEST_ASSERT( len_Y <= MAX_LEN ); + + memset( buff_m, 0, MAX_LEN * sizeof( mbedtls_mpi_uint ) ); + mbedtls_mpi_mod_modulus_init( &m ); + TEST_ASSERT( mbedtls_mpi_mod_modulus_setup( + &m, buff_m, + len_X <= len_Y ? len_X : len_Y, + MBEDTLS_MPI_MOD_EXT_REP_BE, + MBEDTLS_MPI_MOD_REP_MONTGOMERY ) + == 0 ); + + if( len_X == 0 ) + { + X = NULL; + len_X = len_Y; + } + else + TEST_ASSERT( mbedtls_mpi_core_read_be( X, len_X, + input_X->x, input_X->len ) + == 0 ); + + if( len_Y == 0 ) + { + Y = NULL; + len_Y = len_X; + } + else + TEST_ASSERT( mbedtls_mpi_core_read_be( Y, len_Y, + input_Y->x, input_Y->len ) + == 0 ); + + TEST_CF_SECRET( X, len_X * sizeof( mbedtls_mpi_uint ) ); + TEST_CF_SECRET( Y, len_Y * sizeof( mbedtls_mpi_uint ) ); + + ret = mbedtls_mpi_mod_raw_cond_assign( X, Y, &m, cond ); + + TEST_CF_PUBLIC( X, len_X * sizeof( mbedtls_mpi_uint ) ); + TEST_CF_PUBLIC( Y, len_Y * sizeof( mbedtls_mpi_uint ) ); + TEST_CF_PUBLIC( &ret, sizeof( ret ) ); + + TEST_EQUAL( ret, exp_ret ); + + if( !ret ) + { + if( cond ) + ASSERT_COMPARE( X, len_Y * sizeof( mbedtls_mpi_uint ), + Y, len_Y * sizeof( mbedtls_mpi_uint ) ); + + else + TEST_ASSERT( memcmp( X, Y, m.limbs * sizeof( mbedtls_mpi_uint ) ) != 0 ); + } + +exit: + ; + + #undef MAX_LEN +} +/* END_CASE */ + +/* BEGIN_CASE */ +void mpi_mod_raw_cond_swap( data_t * input_X, + data_t * input_Y, + int cond, + int input_ret ) +{ + #define MAX_LEN 64 + mbedtls_mpi_uint tmp_X[MAX_LEN]; + mbedtls_mpi_uint tmp_Y[MAX_LEN]; + mbedtls_mpi_uint buff_X[MAX_LEN]; + mbedtls_mpi_uint buff_Y[MAX_LEN]; + mbedtls_mpi_uint buff_m[MAX_LEN]; + mbedtls_mpi_uint *X = buff_X; + mbedtls_mpi_uint *Y = buff_Y; + mbedtls_mpi_mod_modulus m; + unsigned exp_ret = input_ret; + unsigned ret; + size_t len_X = CHARS_TO_LIMBS( input_X->len ); + size_t len_Y = CHARS_TO_LIMBS( input_Y->len ); + + TEST_ASSERT( len_X <= MAX_LEN ); + TEST_ASSERT( len_Y <= MAX_LEN ); + + memset( buff_m, 0, MAX_LEN * sizeof( mbedtls_mpi_uint ) ); + mbedtls_mpi_mod_modulus_init( &m ); + TEST_ASSERT( mbedtls_mpi_mod_modulus_setup( + &m, buff_m, + len_X <= len_Y ? len_X : len_Y, + MBEDTLS_MPI_MOD_EXT_REP_BE, + MBEDTLS_MPI_MOD_REP_MONTGOMERY ) + == 0 ); + + if( len_X == 0 ) + { + X = NULL; + len_X = len_Y; + } + else + { + TEST_ASSERT( mbedtls_mpi_core_read_be( tmp_X, len_X, input_X->x, input_X->len ) + == 0 ); + memcpy( X, tmp_X, len_X * sizeof( mbedtls_mpi_uint ) ); + } + + if( len_Y == 0 ) + { + Y = NULL; + len_Y = len_X; + } + else + { + TEST_ASSERT( mbedtls_mpi_core_read_be( tmp_Y, len_Y, input_Y->x, input_Y->len ) + == 0 ); + memcpy( Y, tmp_Y, len_Y * sizeof( mbedtls_mpi_uint ) ); + } + + TEST_CF_SECRET( X, len_X * sizeof( mbedtls_mpi_uint ) ); + TEST_CF_SECRET( Y, len_Y * sizeof( mbedtls_mpi_uint ) ); + + ret = mbedtls_mpi_mod_raw_cond_swap( X, Y, &m, cond ); + + TEST_CF_PUBLIC( X, len_X * sizeof( mbedtls_mpi_uint ) ); + TEST_CF_PUBLIC( Y, len_Y * sizeof( mbedtls_mpi_uint ) ); + TEST_CF_PUBLIC( &ret, sizeof( ret ) ); + + TEST_EQUAL( ret, exp_ret ); + + if( !ret ) + { + if( cond ) + { + ASSERT_COMPARE( X, m.limbs * sizeof( mbedtls_mpi_uint ), + tmp_Y, len_Y * sizeof( mbedtls_mpi_uint ) ); + ASSERT_COMPARE( Y, m.limbs * sizeof( mbedtls_mpi_uint ), + tmp_X, len_X * sizeof( mbedtls_mpi_uint ) ); + } + + else + { + ASSERT_COMPARE( X, len_X * sizeof( mbedtls_mpi_uint ), + tmp_X, m.limbs * sizeof( mbedtls_mpi_uint ) ); + ASSERT_COMPARE( Y, len_Y * sizeof( mbedtls_mpi_uint ), + tmp_Y, m.limbs * sizeof( mbedtls_mpi_uint ) ); + } + } + +exit: + ; + + #undef MAX_LEN +} +/* END_CASE */ + /* BEGIN_CASE */ void mpi_lt_mpi_ct( int size_X, char * input_X, int size_Y, char * input_Y,