blob: 3379a999d15113f665bc1c7ad705827be1b2de04 [file] [log] [blame]
Paul Bakker33b43f12013-08-20 11:48:36 +02001/* BEGIN_HEADER */
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +00002#include "mbedtls/bignum.h"
Janos Follath64eca052018-09-05 17:04:49 +01003
4typedef struct mbedtls_test_mpi_random
5{
6 data_t *data;
7 size_t pos;
8 size_t chunk_len;
9} mbedtls_test_mpi_random;
10
11/*
12 * This function is called by the Miller-Rabin primality test each time it
13 * chooses a random witness. The witnesses (or non-witnesses as provided by the
14 * test) are stored in the data member of the state structure. Each number is in
15 * the format that mbedtls_mpi_read_string understands and is chunk_len long.
16 */
17int mbedtls_test_mpi_miller_rabin_determinizer( void* state,
18 unsigned char* buf,
19 size_t len )
20{
21 mbedtls_test_mpi_random *random = (mbedtls_test_mpi_random*) state;
22
23 if( random == NULL || random->data->x == NULL || buf == NULL )
24 return( -1 );
25
26 if( random->pos + random->chunk_len > random->data->len
27 || random->chunk_len > len )
28 {
29 return( -1 );
30 }
31
32 memset( buf, 0, len );
33
34 /* The witness is written to the end of the buffer, since the buffer is
35 * used as big endian, unsigned binary data in mbedtls_mpi_read_binary.
36 * Writing the witness to the start of the buffer would result in the
37 * buffer being 'witness 000...000', which would be treated as
38 * witness * 2^n for some n. */
39 memcpy( buf + len - random->chunk_len, &random->data->x[random->pos],
40 random->chunk_len );
41
42 random->pos += random->chunk_len;
43
44 return( 0 );
45}
Paul Bakker33b43f12013-08-20 11:48:36 +020046/* END_HEADER */
Paul Bakker367dae42009-06-28 21:50:27 +000047
Paul Bakker33b43f12013-08-20 11:48:36 +020048/* BEGIN_DEPENDENCIES
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020049 * depends_on:MBEDTLS_BIGNUM_C
Paul Bakker33b43f12013-08-20 11:48:36 +020050 * END_DEPENDENCIES
51 */
Paul Bakker5690efc2011-05-26 13:16:06 +000052
Hanno Beckerb48e1aa2018-12-18 23:25:01 +000053/* BEGIN_CASE */
54void mpi_valid_param( )
55{
56 TEST_VALID_PARAM( mbedtls_mpi_free( NULL ) );
57}
58/* END_CASE */
59
Hanno Beckerafb607b2018-12-11 14:27:08 +000060/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
61void mpi_invalid_param( )
62{
63 mbedtls_mpi X;
64 const char *s_in = "00101000101010";
65 char s_out[16] = { 0 };
66 unsigned char u_out[16] = { 0 };
67 unsigned char u_in[16] = { 0 };
68 size_t olen;
69 mbedtls_mpi_uint mpi_uint;
70
71 TEST_INVALID_PARAM( mbedtls_mpi_init( NULL ) );
Hanno Beckere1185042018-12-13 14:31:46 +000072
Hanno Beckerafb607b2018-12-11 14:27:08 +000073 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
74 mbedtls_mpi_grow( NULL, 42 ) );
75 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
76 mbedtls_mpi_copy( NULL, &X ) );
77 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
78 mbedtls_mpi_copy( &X, NULL ) );
Hanno Beckere1185042018-12-13 14:31:46 +000079
Hanno Beckerafb607b2018-12-11 14:27:08 +000080 TEST_INVALID_PARAM( mbedtls_mpi_swap( NULL, &X ) );
81 TEST_INVALID_PARAM( mbedtls_mpi_swap( &X, NULL ) );
Hanno Beckere1185042018-12-13 14:31:46 +000082
Hanno Beckerafb607b2018-12-11 14:27:08 +000083 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
84 mbedtls_mpi_safe_cond_assign( NULL, &X, 0 ) );
85 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
86 mbedtls_mpi_safe_cond_assign( &X, NULL, 0 ) );
Hanno Beckere1185042018-12-13 14:31:46 +000087
Hanno Beckerafb607b2018-12-11 14:27:08 +000088 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
89 mbedtls_mpi_safe_cond_swap( NULL, &X, 0 ) );
90 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
91 mbedtls_mpi_safe_cond_swap( &X, NULL, 0 ) );
Hanno Beckere1185042018-12-13 14:31:46 +000092
Hanno Beckerafb607b2018-12-11 14:27:08 +000093 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
94 mbedtls_mpi_lset( NULL, 42 ) );
Hanno Beckere1185042018-12-13 14:31:46 +000095
Hanno Beckerafb607b2018-12-11 14:27:08 +000096 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
97 mbedtls_mpi_get_bit( NULL, 42 ) );
98 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
99 mbedtls_mpi_set_bit( NULL, 42, 0 ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000100
Hanno Beckerafb607b2018-12-11 14:27:08 +0000101 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
102 mbedtls_mpi_read_string( NULL, 2, s_in ) );
103 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
104 mbedtls_mpi_read_string( &X, 2, NULL ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000105
Hanno Beckerafb607b2018-12-11 14:27:08 +0000106 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
107 mbedtls_mpi_write_string( NULL, 2,
108 s_out, sizeof( s_out ),
109 &olen ) );
110 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
111 mbedtls_mpi_write_string( &X, 2,
112 NULL, sizeof( s_out ),
113 &olen ) );
114 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
115 mbedtls_mpi_write_string( &X, 2,
116 s_out, sizeof( s_out ),
117 NULL ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000118
Hanno Beckerafb607b2018-12-11 14:27:08 +0000119#if defined(MBEDTLS_FS_IO)
120 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
121 mbedtls_mpi_read_file( NULL, 2, stdin ) );
122 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
123 mbedtls_mpi_read_file( &X, 2, NULL ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000124
Hanno Beckerafb607b2018-12-11 14:27:08 +0000125 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
126 mbedtls_mpi_write_file( "", NULL, 2, NULL ) );
127#endif /* MBEDTLS_FS_IO */
128
129 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
130 mbedtls_mpi_read_binary( NULL, u_in,
131 sizeof( u_in ) ) );
132 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
133 mbedtls_mpi_read_binary( &X, NULL,
134 sizeof( u_in ) ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000135
Hanno Beckerafb607b2018-12-11 14:27:08 +0000136 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
137 mbedtls_mpi_write_binary( NULL, u_out,
138 sizeof( u_out ) ) );
139 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
140 mbedtls_mpi_write_binary( &X, NULL,
141 sizeof( u_out ) ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000142
Hanno Beckerafb607b2018-12-11 14:27:08 +0000143 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
144 mbedtls_mpi_shift_l( NULL, 42 ) );
145 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
146 mbedtls_mpi_shift_r( NULL, 42 ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000147
Hanno Beckerafb607b2018-12-11 14:27:08 +0000148 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
149 mbedtls_mpi_cmp_abs( NULL, &X ) );
150 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
151 mbedtls_mpi_cmp_abs( &X, NULL ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000152
Hanno Beckerafb607b2018-12-11 14:27:08 +0000153 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
154 mbedtls_mpi_cmp_mpi( NULL, &X ) );
155 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
156 mbedtls_mpi_cmp_mpi( &X, NULL ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000157
Hanno Beckerafb607b2018-12-11 14:27:08 +0000158 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
159 mbedtls_mpi_cmp_int( NULL, 42 ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000160
Hanno Beckerafb607b2018-12-11 14:27:08 +0000161 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
162 mbedtls_mpi_add_abs( NULL, &X, &X ) );
163 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
164 mbedtls_mpi_add_abs( &X, NULL, &X ) );
165 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
166 mbedtls_mpi_add_abs( &X, &X, NULL ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000167
Hanno Beckerafb607b2018-12-11 14:27:08 +0000168 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
169 mbedtls_mpi_sub_abs( NULL, &X, &X ) );
170 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
171 mbedtls_mpi_sub_abs( &X, NULL, &X ) );
172 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
173 mbedtls_mpi_sub_abs( &X, &X, NULL ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000174
Hanno Beckerafb607b2018-12-11 14:27:08 +0000175 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
176 mbedtls_mpi_add_mpi( NULL, &X, &X ) );
177 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
178 mbedtls_mpi_add_mpi( &X, NULL, &X ) );
179 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
180 mbedtls_mpi_add_mpi( &X, &X, NULL ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000181
Hanno Beckerafb607b2018-12-11 14:27:08 +0000182 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
183 mbedtls_mpi_sub_mpi( NULL, &X, &X ) );
184 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
185 mbedtls_mpi_sub_mpi( &X, NULL, &X ) );
186 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
187 mbedtls_mpi_sub_mpi( &X, &X, NULL ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000188
Hanno Beckerafb607b2018-12-11 14:27:08 +0000189 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
190 mbedtls_mpi_add_int( NULL, &X, 42 ) );
191 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
192 mbedtls_mpi_add_int( &X, NULL, 42 ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000193
Hanno Beckerafb607b2018-12-11 14:27:08 +0000194 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
195 mbedtls_mpi_sub_int( NULL, &X, 42 ) );
196 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
197 mbedtls_mpi_sub_int( &X, NULL, 42 ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000198
Hanno Beckerafb607b2018-12-11 14:27:08 +0000199 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
200 mbedtls_mpi_mul_mpi( NULL, &X, &X ) );
201 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
202 mbedtls_mpi_mul_mpi( &X, NULL, &X ) );
203 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
204 mbedtls_mpi_mul_mpi( &X, &X, NULL ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000205
Hanno Beckerafb607b2018-12-11 14:27:08 +0000206 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
207 mbedtls_mpi_mul_int( NULL, &X, 42 ) );
208 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
209 mbedtls_mpi_mul_int( &X, NULL, 42 ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000210
Hanno Beckerafb607b2018-12-11 14:27:08 +0000211 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
212 mbedtls_mpi_div_mpi( &X, &X, NULL, &X ) );
213 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
214 mbedtls_mpi_div_mpi( &X, &X, &X, NULL ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000215
Hanno Beckerafb607b2018-12-11 14:27:08 +0000216 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
217 mbedtls_mpi_div_int( &X, &X, NULL, 42 ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000218
Hanno Beckerafb607b2018-12-11 14:27:08 +0000219 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
220 mbedtls_mpi_mod_mpi( NULL, &X, &X ) );
221 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
222 mbedtls_mpi_mod_mpi( &X, NULL, &X ) );
223 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
224 mbedtls_mpi_mod_mpi( &X, &X, NULL ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000225
Hanno Beckerafb607b2018-12-11 14:27:08 +0000226 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
227 mbedtls_mpi_mod_int( NULL, &X, 42 ) );
228 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
229 mbedtls_mpi_mod_int( &mpi_uint, NULL, 42 ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000230
Hanno Beckerafb607b2018-12-11 14:27:08 +0000231 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
232 mbedtls_mpi_exp_mod( NULL, &X, &X, &X, NULL ) );
233 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
234 mbedtls_mpi_exp_mod( &X, NULL, &X, &X, NULL ) );
235 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
236 mbedtls_mpi_exp_mod( &X, &X, NULL, &X, NULL ) );
237 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
238 mbedtls_mpi_exp_mod( &X, &X, &X, NULL, NULL ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000239
Hanno Beckerafb607b2018-12-11 14:27:08 +0000240 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
241 mbedtls_mpi_fill_random( NULL, 42, rnd_std_rand,
242 NULL ) );
243 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
244 mbedtls_mpi_fill_random( &X, 42, NULL, NULL ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000245
Hanno Beckerafb607b2018-12-11 14:27:08 +0000246 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
247 mbedtls_mpi_gcd( NULL, &X, &X ) );
248 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
249 mbedtls_mpi_gcd( &X, NULL, &X ) );
250 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
251 mbedtls_mpi_gcd( &X, &X, NULL ) );
Hanno Beckere1185042018-12-13 14:31:46 +0000252
Hanno Beckerafb607b2018-12-11 14:27:08 +0000253 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
254 mbedtls_mpi_inv_mod( NULL, &X, &X ) );
255 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
256 mbedtls_mpi_inv_mod( &X, NULL, &X ) );
257 TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
Hanno Beckere1185042018-12-13 14:31:46 +0000258 mbedtls_mpi_inv_mod( &X, &X, NULL ) );
Hanno Beckerafb607b2018-12-11 14:27:08 +0000259
260exit:
261 return;
Hanno Beckerafb607b2018-12-11 14:27:08 +0000262}
263/* END_CASE */
264
Paul Bakker33b43f12013-08-20 11:48:36 +0200265/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100266void mpi_null( )
Manuel Pégourié-Gonnard770b5e12015-04-29 17:02:01 +0200267{
Manuel Pégourié-Gonnardda61ed32015-04-30 10:28:51 +0200268 mbedtls_mpi X, Y, Z;
Manuel Pégourié-Gonnard770b5e12015-04-29 17:02:01 +0200269
Manuel Pégourié-Gonnardda61ed32015-04-30 10:28:51 +0200270 mbedtls_mpi_init( &X );
271 mbedtls_mpi_init( &Y );
272 mbedtls_mpi_init( &Z );
Manuel Pégourié-Gonnard770b5e12015-04-29 17:02:01 +0200273
Manuel Pégourié-Gonnardda61ed32015-04-30 10:28:51 +0200274 TEST_ASSERT( mbedtls_mpi_get_bit( &X, 42 ) == 0 );
275 TEST_ASSERT( mbedtls_mpi_lsb( &X ) == 0 );
Manuel Pégourié-Gonnardc0696c22015-06-18 16:47:17 +0200276 TEST_ASSERT( mbedtls_mpi_bitlen( &X ) == 0 );
Manuel Pégourié-Gonnardda61ed32015-04-30 10:28:51 +0200277 TEST_ASSERT( mbedtls_mpi_size( &X ) == 0 );
Manuel Pégourié-Gonnard770b5e12015-04-29 17:02:01 +0200278
279exit:
Manuel Pégourié-Gonnardda61ed32015-04-30 10:28:51 +0200280 mbedtls_mpi_free( &X );
Manuel Pégourié-Gonnard770b5e12015-04-29 17:02:01 +0200281}
282/* END_CASE */
283
284/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100285void mpi_read_write_string( int radix_X, char * input_X, int radix_A,
286 char * input_A, int output_size, int result_read,
Paul Bakker33b43f12013-08-20 11:48:36 +0200287 int result_write )
Paul Bakker367dae42009-06-28 21:50:27 +0000288{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200289 mbedtls_mpi X;
Paul Bakker367dae42009-06-28 21:50:27 +0000290 char str[1000];
Manuel Pégourié-Gonnardf79b4252015-06-02 15:41:48 +0100291 size_t len;
Paul Bakker367dae42009-06-28 21:50:27 +0000292
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200293 mbedtls_mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000294
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200295 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == result_read );
Paul Bakker33b43f12013-08-20 11:48:36 +0200296 if( result_read == 0 )
Paul Bakkerba48cb22009-07-12 11:01:32 +0000297 {
Manuel Pégourié-Gonnardf79b4252015-06-02 15:41:48 +0100298 TEST_ASSERT( mbedtls_mpi_write_string( &X, radix_A, str, output_size, &len ) == result_write );
Paul Bakker33b43f12013-08-20 11:48:36 +0200299 if( result_write == 0 )
Paul Bakkerba48cb22009-07-12 11:01:32 +0000300 {
Paul Bakker33b43f12013-08-20 11:48:36 +0200301 TEST_ASSERT( strcasecmp( str, input_A ) == 0 );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000302 }
303 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000304
Paul Bakkerbd51b262014-07-10 15:26:12 +0200305exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200306 mbedtls_mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000307}
Paul Bakker33b43f12013-08-20 11:48:36 +0200308/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000309
Paul Bakker33b43f12013-08-20 11:48:36 +0200310/* BEGIN_CASE */
Azim Khan5fcca462018-06-29 11:05:32 +0100311void mbedtls_mpi_read_binary( data_t * buf, int radix_A, char * input_A )
Paul Bakkere896fea2009-07-06 06:40:23 +0000312{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200313 mbedtls_mpi X;
Paul Bakkere896fea2009-07-06 06:40:23 +0000314 unsigned char str[1000];
Manuel Pégourié-Gonnardf79b4252015-06-02 15:41:48 +0100315 size_t len;
Paul Bakkere896fea2009-07-06 06:40:23 +0000316
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200317 mbedtls_mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000318
Paul Bakkere896fea2009-07-06 06:40:23 +0000319
Azim Khand30ca132017-06-09 04:32:58 +0100320 TEST_ASSERT( mbedtls_mpi_read_binary( &X, buf->x, buf->len ) == 0 );
Manuel Pégourié-Gonnardf79b4252015-06-02 15:41:48 +0100321 TEST_ASSERT( mbedtls_mpi_write_string( &X, radix_A, (char *) str, sizeof( str ), &len ) == 0 );
Paul Bakker33b43f12013-08-20 11:48:36 +0200322 TEST_ASSERT( strcmp( (char *) str, input_A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000323
Paul Bakkerbd51b262014-07-10 15:26:12 +0200324exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200325 mbedtls_mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000326}
Paul Bakker33b43f12013-08-20 11:48:36 +0200327/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000328
Paul Bakker33b43f12013-08-20 11:48:36 +0200329/* BEGIN_CASE */
Azim Khand30ca132017-06-09 04:32:58 +0100330void mbedtls_mpi_write_binary( int radix_X, char * input_X,
Azim Khan5fcca462018-06-29 11:05:32 +0100331 data_t * input_A, int output_size,
Azim Khanf1aaec92017-05-30 14:23:15 +0100332 int result )
Paul Bakkere896fea2009-07-06 06:40:23 +0000333{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200334 mbedtls_mpi X;
Paul Bakkere896fea2009-07-06 06:40:23 +0000335 unsigned char buf[1000];
Paul Bakkerf4a3f302011-04-24 15:53:29 +0000336 size_t buflen;
Paul Bakkere896fea2009-07-06 06:40:23 +0000337
338 memset( buf, 0x00, 1000 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000339
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200340 mbedtls_mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000341
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200342 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
Manuel Pégourié-Gonnarde670f902015-10-30 09:23:19 +0100343
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200344 buflen = mbedtls_mpi_size( &X );
Paul Bakker33b43f12013-08-20 11:48:36 +0200345 if( buflen > (size_t) output_size )
346 buflen = (size_t) output_size;
Paul Bakkere896fea2009-07-06 06:40:23 +0000347
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200348 TEST_ASSERT( mbedtls_mpi_write_binary( &X, buf, buflen ) == result );
Paul Bakker33b43f12013-08-20 11:48:36 +0200349 if( result == 0)
Paul Bakkerba48cb22009-07-12 11:01:32 +0000350 {
Paul Bakkere896fea2009-07-06 06:40:23 +0000351
Azim Khand30ca132017-06-09 04:32:58 +0100352 TEST_ASSERT( hexcmp( buf, input_A->x, buflen, input_A->len ) == 0 );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000353 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000354
Paul Bakkerbd51b262014-07-10 15:26:12 +0200355exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200356 mbedtls_mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000357}
Paul Bakker33b43f12013-08-20 11:48:36 +0200358/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000359
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200360/* BEGIN_CASE depends_on:MBEDTLS_FS_IO */
Azim Khand30ca132017-06-09 04:32:58 +0100361void mbedtls_mpi_read_file( int radix_X, char * input_file,
Azim Khan5fcca462018-06-29 11:05:32 +0100362 data_t * input_A, int result )
Paul Bakkere896fea2009-07-06 06:40:23 +0000363{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200364 mbedtls_mpi X;
Paul Bakkere896fea2009-07-06 06:40:23 +0000365 unsigned char buf[1000];
Paul Bakkerf4a3f302011-04-24 15:53:29 +0000366 size_t buflen;
Paul Bakker69998dd2009-07-11 19:15:20 +0000367 FILE *file;
Manuel Pégourié-Gonnarde43187d2015-02-14 16:01:34 +0000368 int ret;
Paul Bakkere896fea2009-07-06 06:40:23 +0000369
370 memset( buf, 0x00, 1000 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000371
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200372 mbedtls_mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000373
Paul Bakker33b43f12013-08-20 11:48:36 +0200374 file = fopen( input_file, "r" );
Paul Bakker8a0c0a92014-04-17 16:08:20 +0200375 TEST_ASSERT( file != NULL );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200376 ret = mbedtls_mpi_read_file( &X, radix_X, file );
Paul Bakkere896fea2009-07-06 06:40:23 +0000377 fclose(file);
Manuel Pégourié-Gonnarde43187d2015-02-14 16:01:34 +0000378 TEST_ASSERT( ret == result );
Paul Bakkere896fea2009-07-06 06:40:23 +0000379
Paul Bakker33b43f12013-08-20 11:48:36 +0200380 if( result == 0 )
Paul Bakkerba48cb22009-07-12 11:01:32 +0000381 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200382 buflen = mbedtls_mpi_size( &X );
383 TEST_ASSERT( mbedtls_mpi_write_binary( &X, buf, buflen ) == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000384
Paul Bakkere896fea2009-07-06 06:40:23 +0000385
Azim Khand30ca132017-06-09 04:32:58 +0100386 TEST_ASSERT( hexcmp( buf, input_A->x, buflen, input_A->len ) == 0 );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000387 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000388
Paul Bakkerbd51b262014-07-10 15:26:12 +0200389exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200390 mbedtls_mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000391}
Paul Bakker33b43f12013-08-20 11:48:36 +0200392/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000393
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200394/* BEGIN_CASE depends_on:MBEDTLS_FS_IO */
Azim Khanf1aaec92017-05-30 14:23:15 +0100395void mbedtls_mpi_write_file( int radix_X, char * input_X, int output_radix,
396 char * output_file )
Paul Bakkere896fea2009-07-06 06:40:23 +0000397{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200398 mbedtls_mpi X, Y;
Paul Bakker69998dd2009-07-11 19:15:20 +0000399 FILE *file_out, *file_in;
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200400 int ret;
Paul Bakker69998dd2009-07-11 19:15:20 +0000401
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200402 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y );
Paul Bakkere896fea2009-07-06 06:40:23 +0000403
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200404 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000405
Paul Bakker33b43f12013-08-20 11:48:36 +0200406 file_out = fopen( output_file, "w" );
Paul Bakker5690efc2011-05-26 13:16:06 +0000407 TEST_ASSERT( file_out != NULL );
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200408 ret = mbedtls_mpi_write_file( NULL, &X, output_radix, file_out );
Paul Bakkere896fea2009-07-06 06:40:23 +0000409 fclose(file_out);
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200410 TEST_ASSERT( ret == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000411
Paul Bakker33b43f12013-08-20 11:48:36 +0200412 file_in = fopen( output_file, "r" );
Paul Bakker5690efc2011-05-26 13:16:06 +0000413 TEST_ASSERT( file_in != NULL );
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200414 ret = mbedtls_mpi_read_file( &Y, output_radix, file_in );
Paul Bakkere896fea2009-07-06 06:40:23 +0000415 fclose(file_in);
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200416 TEST_ASSERT( ret == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000417
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200418 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000419
Paul Bakkerbd51b262014-07-10 15:26:12 +0200420exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200421 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y );
Paul Bakkere896fea2009-07-06 06:40:23 +0000422}
Paul Bakker33b43f12013-08-20 11:48:36 +0200423/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000424
Paul Bakker33b43f12013-08-20 11:48:36 +0200425/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100426void mbedtls_mpi_get_bit( int radix_X, char * input_X, int pos, int val )
Paul Bakker2f5947e2011-05-18 15:47:11 +0000427{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200428 mbedtls_mpi X;
429 mbedtls_mpi_init( &X );
430 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
431 TEST_ASSERT( mbedtls_mpi_get_bit( &X, pos ) == val );
Paul Bakker2f5947e2011-05-18 15:47:11 +0000432
Paul Bakkerbd51b262014-07-10 15:26:12 +0200433exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200434 mbedtls_mpi_free( &X );
Paul Bakker2f5947e2011-05-18 15:47:11 +0000435}
Paul Bakker33b43f12013-08-20 11:48:36 +0200436/* END_CASE */
Paul Bakker2f5947e2011-05-18 15:47:11 +0000437
Paul Bakker33b43f12013-08-20 11:48:36 +0200438/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100439void mbedtls_mpi_set_bit( int radix_X, char * input_X, int pos, int val,
440 int radix_Y, char * output_Y, int result )
Paul Bakker2f5947e2011-05-18 15:47:11 +0000441{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200442 mbedtls_mpi X, Y;
443 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y );
Paul Bakker2f5947e2011-05-18 15:47:11 +0000444
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200445 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
446 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, output_Y ) == 0 );
Paul Bakkerec5ceb62016-07-14 12:47:07 +0100447 TEST_ASSERT( mbedtls_mpi_set_bit( &X, pos, val ) == result );
448
449 if( result == 0 )
450 {
451 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) == 0 );
452 }
Paul Bakker2f5947e2011-05-18 15:47:11 +0000453
Paul Bakkerbd51b262014-07-10 15:26:12 +0200454exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200455 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y );
Paul Bakker2f5947e2011-05-18 15:47:11 +0000456}
Paul Bakker33b43f12013-08-20 11:48:36 +0200457/* END_CASE */
Paul Bakker2f5947e2011-05-18 15:47:11 +0000458
Paul Bakker33b43f12013-08-20 11:48:36 +0200459/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100460void mbedtls_mpi_lsb( int radix_X, char * input_X, int nr_bits )
Paul Bakkere896fea2009-07-06 06:40:23 +0000461{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200462 mbedtls_mpi X;
463 mbedtls_mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000464
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200465 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
466 TEST_ASSERT( mbedtls_mpi_lsb( &X ) == (size_t) nr_bits );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000467
Paul Bakkerbd51b262014-07-10 15:26:12 +0200468exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200469 mbedtls_mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000470}
Paul Bakker33b43f12013-08-20 11:48:36 +0200471/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000472
Paul Bakker33b43f12013-08-20 11:48:36 +0200473/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100474void mbedtls_mpi_bitlen( int radix_X, char * input_X, int nr_bits )
Paul Bakkere896fea2009-07-06 06:40:23 +0000475{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200476 mbedtls_mpi X;
477 mbedtls_mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000478
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200479 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
Manuel Pégourié-Gonnardc0696c22015-06-18 16:47:17 +0200480 TEST_ASSERT( mbedtls_mpi_bitlen( &X ) == (size_t) nr_bits );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000481
Paul Bakkerbd51b262014-07-10 15:26:12 +0200482exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200483 mbedtls_mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000484}
Paul Bakker33b43f12013-08-20 11:48:36 +0200485/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000486
Paul Bakker33b43f12013-08-20 11:48:36 +0200487/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100488void mbedtls_mpi_gcd( int radix_X, char * input_X, int radix_Y,
489 char * input_Y, int radix_A, char * input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000490{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200491 mbedtls_mpi A, X, Y, Z;
492 mbedtls_mpi_init( &A ); mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z );
Paul Bakker367dae42009-06-28 21:50:27 +0000493
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200494 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
495 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
496 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
497 TEST_ASSERT( mbedtls_mpi_gcd( &Z, &X, &Y ) == 0 );
498 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000499
Paul Bakkerbd51b262014-07-10 15:26:12 +0200500exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200501 mbedtls_mpi_free( &A ); mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z );
Paul Bakker367dae42009-06-28 21:50:27 +0000502}
Paul Bakker33b43f12013-08-20 11:48:36 +0200503/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000504
Paul Bakker33b43f12013-08-20 11:48:36 +0200505/* BEGIN_CASE */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200506void mbedtls_mpi_cmp_int( int input_X, int input_A, int result_CMP )
Paul Bakker367dae42009-06-28 21:50:27 +0000507{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200508 mbedtls_mpi X;
509 mbedtls_mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000510
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200511 TEST_ASSERT( mbedtls_mpi_lset( &X, input_X ) == 0);
512 TEST_ASSERT( mbedtls_mpi_cmp_int( &X, input_A ) == result_CMP);
Paul Bakker6c591fa2011-05-05 11:49:20 +0000513
Paul Bakkerbd51b262014-07-10 15:26:12 +0200514exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200515 mbedtls_mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000516}
Paul Bakker33b43f12013-08-20 11:48:36 +0200517/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000518
Paul Bakker33b43f12013-08-20 11:48:36 +0200519/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100520void mbedtls_mpi_cmp_mpi( int radix_X, char * input_X, int radix_Y,
521 char * input_Y, int input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000522{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200523 mbedtls_mpi X, Y;
524 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y );
Paul Bakker367dae42009-06-28 21:50:27 +0000525
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200526 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
527 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
528 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) == input_A );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000529
Paul Bakkerbd51b262014-07-10 15:26:12 +0200530exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200531 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y );
Paul Bakker367dae42009-06-28 21:50:27 +0000532}
Paul Bakker33b43f12013-08-20 11:48:36 +0200533/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000534
Paul Bakker33b43f12013-08-20 11:48:36 +0200535/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100536void mbedtls_mpi_cmp_abs( int radix_X, char * input_X, int radix_Y,
537 char * input_Y, int input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000538{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200539 mbedtls_mpi X, Y;
540 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y );
Paul Bakker367dae42009-06-28 21:50:27 +0000541
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200542 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
543 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
544 TEST_ASSERT( mbedtls_mpi_cmp_abs( &X, &Y ) == input_A );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000545
Paul Bakkerbd51b262014-07-10 15:26:12 +0200546exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200547 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y );
Paul Bakker367dae42009-06-28 21:50:27 +0000548}
Paul Bakker33b43f12013-08-20 11:48:36 +0200549/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000550
Paul Bakker33b43f12013-08-20 11:48:36 +0200551/* BEGIN_CASE */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200552void mbedtls_mpi_copy( int input_X, int input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000553{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200554 mbedtls_mpi X, Y, A;
555 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000556
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200557 TEST_ASSERT( mbedtls_mpi_lset( &X, input_X ) == 0 );
558 TEST_ASSERT( mbedtls_mpi_lset( &Y, input_A ) == 0 );
559 TEST_ASSERT( mbedtls_mpi_lset( &A, input_A ) == 0 );
560 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) != 0 );
561 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Y, &A ) == 0 );
562 TEST_ASSERT( mbedtls_mpi_copy( &Y, &X ) == 0 );
563 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) == 0 );
564 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Y, &A ) != 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000565
Paul Bakkerbd51b262014-07-10 15:26:12 +0200566exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200567 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000568}
Paul Bakker33b43f12013-08-20 11:48:36 +0200569/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000570
Paul Bakker33b43f12013-08-20 11:48:36 +0200571/* BEGIN_CASE */
572void mpi_copy_self( int input_X )
Paul Bakkere896fea2009-07-06 06:40:23 +0000573{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200574 mbedtls_mpi X;
575 mbedtls_mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000576
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200577 TEST_ASSERT( mbedtls_mpi_lset( &X, input_X ) == 0 );
578 TEST_ASSERT( mbedtls_mpi_copy( &X, &X ) == 0 );
579 TEST_ASSERT( mbedtls_mpi_cmp_int( &X, input_X ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000580
Paul Bakkerbd51b262014-07-10 15:26:12 +0200581exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200582 mbedtls_mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000583}
Paul Bakker33b43f12013-08-20 11:48:36 +0200584/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000585
Paul Bakker33b43f12013-08-20 11:48:36 +0200586/* BEGIN_CASE */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200587void mbedtls_mpi_shrink( int before, int used, int min, int after )
Manuel Pégourié-Gonnard58681632013-11-21 10:39:37 +0100588{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200589 mbedtls_mpi X;
590 mbedtls_mpi_init( &X );
Manuel Pégourié-Gonnard58681632013-11-21 10:39:37 +0100591
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200592 TEST_ASSERT( mbedtls_mpi_grow( &X, before ) == 0 );
Manuel Pégourié-Gonnard58681632013-11-21 10:39:37 +0100593 TEST_ASSERT( used <= before );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200594 memset( X.p, 0x2a, used * sizeof( mbedtls_mpi_uint ) );
595 TEST_ASSERT( mbedtls_mpi_shrink( &X, min ) == 0 );
Manuel Pégourié-Gonnard58681632013-11-21 10:39:37 +0100596 TEST_ASSERT( X.n == (size_t) after );
597
Paul Bakkerbd51b262014-07-10 15:26:12 +0200598exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200599 mbedtls_mpi_free( &X );
Manuel Pégourié-Gonnard58681632013-11-21 10:39:37 +0100600}
601/* END_CASE */
602
603/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100604void mbedtls_mpi_safe_cond_assign( int x_sign, char * x_str, int y_sign,
605 char * y_str )
Manuel Pégourié-Gonnard71c2c212013-11-21 16:56:39 +0100606{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200607 mbedtls_mpi X, Y, XX;
608 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &XX );
Manuel Pégourié-Gonnard71c2c212013-11-21 16:56:39 +0100609
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200610 TEST_ASSERT( mbedtls_mpi_read_string( &X, 16, x_str ) == 0 );
Manuel Pégourié-Gonnard3e3d2b82013-11-21 21:12:26 +0100611 X.s = x_sign;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200612 TEST_ASSERT( mbedtls_mpi_read_string( &Y, 16, y_str ) == 0 );
Manuel Pégourié-Gonnard3e3d2b82013-11-21 21:12:26 +0100613 Y.s = y_sign;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200614 TEST_ASSERT( mbedtls_mpi_copy( &XX, &X ) == 0 );
Manuel Pégourié-Gonnard71c2c212013-11-21 16:56:39 +0100615
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200616 TEST_ASSERT( mbedtls_mpi_safe_cond_assign( &X, &Y, 0 ) == 0 );
617 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &XX ) == 0 );
Manuel Pégourié-Gonnard71c2c212013-11-21 16:56:39 +0100618
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200619 TEST_ASSERT( mbedtls_mpi_safe_cond_assign( &X, &Y, 1 ) == 0 );
620 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) == 0 );
Manuel Pégourié-Gonnard71c2c212013-11-21 16:56:39 +0100621
Paul Bakkerbd51b262014-07-10 15:26:12 +0200622exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200623 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &XX );
Manuel Pégourié-Gonnard71c2c212013-11-21 16:56:39 +0100624}
625/* END_CASE */
626
627/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100628void mbedtls_mpi_safe_cond_swap( int x_sign, char * x_str, int y_sign,
629 char * y_str )
Manuel Pégourié-Gonnarda60fe892013-12-04 21:41:50 +0100630{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200631 mbedtls_mpi X, Y, XX, YY;
Manuel Pégourié-Gonnarda60fe892013-12-04 21:41:50 +0100632
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200633 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y );
634 mbedtls_mpi_init( &XX ); mbedtls_mpi_init( &YY );
Manuel Pégourié-Gonnarda60fe892013-12-04 21:41:50 +0100635
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200636 TEST_ASSERT( mbedtls_mpi_read_string( &X, 16, x_str ) == 0 );
Manuel Pégourié-Gonnarda60fe892013-12-04 21:41:50 +0100637 X.s = x_sign;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200638 TEST_ASSERT( mbedtls_mpi_read_string( &Y, 16, y_str ) == 0 );
Manuel Pégourié-Gonnarda60fe892013-12-04 21:41:50 +0100639 Y.s = y_sign;
640
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200641 TEST_ASSERT( mbedtls_mpi_copy( &XX, &X ) == 0 );
642 TEST_ASSERT( mbedtls_mpi_copy( &YY, &Y ) == 0 );
Manuel Pégourié-Gonnarda60fe892013-12-04 21:41:50 +0100643
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200644 TEST_ASSERT( mbedtls_mpi_safe_cond_swap( &X, &Y, 0 ) == 0 );
645 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &XX ) == 0 );
646 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Y, &YY ) == 0 );
Manuel Pégourié-Gonnarda60fe892013-12-04 21:41:50 +0100647
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200648 TEST_ASSERT( mbedtls_mpi_safe_cond_swap( &X, &Y, 1 ) == 0 );
649 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Y, &XX ) == 0 );
650 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &YY ) == 0 );
Manuel Pégourié-Gonnarda60fe892013-12-04 21:41:50 +0100651
Paul Bakkerbd51b262014-07-10 15:26:12 +0200652exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200653 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y );
654 mbedtls_mpi_free( &XX ); mbedtls_mpi_free( &YY );
Manuel Pégourié-Gonnarda60fe892013-12-04 21:41:50 +0100655}
656/* END_CASE */
657
658/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100659void mbedtls_mpi_swap( int input_X, int input_Y )
Paul Bakker367dae42009-06-28 21:50:27 +0000660{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200661 mbedtls_mpi X, Y, A;
662 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000663
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200664 TEST_ASSERT( mbedtls_mpi_lset( &X, input_X ) == 0 );
665 TEST_ASSERT( mbedtls_mpi_lset( &Y, input_Y ) == 0 );
666 TEST_ASSERT( mbedtls_mpi_lset( &A, input_X ) == 0 );
667 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) != 0 );
668 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
669 mbedtls_mpi_swap( &X, &Y );
670 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) != 0 );
671 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Y, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000672
Paul Bakkerbd51b262014-07-10 15:26:12 +0200673exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200674 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000675}
Paul Bakker33b43f12013-08-20 11:48:36 +0200676/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000677
Paul Bakker33b43f12013-08-20 11:48:36 +0200678/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100679void mbedtls_mpi_add_mpi( int radix_X, char * input_X, int radix_Y,
680 char * input_Y, int radix_A, char * input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000681{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200682 mbedtls_mpi X, Y, Z, A;
683 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000684
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200685 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
686 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
687 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
688 TEST_ASSERT( mbedtls_mpi_add_mpi( &Z, &X, &Y ) == 0 );
689 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000690
Paul Bakkerbd51b262014-07-10 15:26:12 +0200691exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200692 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000693}
Paul Bakker33b43f12013-08-20 11:48:36 +0200694/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000695
Paul Bakker33b43f12013-08-20 11:48:36 +0200696/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100697void mbedtls_mpi_add_mpi_inplace( int radix_X, char * input_X, int radix_A,
698 char * input_A )
Janos Follath044a86b2015-10-25 10:58:03 +0100699{
700 mbedtls_mpi X, A;
701 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &A );
702
Janos Follath044a86b2015-10-25 10:58:03 +0100703 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
Janos Follath6cbacec2015-10-25 12:29:13 +0100704
705 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
706 TEST_ASSERT( mbedtls_mpi_sub_abs( &X, &X, &X ) == 0 );
707 TEST_ASSERT( mbedtls_mpi_cmp_int( &X, 0 ) == 0 );
708
709 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
710 TEST_ASSERT( mbedtls_mpi_add_abs( &X, &X, &X ) == 0 );
711 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
712
713 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
Janos Follath044a86b2015-10-25 10:58:03 +0100714 TEST_ASSERT( mbedtls_mpi_add_mpi( &X, &X, &X ) == 0 );
715 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
716
717exit:
718 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &A );
719}
720/* END_CASE */
721
722
723/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100724void mbedtls_mpi_add_abs( int radix_X, char * input_X, int radix_Y,
725 char * input_Y, int radix_A, char * input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000726{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200727 mbedtls_mpi X, Y, Z, A;
728 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000729
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200730 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
731 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
732 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
733 TEST_ASSERT( mbedtls_mpi_add_abs( &Z, &X, &Y ) == 0 );
734 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000735
Paul Bakkerbd51b262014-07-10 15:26:12 +0200736exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200737 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000738}
Paul Bakker33b43f12013-08-20 11:48:36 +0200739/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000740
Paul Bakker33b43f12013-08-20 11:48:36 +0200741/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100742void mpi_add_abs_add_first( int radix_X, char * input_X, int radix_Y,
743 char * input_Y, int radix_A, char * input_A )
Paul Bakkerba48cb22009-07-12 11:01:32 +0000744{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200745 mbedtls_mpi X, Y, A;
746 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000747
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200748 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
749 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
750 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
751 TEST_ASSERT( mbedtls_mpi_add_abs( &X, &X, &Y ) == 0 );
752 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000753
Paul Bakkerbd51b262014-07-10 15:26:12 +0200754exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200755 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000756}
Paul Bakker33b43f12013-08-20 11:48:36 +0200757/* END_CASE */
Paul Bakkerba48cb22009-07-12 11:01:32 +0000758
Paul Bakker33b43f12013-08-20 11:48:36 +0200759/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100760void mpi_add_abs_add_second( int radix_X, char * input_X, int radix_Y,
761 char * input_Y, int radix_A, char * input_A )
Paul Bakkerba48cb22009-07-12 11:01:32 +0000762{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200763 mbedtls_mpi X, Y, A;
764 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000765
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200766 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
767 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
768 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
769 TEST_ASSERT( mbedtls_mpi_add_abs( &Y, &X, &Y ) == 0 );
770 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Y, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000771
Paul Bakkerbd51b262014-07-10 15:26:12 +0200772exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200773 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000774}
Paul Bakker33b43f12013-08-20 11:48:36 +0200775/* END_CASE */
Paul Bakkerba48cb22009-07-12 11:01:32 +0000776
Paul Bakker33b43f12013-08-20 11:48:36 +0200777/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100778void mbedtls_mpi_add_int( int radix_X, char * input_X, int input_Y,
779 int radix_A, char * input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000780{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200781 mbedtls_mpi X, Z, A;
782 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000783
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200784 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
785 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
786 TEST_ASSERT( mbedtls_mpi_add_int( &Z, &X, input_Y ) == 0 );
787 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000788
Paul Bakkerbd51b262014-07-10 15:26:12 +0200789exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200790 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000791}
Paul Bakker33b43f12013-08-20 11:48:36 +0200792/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000793
Paul Bakker33b43f12013-08-20 11:48:36 +0200794/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100795void mbedtls_mpi_sub_mpi( int radix_X, char * input_X, int radix_Y,
796 char * input_Y, int radix_A, char * input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000797{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200798 mbedtls_mpi X, Y, Z, A;
799 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000800
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200801 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
802 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
803 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
804 TEST_ASSERT( mbedtls_mpi_sub_mpi( &Z, &X, &Y ) == 0 );
805 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000806
Paul Bakkerbd51b262014-07-10 15:26:12 +0200807exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200808 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000809}
Paul Bakker33b43f12013-08-20 11:48:36 +0200810/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000811
Paul Bakker33b43f12013-08-20 11:48:36 +0200812/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100813void mbedtls_mpi_sub_abs( int radix_X, char * input_X, int radix_Y,
814 char * input_Y, int radix_A, char * input_A,
815 int sub_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000816{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200817 mbedtls_mpi X, Y, Z, A;
Paul Bakker367dae42009-06-28 21:50:27 +0000818 int res;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200819 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000820
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200821 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
822 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
823 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
Manuel Pégourié-Gonnarde670f902015-10-30 09:23:19 +0100824
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200825 res = mbedtls_mpi_sub_abs( &Z, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200826 TEST_ASSERT( res == sub_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000827 if( res == 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200828 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000829
Paul Bakkerbd51b262014-07-10 15:26:12 +0200830exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200831 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000832}
Paul Bakker33b43f12013-08-20 11:48:36 +0200833/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000834
Paul Bakker33b43f12013-08-20 11:48:36 +0200835/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100836void mbedtls_mpi_sub_int( int radix_X, char * input_X, int input_Y,
837 int radix_A, char * input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000838{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200839 mbedtls_mpi X, Z, A;
840 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000841
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200842 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
843 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
844 TEST_ASSERT( mbedtls_mpi_sub_int( &Z, &X, input_Y ) == 0 );
845 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000846
Paul Bakkerbd51b262014-07-10 15:26:12 +0200847exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200848 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000849}
Paul Bakker33b43f12013-08-20 11:48:36 +0200850/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000851
Paul Bakker33b43f12013-08-20 11:48:36 +0200852/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100853void mbedtls_mpi_mul_mpi( int radix_X, char * input_X, int radix_Y,
854 char * input_Y, int radix_A, char * input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000855{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200856 mbedtls_mpi X, Y, Z, A;
857 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000858
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200859 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
860 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
861 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
862 TEST_ASSERT( mbedtls_mpi_mul_mpi( &Z, &X, &Y ) == 0 );
863 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000864
Paul Bakkerbd51b262014-07-10 15:26:12 +0200865exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200866 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000867}
Paul Bakker33b43f12013-08-20 11:48:36 +0200868/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000869
Paul Bakker33b43f12013-08-20 11:48:36 +0200870/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100871void mbedtls_mpi_mul_int( int radix_X, char * input_X, int input_Y,
872 int radix_A, char * input_A,
873 char * result_comparison )
Paul Bakker367dae42009-06-28 21:50:27 +0000874{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200875 mbedtls_mpi X, Z, A;
876 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000877
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200878 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
879 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
880 TEST_ASSERT( mbedtls_mpi_mul_int( &Z, &X, input_Y ) == 0 );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200881 if( strcmp( result_comparison, "==" ) == 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200882 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200883 else if( strcmp( result_comparison, "!=" ) == 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200884 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) != 0 );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200885 else
886 TEST_ASSERT( "unknown operator" == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000887
Paul Bakkerbd51b262014-07-10 15:26:12 +0200888exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200889 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000890}
Paul Bakker33b43f12013-08-20 11:48:36 +0200891/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000892
Paul Bakker33b43f12013-08-20 11:48:36 +0200893/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100894void mbedtls_mpi_div_mpi( int radix_X, char * input_X, int radix_Y,
895 char * input_Y, int radix_A, char * input_A,
896 int radix_B, char * input_B, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000897{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200898 mbedtls_mpi X, Y, Q, R, A, B;
Paul Bakker367dae42009-06-28 21:50:27 +0000899 int res;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200900 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &R );
901 mbedtls_mpi_init( &A ); mbedtls_mpi_init( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000902
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200903 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
904 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
905 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
906 TEST_ASSERT( mbedtls_mpi_read_string( &B, radix_B, input_B ) == 0 );
907 res = mbedtls_mpi_div_mpi( &Q, &R, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200908 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000909 if( res == 0 )
910 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200911 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Q, &A ) == 0 );
912 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R, &B ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000913 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000914
Paul Bakkerbd51b262014-07-10 15:26:12 +0200915exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200916 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &R );
917 mbedtls_mpi_free( &A ); mbedtls_mpi_free( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000918}
Paul Bakker33b43f12013-08-20 11:48:36 +0200919/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000920
Paul Bakker33b43f12013-08-20 11:48:36 +0200921/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100922void mbedtls_mpi_div_int( int radix_X, char * input_X, int input_Y,
923 int radix_A, char * input_A, int radix_B,
924 char * input_B, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000925{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200926 mbedtls_mpi X, Q, R, A, B;
Paul Bakker367dae42009-06-28 21:50:27 +0000927 int res;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200928 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &R ); mbedtls_mpi_init( &A );
929 mbedtls_mpi_init( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000930
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200931 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
932 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
933 TEST_ASSERT( mbedtls_mpi_read_string( &B, radix_B, input_B ) == 0 );
934 res = mbedtls_mpi_div_int( &Q, &R, &X, input_Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200935 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000936 if( res == 0 )
937 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200938 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Q, &A ) == 0 );
939 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R, &B ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000940 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000941
Paul Bakkerbd51b262014-07-10 15:26:12 +0200942exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200943 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &R ); mbedtls_mpi_free( &A );
944 mbedtls_mpi_free( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000945}
Paul Bakker33b43f12013-08-20 11:48:36 +0200946/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000947
Paul Bakker33b43f12013-08-20 11:48:36 +0200948/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100949void mbedtls_mpi_mod_mpi( int radix_X, char * input_X, int radix_Y,
950 char * input_Y, int radix_A, char * input_A,
951 int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000952{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200953 mbedtls_mpi X, Y, A;
Paul Bakker367dae42009-06-28 21:50:27 +0000954 int res;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200955 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000956
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200957 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
958 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
959 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
960 res = mbedtls_mpi_mod_mpi( &X, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200961 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000962 if( res == 0 )
963 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200964 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000965 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000966
Paul Bakkerbd51b262014-07-10 15:26:12 +0200967exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200968 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000969}
Paul Bakker33b43f12013-08-20 11:48:36 +0200970/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000971
Paul Bakker33b43f12013-08-20 11:48:36 +0200972/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100973void mbedtls_mpi_mod_int( int radix_X, char * input_X, int input_Y,
974 int input_A, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000975{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200976 mbedtls_mpi X;
Paul Bakker367dae42009-06-28 21:50:27 +0000977 int res;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200978 mbedtls_mpi_uint r;
979 mbedtls_mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000980
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200981 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
982 res = mbedtls_mpi_mod_int( &r, &X, input_Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200983 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000984 if( res == 0 )
985 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200986 TEST_ASSERT( r == (mbedtls_mpi_uint) input_A );
Paul Bakker367dae42009-06-28 21:50:27 +0000987 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000988
Paul Bakkerbd51b262014-07-10 15:26:12 +0200989exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200990 mbedtls_mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000991}
Paul Bakker33b43f12013-08-20 11:48:36 +0200992/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000993
Paul Bakker33b43f12013-08-20 11:48:36 +0200994/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100995void mbedtls_mpi_exp_mod( int radix_A, char * input_A, int radix_E,
996 char * input_E, int radix_N, char * input_N,
997 int radix_RR, char * input_RR, int radix_X,
998 char * input_X, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000999{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001000 mbedtls_mpi A, E, N, RR, Z, X;
Paul Bakker367dae42009-06-28 21:50:27 +00001001 int res;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001002 mbedtls_mpi_init( &A ); mbedtls_mpi_init( &E ); mbedtls_mpi_init( &N );
1003 mbedtls_mpi_init( &RR ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +00001004
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001005 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
1006 TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
1007 TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
1008 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +00001009
Paul Bakker33b43f12013-08-20 11:48:36 +02001010 if( strlen( input_RR ) )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001011 TEST_ASSERT( mbedtls_mpi_read_string( &RR, radix_RR, input_RR ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +00001012
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001013 res = mbedtls_mpi_exp_mod( &Z, &A, &E, &N, &RR );
Paul Bakker33b43f12013-08-20 11:48:36 +02001014 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +00001015 if( res == 0 )
1016 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001017 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &X ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +00001018 }
Paul Bakker6c591fa2011-05-05 11:49:20 +00001019
Paul Bakkerbd51b262014-07-10 15:26:12 +02001020exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001021 mbedtls_mpi_free( &A ); mbedtls_mpi_free( &E ); mbedtls_mpi_free( &N );
1022 mbedtls_mpi_free( &RR ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +00001023}
Paul Bakker33b43f12013-08-20 11:48:36 +02001024/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +00001025
Paul Bakker33b43f12013-08-20 11:48:36 +02001026/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +01001027void mbedtls_mpi_inv_mod( int radix_X, char * input_X, int radix_Y,
1028 char * input_Y, int radix_A, char * input_A,
1029 int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +00001030{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001031 mbedtls_mpi X, Y, Z, A;
Paul Bakker367dae42009-06-28 21:50:27 +00001032 int res;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001033 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +00001034
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001035 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
1036 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
1037 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
1038 res = mbedtls_mpi_inv_mod( &Z, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +02001039 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +00001040 if( res == 0 )
1041 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001042 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +00001043 }
Paul Bakker6c591fa2011-05-05 11:49:20 +00001044
Paul Bakkerbd51b262014-07-10 15:26:12 +02001045exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001046 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +00001047}
Paul Bakker33b43f12013-08-20 11:48:36 +02001048/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +00001049
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001050/* BEGIN_CASE depends_on:MBEDTLS_GENPRIME */
Azim Khanf1aaec92017-05-30 14:23:15 +01001051void mbedtls_mpi_is_prime( int radix_X, char * input_X, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +00001052{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001053 mbedtls_mpi X;
Paul Bakker367dae42009-06-28 21:50:27 +00001054 int res;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001055 mbedtls_mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +00001056
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001057 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
Janos Follatha0b67c22018-09-18 14:48:23 +01001058 res = mbedtls_mpi_is_prime_ext( &X, 40, rnd_std_rand, NULL );
Paul Bakker33b43f12013-08-20 11:48:36 +02001059 TEST_ASSERT( res == div_result );
Paul Bakker6c591fa2011-05-05 11:49:20 +00001060
Paul Bakkerbd51b262014-07-10 15:26:12 +02001061exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001062 mbedtls_mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +00001063}
Paul Bakker33b43f12013-08-20 11:48:36 +02001064/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +00001065
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001066/* BEGIN_CASE depends_on:MBEDTLS_GENPRIME */
Janos Follath64eca052018-09-05 17:04:49 +01001067void mbedtls_mpi_is_prime_det( data_t * input_X, data_t * witnesses,
Darryl Greenac2ead02018-10-02 15:30:39 +01001068 int chunk_len, int rounds )
Janos Follath64eca052018-09-05 17:04:49 +01001069{
1070 mbedtls_mpi X;
1071 int res;
1072 mbedtls_test_mpi_random rand;
1073
1074 mbedtls_mpi_init( &X );
1075 rand.data = witnesses;
1076 rand.pos = 0;
1077 rand.chunk_len = chunk_len;
1078
1079 TEST_ASSERT( mbedtls_mpi_read_binary( &X, input_X->x, input_X->len ) == 0 );
Darryl Greenac2ead02018-10-02 15:30:39 +01001080 res = mbedtls_mpi_is_prime_ext( &X, rounds - 1,
1081 mbedtls_test_mpi_miller_rabin_determinizer,
1082 &rand );
1083 TEST_ASSERT( res == 0 );
1084
1085 rand.data = witnesses;
1086 rand.pos = 0;
1087 rand.chunk_len = chunk_len;
1088
Janos Follatha0b67c22018-09-18 14:48:23 +01001089 res = mbedtls_mpi_is_prime_ext( &X, rounds,
1090 mbedtls_test_mpi_miller_rabin_determinizer,
Janos Follath64eca052018-09-05 17:04:49 +01001091 &rand );
Darryl Greenac2ead02018-10-02 15:30:39 +01001092 TEST_ASSERT( res == MBEDTLS_ERR_MPI_NOT_ACCEPTABLE );
Janos Follath64eca052018-09-05 17:04:49 +01001093
1094exit:
1095 mbedtls_mpi_free( &X );
1096}
1097/* END_CASE */
1098
1099/* BEGIN_CASE depends_on:MBEDTLS_GENPRIME */
Janos Follatha3cb7eb2018-08-14 15:31:54 +01001100void mbedtls_mpi_gen_prime( int bits, int flags, int ref_ret )
Manuel Pégourié-Gonnard15f58a82014-06-16 17:12:40 +02001101{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001102 mbedtls_mpi X;
Manuel Pégourié-Gonnard15f58a82014-06-16 17:12:40 +02001103 int my_ret;
1104
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001105 mbedtls_mpi_init( &X );
Manuel Pégourié-Gonnard15f58a82014-06-16 17:12:40 +02001106
Janos Follatha3cb7eb2018-08-14 15:31:54 +01001107 my_ret = mbedtls_mpi_gen_prime( &X, bits, flags, rnd_std_rand, NULL );
Manuel Pégourié-Gonnard15f58a82014-06-16 17:12:40 +02001108 TEST_ASSERT( my_ret == ref_ret );
1109
1110 if( ref_ret == 0 )
1111 {
Manuel Pégourié-Gonnardc0696c22015-06-18 16:47:17 +02001112 size_t actual_bits = mbedtls_mpi_bitlen( &X );
Manuel Pégourié-Gonnard15f58a82014-06-16 17:12:40 +02001113
1114 TEST_ASSERT( actual_bits >= (size_t) bits );
1115 TEST_ASSERT( actual_bits <= (size_t) bits + 1 );
1116
Janos Follatha0b67c22018-09-18 14:48:23 +01001117 TEST_ASSERT( mbedtls_mpi_is_prime_ext( &X, 40, rnd_std_rand, NULL )
1118 == 0 );
Janos Follatha3cb7eb2018-08-14 15:31:54 +01001119 if( flags & MBEDTLS_MPI_GEN_PRIME_FLAG_DH )
Manuel Pégourié-Gonnard15f58a82014-06-16 17:12:40 +02001120 {
Hanno Beckerd4d60572018-01-10 07:12:01 +00001121 /* X = ( X - 1 ) / 2 */
1122 TEST_ASSERT( mbedtls_mpi_shift_r( &X, 1 ) == 0 );
Janos Follatha0b67c22018-09-18 14:48:23 +01001123 TEST_ASSERT( mbedtls_mpi_is_prime_ext( &X, 40, rnd_std_rand, NULL )
1124 == 0 );
Manuel Pégourié-Gonnard15f58a82014-06-16 17:12:40 +02001125 }
1126 }
1127
Paul Bakkerbd51b262014-07-10 15:26:12 +02001128exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001129 mbedtls_mpi_free( &X );
Manuel Pégourié-Gonnard15f58a82014-06-16 17:12:40 +02001130}
1131/* END_CASE */
1132
Paul Bakker33b43f12013-08-20 11:48:36 +02001133/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +01001134void mbedtls_mpi_shift_l( int radix_X, char * input_X, int shift_X,
1135 int radix_A, char * input_A )
Paul Bakker367dae42009-06-28 21:50:27 +00001136{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001137 mbedtls_mpi X, A;
1138 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +00001139
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001140 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
1141 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
1142 TEST_ASSERT( mbedtls_mpi_shift_l( &X, shift_X ) == 0 );
1143 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +00001144
Paul Bakkerbd51b262014-07-10 15:26:12 +02001145exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001146 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +00001147}
Paul Bakker33b43f12013-08-20 11:48:36 +02001148/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +00001149
Paul Bakker33b43f12013-08-20 11:48:36 +02001150/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +01001151void mbedtls_mpi_shift_r( int radix_X, char * input_X, int shift_X,
1152 int radix_A, char * input_A )
Paul Bakker367dae42009-06-28 21:50:27 +00001153{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001154 mbedtls_mpi X, A;
1155 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +00001156
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001157 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
1158 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
1159 TEST_ASSERT( mbedtls_mpi_shift_r( &X, shift_X ) == 0 );
1160 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +00001161
Paul Bakkerbd51b262014-07-10 15:26:12 +02001162exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001163 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +00001164}
Paul Bakker33b43f12013-08-20 11:48:36 +02001165/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +00001166
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001167/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
Azim Khanf1aaec92017-05-30 14:23:15 +01001168void mpi_selftest( )
Paul Bakkere896fea2009-07-06 06:40:23 +00001169{
Andres AG93012e82016-09-09 09:10:28 +01001170 TEST_ASSERT( mbedtls_mpi_self_test( 1 ) == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +00001171}
Paul Bakker33b43f12013-08-20 11:48:36 +02001172/* END_CASE */