blob: 63e0e9715bb698a375b4860ab89470384b5cd731 [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
Hanno Becker56b661c2018-12-12 13:37:25 +0000260 mbedtls_mpi_free( NULL );
261
Hanno Beckerafb607b2018-12-11 14:27:08 +0000262exit:
263 return;
Hanno Beckerafb607b2018-12-11 14:27:08 +0000264}
265/* END_CASE */
266
Paul Bakker33b43f12013-08-20 11:48:36 +0200267/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100268void mpi_null( )
Manuel Pégourié-Gonnard770b5e12015-04-29 17:02:01 +0200269{
Manuel Pégourié-Gonnardda61ed32015-04-30 10:28:51 +0200270 mbedtls_mpi X, Y, Z;
Manuel Pégourié-Gonnard770b5e12015-04-29 17:02:01 +0200271
Manuel Pégourié-Gonnardda61ed32015-04-30 10:28:51 +0200272 mbedtls_mpi_init( &X );
273 mbedtls_mpi_init( &Y );
274 mbedtls_mpi_init( &Z );
Manuel Pégourié-Gonnard770b5e12015-04-29 17:02:01 +0200275
Manuel Pégourié-Gonnardda61ed32015-04-30 10:28:51 +0200276 TEST_ASSERT( mbedtls_mpi_get_bit( &X, 42 ) == 0 );
277 TEST_ASSERT( mbedtls_mpi_lsb( &X ) == 0 );
Manuel Pégourié-Gonnardc0696c22015-06-18 16:47:17 +0200278 TEST_ASSERT( mbedtls_mpi_bitlen( &X ) == 0 );
Manuel Pégourié-Gonnardda61ed32015-04-30 10:28:51 +0200279 TEST_ASSERT( mbedtls_mpi_size( &X ) == 0 );
Manuel Pégourié-Gonnard770b5e12015-04-29 17:02:01 +0200280
281exit:
Manuel Pégourié-Gonnardda61ed32015-04-30 10:28:51 +0200282 mbedtls_mpi_free( &X );
Manuel Pégourié-Gonnard770b5e12015-04-29 17:02:01 +0200283}
284/* END_CASE */
285
286/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100287void mpi_read_write_string( int radix_X, char * input_X, int radix_A,
288 char * input_A, int output_size, int result_read,
Paul Bakker33b43f12013-08-20 11:48:36 +0200289 int result_write )
Paul Bakker367dae42009-06-28 21:50:27 +0000290{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200291 mbedtls_mpi X;
Paul Bakker367dae42009-06-28 21:50:27 +0000292 char str[1000];
Manuel Pégourié-Gonnardf79b4252015-06-02 15:41:48 +0100293 size_t len;
Paul Bakker367dae42009-06-28 21:50:27 +0000294
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200295 mbedtls_mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000296
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200297 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == result_read );
Paul Bakker33b43f12013-08-20 11:48:36 +0200298 if( result_read == 0 )
Paul Bakkerba48cb22009-07-12 11:01:32 +0000299 {
Manuel Pégourié-Gonnardf79b4252015-06-02 15:41:48 +0100300 TEST_ASSERT( mbedtls_mpi_write_string( &X, radix_A, str, output_size, &len ) == result_write );
Paul Bakker33b43f12013-08-20 11:48:36 +0200301 if( result_write == 0 )
Paul Bakkerba48cb22009-07-12 11:01:32 +0000302 {
Paul Bakker33b43f12013-08-20 11:48:36 +0200303 TEST_ASSERT( strcasecmp( str, input_A ) == 0 );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000304 }
305 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000306
Paul Bakkerbd51b262014-07-10 15:26:12 +0200307exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200308 mbedtls_mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000309}
Paul Bakker33b43f12013-08-20 11:48:36 +0200310/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000311
Paul Bakker33b43f12013-08-20 11:48:36 +0200312/* BEGIN_CASE */
Azim Khan5fcca462018-06-29 11:05:32 +0100313void mbedtls_mpi_read_binary( data_t * buf, int radix_A, char * input_A )
Paul Bakkere896fea2009-07-06 06:40:23 +0000314{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200315 mbedtls_mpi X;
Paul Bakkere896fea2009-07-06 06:40:23 +0000316 unsigned char str[1000];
Manuel Pégourié-Gonnardf79b4252015-06-02 15:41:48 +0100317 size_t len;
Paul Bakkere896fea2009-07-06 06:40:23 +0000318
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200319 mbedtls_mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000320
Paul Bakkere896fea2009-07-06 06:40:23 +0000321
Azim Khand30ca132017-06-09 04:32:58 +0100322 TEST_ASSERT( mbedtls_mpi_read_binary( &X, buf->x, buf->len ) == 0 );
Manuel Pégourié-Gonnardf79b4252015-06-02 15:41:48 +0100323 TEST_ASSERT( mbedtls_mpi_write_string( &X, radix_A, (char *) str, sizeof( str ), &len ) == 0 );
Paul Bakker33b43f12013-08-20 11:48:36 +0200324 TEST_ASSERT( strcmp( (char *) str, input_A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000325
Paul Bakkerbd51b262014-07-10 15:26:12 +0200326exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200327 mbedtls_mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000328}
Paul Bakker33b43f12013-08-20 11:48:36 +0200329/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000330
Paul Bakker33b43f12013-08-20 11:48:36 +0200331/* BEGIN_CASE */
Azim Khand30ca132017-06-09 04:32:58 +0100332void mbedtls_mpi_write_binary( int radix_X, char * input_X,
Azim Khan5fcca462018-06-29 11:05:32 +0100333 data_t * input_A, int output_size,
Azim Khanf1aaec92017-05-30 14:23:15 +0100334 int result )
Paul Bakkere896fea2009-07-06 06:40:23 +0000335{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200336 mbedtls_mpi X;
Paul Bakkere896fea2009-07-06 06:40:23 +0000337 unsigned char buf[1000];
Paul Bakkerf4a3f302011-04-24 15:53:29 +0000338 size_t buflen;
Paul Bakkere896fea2009-07-06 06:40:23 +0000339
340 memset( buf, 0x00, 1000 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000341
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200342 mbedtls_mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000343
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200344 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
Manuel Pégourié-Gonnarde670f902015-10-30 09:23:19 +0100345
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200346 buflen = mbedtls_mpi_size( &X );
Paul Bakker33b43f12013-08-20 11:48:36 +0200347 if( buflen > (size_t) output_size )
348 buflen = (size_t) output_size;
Paul Bakkere896fea2009-07-06 06:40:23 +0000349
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200350 TEST_ASSERT( mbedtls_mpi_write_binary( &X, buf, buflen ) == result );
Paul Bakker33b43f12013-08-20 11:48:36 +0200351 if( result == 0)
Paul Bakkerba48cb22009-07-12 11:01:32 +0000352 {
Paul Bakkere896fea2009-07-06 06:40:23 +0000353
Azim Khand30ca132017-06-09 04:32:58 +0100354 TEST_ASSERT( hexcmp( buf, input_A->x, buflen, input_A->len ) == 0 );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000355 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000356
Paul Bakkerbd51b262014-07-10 15:26:12 +0200357exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200358 mbedtls_mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000359}
Paul Bakker33b43f12013-08-20 11:48:36 +0200360/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000361
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200362/* BEGIN_CASE depends_on:MBEDTLS_FS_IO */
Azim Khand30ca132017-06-09 04:32:58 +0100363void mbedtls_mpi_read_file( int radix_X, char * input_file,
Azim Khan5fcca462018-06-29 11:05:32 +0100364 data_t * input_A, int result )
Paul Bakkere896fea2009-07-06 06:40:23 +0000365{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200366 mbedtls_mpi X;
Paul Bakkere896fea2009-07-06 06:40:23 +0000367 unsigned char buf[1000];
Paul Bakkerf4a3f302011-04-24 15:53:29 +0000368 size_t buflen;
Paul Bakker69998dd2009-07-11 19:15:20 +0000369 FILE *file;
Manuel Pégourié-Gonnarde43187d2015-02-14 16:01:34 +0000370 int ret;
Paul Bakkere896fea2009-07-06 06:40:23 +0000371
372 memset( buf, 0x00, 1000 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000373
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200374 mbedtls_mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000375
Paul Bakker33b43f12013-08-20 11:48:36 +0200376 file = fopen( input_file, "r" );
Paul Bakker8a0c0a92014-04-17 16:08:20 +0200377 TEST_ASSERT( file != NULL );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200378 ret = mbedtls_mpi_read_file( &X, radix_X, file );
Paul Bakkere896fea2009-07-06 06:40:23 +0000379 fclose(file);
Manuel Pégourié-Gonnarde43187d2015-02-14 16:01:34 +0000380 TEST_ASSERT( ret == result );
Paul Bakkere896fea2009-07-06 06:40:23 +0000381
Paul Bakker33b43f12013-08-20 11:48:36 +0200382 if( result == 0 )
Paul Bakkerba48cb22009-07-12 11:01:32 +0000383 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200384 buflen = mbedtls_mpi_size( &X );
385 TEST_ASSERT( mbedtls_mpi_write_binary( &X, buf, buflen ) == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000386
Paul Bakkere896fea2009-07-06 06:40:23 +0000387
Azim Khand30ca132017-06-09 04:32:58 +0100388 TEST_ASSERT( hexcmp( buf, input_A->x, buflen, input_A->len ) == 0 );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000389 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000390
Paul Bakkerbd51b262014-07-10 15:26:12 +0200391exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200392 mbedtls_mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000393}
Paul Bakker33b43f12013-08-20 11:48:36 +0200394/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000395
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200396/* BEGIN_CASE depends_on:MBEDTLS_FS_IO */
Azim Khanf1aaec92017-05-30 14:23:15 +0100397void mbedtls_mpi_write_file( int radix_X, char * input_X, int output_radix,
398 char * output_file )
Paul Bakkere896fea2009-07-06 06:40:23 +0000399{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200400 mbedtls_mpi X, Y;
Paul Bakker69998dd2009-07-11 19:15:20 +0000401 FILE *file_out, *file_in;
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200402 int ret;
Paul Bakker69998dd2009-07-11 19:15:20 +0000403
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200404 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y );
Paul Bakkere896fea2009-07-06 06:40:23 +0000405
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200406 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000407
Paul Bakker33b43f12013-08-20 11:48:36 +0200408 file_out = fopen( output_file, "w" );
Paul Bakker5690efc2011-05-26 13:16:06 +0000409 TEST_ASSERT( file_out != NULL );
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200410 ret = mbedtls_mpi_write_file( NULL, &X, output_radix, file_out );
Paul Bakkere896fea2009-07-06 06:40:23 +0000411 fclose(file_out);
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200412 TEST_ASSERT( ret == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000413
Paul Bakker33b43f12013-08-20 11:48:36 +0200414 file_in = fopen( output_file, "r" );
Paul Bakker5690efc2011-05-26 13:16:06 +0000415 TEST_ASSERT( file_in != NULL );
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200416 ret = mbedtls_mpi_read_file( &Y, output_radix, file_in );
Paul Bakkere896fea2009-07-06 06:40:23 +0000417 fclose(file_in);
Manuel Pégourié-Gonnardac5361f2015-06-24 01:08:09 +0200418 TEST_ASSERT( ret == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000419
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200420 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000421
Paul Bakkerbd51b262014-07-10 15:26:12 +0200422exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200423 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y );
Paul Bakkere896fea2009-07-06 06:40:23 +0000424}
Paul Bakker33b43f12013-08-20 11:48:36 +0200425/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000426
Paul Bakker33b43f12013-08-20 11:48:36 +0200427/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100428void mbedtls_mpi_get_bit( int radix_X, char * input_X, int pos, int val )
Paul Bakker2f5947e2011-05-18 15:47:11 +0000429{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200430 mbedtls_mpi X;
431 mbedtls_mpi_init( &X );
432 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
433 TEST_ASSERT( mbedtls_mpi_get_bit( &X, pos ) == val );
Paul Bakker2f5947e2011-05-18 15:47:11 +0000434
Paul Bakkerbd51b262014-07-10 15:26:12 +0200435exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200436 mbedtls_mpi_free( &X );
Paul Bakker2f5947e2011-05-18 15:47:11 +0000437}
Paul Bakker33b43f12013-08-20 11:48:36 +0200438/* END_CASE */
Paul Bakker2f5947e2011-05-18 15:47:11 +0000439
Paul Bakker33b43f12013-08-20 11:48:36 +0200440/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100441void mbedtls_mpi_set_bit( int radix_X, char * input_X, int pos, int val,
442 int radix_Y, char * output_Y, int result )
Paul Bakker2f5947e2011-05-18 15:47:11 +0000443{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200444 mbedtls_mpi X, Y;
445 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y );
Paul Bakker2f5947e2011-05-18 15:47:11 +0000446
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200447 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
448 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, output_Y ) == 0 );
Paul Bakkerec5ceb62016-07-14 12:47:07 +0100449 TEST_ASSERT( mbedtls_mpi_set_bit( &X, pos, val ) == result );
450
451 if( result == 0 )
452 {
453 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) == 0 );
454 }
Paul Bakker2f5947e2011-05-18 15:47:11 +0000455
Paul Bakkerbd51b262014-07-10 15:26:12 +0200456exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200457 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y );
Paul Bakker2f5947e2011-05-18 15:47:11 +0000458}
Paul Bakker33b43f12013-08-20 11:48:36 +0200459/* END_CASE */
Paul Bakker2f5947e2011-05-18 15:47:11 +0000460
Paul Bakker33b43f12013-08-20 11:48:36 +0200461/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100462void mbedtls_mpi_lsb( int radix_X, char * input_X, int nr_bits )
Paul Bakkere896fea2009-07-06 06:40:23 +0000463{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200464 mbedtls_mpi X;
465 mbedtls_mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000466
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200467 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
468 TEST_ASSERT( mbedtls_mpi_lsb( &X ) == (size_t) nr_bits );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000469
Paul Bakkerbd51b262014-07-10 15:26:12 +0200470exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200471 mbedtls_mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000472}
Paul Bakker33b43f12013-08-20 11:48:36 +0200473/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000474
Paul Bakker33b43f12013-08-20 11:48:36 +0200475/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100476void mbedtls_mpi_bitlen( int radix_X, char * input_X, int nr_bits )
Paul Bakkere896fea2009-07-06 06:40:23 +0000477{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200478 mbedtls_mpi X;
479 mbedtls_mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000480
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200481 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
Manuel Pégourié-Gonnardc0696c22015-06-18 16:47:17 +0200482 TEST_ASSERT( mbedtls_mpi_bitlen( &X ) == (size_t) nr_bits );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000483
Paul Bakkerbd51b262014-07-10 15:26:12 +0200484exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200485 mbedtls_mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000486}
Paul Bakker33b43f12013-08-20 11:48:36 +0200487/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000488
Paul Bakker33b43f12013-08-20 11:48:36 +0200489/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100490void mbedtls_mpi_gcd( int radix_X, char * input_X, int radix_Y,
491 char * input_Y, int radix_A, char * input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000492{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200493 mbedtls_mpi A, X, Y, Z;
494 mbedtls_mpi_init( &A ); mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z );
Paul Bakker367dae42009-06-28 21:50:27 +0000495
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200496 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
497 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
498 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
499 TEST_ASSERT( mbedtls_mpi_gcd( &Z, &X, &Y ) == 0 );
500 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000501
Paul Bakkerbd51b262014-07-10 15:26:12 +0200502exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200503 mbedtls_mpi_free( &A ); mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z );
Paul Bakker367dae42009-06-28 21:50:27 +0000504}
Paul Bakker33b43f12013-08-20 11:48:36 +0200505/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000506
Paul Bakker33b43f12013-08-20 11:48:36 +0200507/* BEGIN_CASE */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200508void mbedtls_mpi_cmp_int( int input_X, int input_A, int result_CMP )
Paul Bakker367dae42009-06-28 21:50:27 +0000509{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200510 mbedtls_mpi X;
511 mbedtls_mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000512
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200513 TEST_ASSERT( mbedtls_mpi_lset( &X, input_X ) == 0);
514 TEST_ASSERT( mbedtls_mpi_cmp_int( &X, input_A ) == result_CMP);
Paul Bakker6c591fa2011-05-05 11:49:20 +0000515
Paul Bakkerbd51b262014-07-10 15:26:12 +0200516exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200517 mbedtls_mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000518}
Paul Bakker33b43f12013-08-20 11:48:36 +0200519/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000520
Paul Bakker33b43f12013-08-20 11:48:36 +0200521/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100522void mbedtls_mpi_cmp_mpi( int radix_X, char * input_X, int radix_Y,
523 char * input_Y, int input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000524{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200525 mbedtls_mpi X, Y;
526 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y );
Paul Bakker367dae42009-06-28 21:50:27 +0000527
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200528 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
529 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
530 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) == input_A );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000531
Paul Bakkerbd51b262014-07-10 15:26:12 +0200532exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200533 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y );
Paul Bakker367dae42009-06-28 21:50:27 +0000534}
Paul Bakker33b43f12013-08-20 11:48:36 +0200535/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000536
Paul Bakker33b43f12013-08-20 11:48:36 +0200537/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100538void mbedtls_mpi_cmp_abs( int radix_X, char * input_X, int radix_Y,
539 char * input_Y, int input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000540{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200541 mbedtls_mpi X, Y;
542 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y );
Paul Bakker367dae42009-06-28 21:50:27 +0000543
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200544 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
545 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
546 TEST_ASSERT( mbedtls_mpi_cmp_abs( &X, &Y ) == input_A );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000547
Paul Bakkerbd51b262014-07-10 15:26:12 +0200548exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200549 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y );
Paul Bakker367dae42009-06-28 21:50:27 +0000550}
Paul Bakker33b43f12013-08-20 11:48:36 +0200551/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000552
Paul Bakker33b43f12013-08-20 11:48:36 +0200553/* BEGIN_CASE */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200554void mbedtls_mpi_copy( int input_X, int input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000555{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200556 mbedtls_mpi X, Y, A;
557 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000558
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200559 TEST_ASSERT( mbedtls_mpi_lset( &X, input_X ) == 0 );
560 TEST_ASSERT( mbedtls_mpi_lset( &Y, input_A ) == 0 );
561 TEST_ASSERT( mbedtls_mpi_lset( &A, input_A ) == 0 );
562 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) != 0 );
563 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Y, &A ) == 0 );
564 TEST_ASSERT( mbedtls_mpi_copy( &Y, &X ) == 0 );
565 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) == 0 );
566 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Y, &A ) != 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000567
Paul Bakkerbd51b262014-07-10 15:26:12 +0200568exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200569 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000570}
Paul Bakker33b43f12013-08-20 11:48:36 +0200571/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000572
Paul Bakker33b43f12013-08-20 11:48:36 +0200573/* BEGIN_CASE */
574void mpi_copy_self( int input_X )
Paul Bakkere896fea2009-07-06 06:40:23 +0000575{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200576 mbedtls_mpi X;
577 mbedtls_mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000578
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200579 TEST_ASSERT( mbedtls_mpi_lset( &X, input_X ) == 0 );
580 TEST_ASSERT( mbedtls_mpi_copy( &X, &X ) == 0 );
581 TEST_ASSERT( mbedtls_mpi_cmp_int( &X, input_X ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000582
Paul Bakkerbd51b262014-07-10 15:26:12 +0200583exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200584 mbedtls_mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000585}
Paul Bakker33b43f12013-08-20 11:48:36 +0200586/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000587
Paul Bakker33b43f12013-08-20 11:48:36 +0200588/* BEGIN_CASE */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200589void mbedtls_mpi_shrink( int before, int used, int min, int after )
Manuel Pégourié-Gonnard58681632013-11-21 10:39:37 +0100590{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200591 mbedtls_mpi X;
592 mbedtls_mpi_init( &X );
Manuel Pégourié-Gonnard58681632013-11-21 10:39:37 +0100593
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200594 TEST_ASSERT( mbedtls_mpi_grow( &X, before ) == 0 );
Manuel Pégourié-Gonnard58681632013-11-21 10:39:37 +0100595 TEST_ASSERT( used <= before );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200596 memset( X.p, 0x2a, used * sizeof( mbedtls_mpi_uint ) );
597 TEST_ASSERT( mbedtls_mpi_shrink( &X, min ) == 0 );
Manuel Pégourié-Gonnard58681632013-11-21 10:39:37 +0100598 TEST_ASSERT( X.n == (size_t) after );
599
Paul Bakkerbd51b262014-07-10 15:26:12 +0200600exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200601 mbedtls_mpi_free( &X );
Manuel Pégourié-Gonnard58681632013-11-21 10:39:37 +0100602}
603/* END_CASE */
604
605/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100606void mbedtls_mpi_safe_cond_assign( int x_sign, char * x_str, int y_sign,
607 char * y_str )
Manuel Pégourié-Gonnard71c2c212013-11-21 16:56:39 +0100608{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200609 mbedtls_mpi X, Y, XX;
610 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &XX );
Manuel Pégourié-Gonnard71c2c212013-11-21 16:56:39 +0100611
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200612 TEST_ASSERT( mbedtls_mpi_read_string( &X, 16, x_str ) == 0 );
Manuel Pégourié-Gonnard3e3d2b82013-11-21 21:12:26 +0100613 X.s = x_sign;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200614 TEST_ASSERT( mbedtls_mpi_read_string( &Y, 16, y_str ) == 0 );
Manuel Pégourié-Gonnard3e3d2b82013-11-21 21:12:26 +0100615 Y.s = y_sign;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200616 TEST_ASSERT( mbedtls_mpi_copy( &XX, &X ) == 0 );
Manuel Pégourié-Gonnard71c2c212013-11-21 16:56:39 +0100617
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200618 TEST_ASSERT( mbedtls_mpi_safe_cond_assign( &X, &Y, 0 ) == 0 );
619 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &XX ) == 0 );
Manuel Pégourié-Gonnard71c2c212013-11-21 16:56:39 +0100620
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200621 TEST_ASSERT( mbedtls_mpi_safe_cond_assign( &X, &Y, 1 ) == 0 );
622 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) == 0 );
Manuel Pégourié-Gonnard71c2c212013-11-21 16:56:39 +0100623
Paul Bakkerbd51b262014-07-10 15:26:12 +0200624exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200625 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &XX );
Manuel Pégourié-Gonnard71c2c212013-11-21 16:56:39 +0100626}
627/* END_CASE */
628
629/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100630void mbedtls_mpi_safe_cond_swap( int x_sign, char * x_str, int y_sign,
631 char * y_str )
Manuel Pégourié-Gonnarda60fe892013-12-04 21:41:50 +0100632{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200633 mbedtls_mpi X, Y, XX, YY;
Manuel Pégourié-Gonnarda60fe892013-12-04 21:41:50 +0100634
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200635 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y );
636 mbedtls_mpi_init( &XX ); mbedtls_mpi_init( &YY );
Manuel Pégourié-Gonnarda60fe892013-12-04 21:41:50 +0100637
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200638 TEST_ASSERT( mbedtls_mpi_read_string( &X, 16, x_str ) == 0 );
Manuel Pégourié-Gonnarda60fe892013-12-04 21:41:50 +0100639 X.s = x_sign;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200640 TEST_ASSERT( mbedtls_mpi_read_string( &Y, 16, y_str ) == 0 );
Manuel Pégourié-Gonnarda60fe892013-12-04 21:41:50 +0100641 Y.s = y_sign;
642
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200643 TEST_ASSERT( mbedtls_mpi_copy( &XX, &X ) == 0 );
644 TEST_ASSERT( mbedtls_mpi_copy( &YY, &Y ) == 0 );
Manuel Pégourié-Gonnarda60fe892013-12-04 21:41:50 +0100645
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200646 TEST_ASSERT( mbedtls_mpi_safe_cond_swap( &X, &Y, 0 ) == 0 );
647 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &XX ) == 0 );
648 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Y, &YY ) == 0 );
Manuel Pégourié-Gonnarda60fe892013-12-04 21:41:50 +0100649
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200650 TEST_ASSERT( mbedtls_mpi_safe_cond_swap( &X, &Y, 1 ) == 0 );
651 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Y, &XX ) == 0 );
652 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &YY ) == 0 );
Manuel Pégourié-Gonnarda60fe892013-12-04 21:41:50 +0100653
Paul Bakkerbd51b262014-07-10 15:26:12 +0200654exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200655 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y );
656 mbedtls_mpi_free( &XX ); mbedtls_mpi_free( &YY );
Manuel Pégourié-Gonnarda60fe892013-12-04 21:41:50 +0100657}
658/* END_CASE */
659
660/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100661void mbedtls_mpi_swap( int input_X, int input_Y )
Paul Bakker367dae42009-06-28 21:50:27 +0000662{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200663 mbedtls_mpi X, Y, A;
664 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000665
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200666 TEST_ASSERT( mbedtls_mpi_lset( &X, input_X ) == 0 );
667 TEST_ASSERT( mbedtls_mpi_lset( &Y, input_Y ) == 0 );
668 TEST_ASSERT( mbedtls_mpi_lset( &A, input_X ) == 0 );
669 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) != 0 );
670 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
671 mbedtls_mpi_swap( &X, &Y );
672 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) != 0 );
673 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Y, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000674
Paul Bakkerbd51b262014-07-10 15:26:12 +0200675exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200676 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000677}
Paul Bakker33b43f12013-08-20 11:48:36 +0200678/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000679
Paul Bakker33b43f12013-08-20 11:48:36 +0200680/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100681void mbedtls_mpi_add_mpi( int radix_X, char * input_X, int radix_Y,
682 char * input_Y, int radix_A, char * input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000683{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200684 mbedtls_mpi X, Y, Z, A;
685 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000686
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200687 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
688 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
689 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
690 TEST_ASSERT( mbedtls_mpi_add_mpi( &Z, &X, &Y ) == 0 );
691 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000692
Paul Bakkerbd51b262014-07-10 15:26:12 +0200693exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200694 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000695}
Paul Bakker33b43f12013-08-20 11:48:36 +0200696/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000697
Paul Bakker33b43f12013-08-20 11:48:36 +0200698/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100699void mbedtls_mpi_add_mpi_inplace( int radix_X, char * input_X, int radix_A,
700 char * input_A )
Janos Follath044a86b2015-10-25 10:58:03 +0100701{
702 mbedtls_mpi X, A;
703 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &A );
704
Janos Follath044a86b2015-10-25 10:58:03 +0100705 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
Janos Follath6cbacec2015-10-25 12:29:13 +0100706
707 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
708 TEST_ASSERT( mbedtls_mpi_sub_abs( &X, &X, &X ) == 0 );
709 TEST_ASSERT( mbedtls_mpi_cmp_int( &X, 0 ) == 0 );
710
711 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
712 TEST_ASSERT( mbedtls_mpi_add_abs( &X, &X, &X ) == 0 );
713 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
714
715 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
Janos Follath044a86b2015-10-25 10:58:03 +0100716 TEST_ASSERT( mbedtls_mpi_add_mpi( &X, &X, &X ) == 0 );
717 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
718
719exit:
720 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &A );
721}
722/* END_CASE */
723
724
725/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100726void mbedtls_mpi_add_abs( int radix_X, char * input_X, int radix_Y,
727 char * input_Y, int radix_A, char * input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000728{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200729 mbedtls_mpi X, Y, Z, A;
730 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000731
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200732 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
733 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
734 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
735 TEST_ASSERT( mbedtls_mpi_add_abs( &Z, &X, &Y ) == 0 );
736 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000737
Paul Bakkerbd51b262014-07-10 15:26:12 +0200738exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200739 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000740}
Paul Bakker33b43f12013-08-20 11:48:36 +0200741/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000742
Paul Bakker33b43f12013-08-20 11:48:36 +0200743/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100744void mpi_add_abs_add_first( int radix_X, char * input_X, int radix_Y,
745 char * input_Y, int radix_A, char * input_A )
Paul Bakkerba48cb22009-07-12 11:01:32 +0000746{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200747 mbedtls_mpi X, Y, A;
748 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000749
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200750 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
751 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
752 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
753 TEST_ASSERT( mbedtls_mpi_add_abs( &X, &X, &Y ) == 0 );
754 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000755
Paul Bakkerbd51b262014-07-10 15:26:12 +0200756exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200757 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000758}
Paul Bakker33b43f12013-08-20 11:48:36 +0200759/* END_CASE */
Paul Bakkerba48cb22009-07-12 11:01:32 +0000760
Paul Bakker33b43f12013-08-20 11:48:36 +0200761/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100762void mpi_add_abs_add_second( int radix_X, char * input_X, int radix_Y,
763 char * input_Y, int radix_A, char * input_A )
Paul Bakkerba48cb22009-07-12 11:01:32 +0000764{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200765 mbedtls_mpi X, Y, A;
766 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000767
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200768 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
769 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
770 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
771 TEST_ASSERT( mbedtls_mpi_add_abs( &Y, &X, &Y ) == 0 );
772 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Y, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000773
Paul Bakkerbd51b262014-07-10 15:26:12 +0200774exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200775 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000776}
Paul Bakker33b43f12013-08-20 11:48:36 +0200777/* END_CASE */
Paul Bakkerba48cb22009-07-12 11:01:32 +0000778
Paul Bakker33b43f12013-08-20 11:48:36 +0200779/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100780void mbedtls_mpi_add_int( int radix_X, char * input_X, int input_Y,
781 int radix_A, char * input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000782{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200783 mbedtls_mpi X, Z, A;
784 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000785
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200786 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
787 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
788 TEST_ASSERT( mbedtls_mpi_add_int( &Z, &X, input_Y ) == 0 );
789 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000790
Paul Bakkerbd51b262014-07-10 15:26:12 +0200791exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200792 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000793}
Paul Bakker33b43f12013-08-20 11:48:36 +0200794/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000795
Paul Bakker33b43f12013-08-20 11:48:36 +0200796/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100797void mbedtls_mpi_sub_mpi( int radix_X, char * input_X, int radix_Y,
798 char * input_Y, int radix_A, char * input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000799{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200800 mbedtls_mpi X, Y, Z, A;
801 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000802
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200803 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
804 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
805 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
806 TEST_ASSERT( mbedtls_mpi_sub_mpi( &Z, &X, &Y ) == 0 );
807 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000808
Paul Bakkerbd51b262014-07-10 15:26:12 +0200809exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200810 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000811}
Paul Bakker33b43f12013-08-20 11:48:36 +0200812/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000813
Paul Bakker33b43f12013-08-20 11:48:36 +0200814/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100815void mbedtls_mpi_sub_abs( int radix_X, char * input_X, int radix_Y,
816 char * input_Y, int radix_A, char * input_A,
817 int sub_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000818{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200819 mbedtls_mpi X, Y, Z, A;
Paul Bakker367dae42009-06-28 21:50:27 +0000820 int res;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200821 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000822
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200823 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
824 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
825 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
Manuel Pégourié-Gonnarde670f902015-10-30 09:23:19 +0100826
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200827 res = mbedtls_mpi_sub_abs( &Z, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200828 TEST_ASSERT( res == sub_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000829 if( res == 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200830 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000831
Paul Bakkerbd51b262014-07-10 15:26:12 +0200832exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200833 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000834}
Paul Bakker33b43f12013-08-20 11:48:36 +0200835/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000836
Paul Bakker33b43f12013-08-20 11:48:36 +0200837/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100838void mbedtls_mpi_sub_int( int radix_X, char * input_X, int input_Y,
839 int radix_A, char * input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000840{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200841 mbedtls_mpi X, Z, A;
842 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000843
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200844 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
845 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
846 TEST_ASSERT( mbedtls_mpi_sub_int( &Z, &X, input_Y ) == 0 );
847 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000848
Paul Bakkerbd51b262014-07-10 15:26:12 +0200849exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200850 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000851}
Paul Bakker33b43f12013-08-20 11:48:36 +0200852/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000853
Paul Bakker33b43f12013-08-20 11:48:36 +0200854/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100855void mbedtls_mpi_mul_mpi( int radix_X, char * input_X, int radix_Y,
856 char * input_Y, int radix_A, char * input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000857{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200858 mbedtls_mpi X, Y, Z, A;
859 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000860
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200861 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
862 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
863 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
864 TEST_ASSERT( mbedtls_mpi_mul_mpi( &Z, &X, &Y ) == 0 );
865 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000866
Paul Bakkerbd51b262014-07-10 15:26:12 +0200867exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200868 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000869}
Paul Bakker33b43f12013-08-20 11:48:36 +0200870/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000871
Paul Bakker33b43f12013-08-20 11:48:36 +0200872/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100873void mbedtls_mpi_mul_int( int radix_X, char * input_X, int input_Y,
874 int radix_A, char * input_A,
875 char * result_comparison )
Paul Bakker367dae42009-06-28 21:50:27 +0000876{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200877 mbedtls_mpi X, Z, A;
878 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000879
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200880 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
881 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
882 TEST_ASSERT( mbedtls_mpi_mul_int( &Z, &X, input_Y ) == 0 );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200883 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 if( strcmp( result_comparison, "!=" ) == 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200886 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) != 0 );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200887 else
888 TEST_ASSERT( "unknown operator" == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000889
Paul Bakkerbd51b262014-07-10 15:26:12 +0200890exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200891 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000892}
Paul Bakker33b43f12013-08-20 11:48:36 +0200893/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000894
Paul Bakker33b43f12013-08-20 11:48:36 +0200895/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100896void mbedtls_mpi_div_mpi( int radix_X, char * input_X, int radix_Y,
897 char * input_Y, int radix_A, char * input_A,
898 int radix_B, char * input_B, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000899{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200900 mbedtls_mpi X, Y, Q, R, A, B;
Paul Bakker367dae42009-06-28 21:50:27 +0000901 int res;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200902 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &R );
903 mbedtls_mpi_init( &A ); mbedtls_mpi_init( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000904
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200905 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
906 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
907 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
908 TEST_ASSERT( mbedtls_mpi_read_string( &B, radix_B, input_B ) == 0 );
909 res = mbedtls_mpi_div_mpi( &Q, &R, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200910 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000911 if( res == 0 )
912 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200913 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Q, &A ) == 0 );
914 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R, &B ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000915 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000916
Paul Bakkerbd51b262014-07-10 15:26:12 +0200917exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200918 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &R );
919 mbedtls_mpi_free( &A ); mbedtls_mpi_free( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000920}
Paul Bakker33b43f12013-08-20 11:48:36 +0200921/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000922
Paul Bakker33b43f12013-08-20 11:48:36 +0200923/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100924void mbedtls_mpi_div_int( int radix_X, char * input_X, int input_Y,
925 int radix_A, char * input_A, int radix_B,
926 char * input_B, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000927{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200928 mbedtls_mpi X, Q, R, A, B;
Paul Bakker367dae42009-06-28 21:50:27 +0000929 int res;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200930 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &R ); mbedtls_mpi_init( &A );
931 mbedtls_mpi_init( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000932
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200933 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
934 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
935 TEST_ASSERT( mbedtls_mpi_read_string( &B, radix_B, input_B ) == 0 );
936 res = mbedtls_mpi_div_int( &Q, &R, &X, input_Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200937 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000938 if( res == 0 )
939 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200940 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Q, &A ) == 0 );
941 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R, &B ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000942 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000943
Paul Bakkerbd51b262014-07-10 15:26:12 +0200944exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200945 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &R ); mbedtls_mpi_free( &A );
946 mbedtls_mpi_free( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000947}
Paul Bakker33b43f12013-08-20 11:48:36 +0200948/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000949
Paul Bakker33b43f12013-08-20 11:48:36 +0200950/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100951void mbedtls_mpi_mod_mpi( int radix_X, char * input_X, int radix_Y,
952 char * input_Y, int radix_A, char * input_A,
953 int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000954{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200955 mbedtls_mpi X, Y, A;
Paul Bakker367dae42009-06-28 21:50:27 +0000956 int res;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200957 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000958
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200959 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
960 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
961 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
962 res = mbedtls_mpi_mod_mpi( &X, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200963 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000964 if( res == 0 )
965 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200966 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000967 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000968
Paul Bakkerbd51b262014-07-10 15:26:12 +0200969exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200970 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000971}
Paul Bakker33b43f12013-08-20 11:48:36 +0200972/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000973
Paul Bakker33b43f12013-08-20 11:48:36 +0200974/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100975void mbedtls_mpi_mod_int( int radix_X, char * input_X, int input_Y,
976 int input_A, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000977{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200978 mbedtls_mpi X;
Paul Bakker367dae42009-06-28 21:50:27 +0000979 int res;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200980 mbedtls_mpi_uint r;
981 mbedtls_mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000982
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200983 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
984 res = mbedtls_mpi_mod_int( &r, &X, input_Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200985 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000986 if( res == 0 )
987 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200988 TEST_ASSERT( r == (mbedtls_mpi_uint) input_A );
Paul Bakker367dae42009-06-28 21:50:27 +0000989 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000990
Paul Bakkerbd51b262014-07-10 15:26:12 +0200991exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200992 mbedtls_mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000993}
Paul Bakker33b43f12013-08-20 11:48:36 +0200994/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000995
Paul Bakker33b43f12013-08-20 11:48:36 +0200996/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +0100997void mbedtls_mpi_exp_mod( int radix_A, char * input_A, int radix_E,
998 char * input_E, int radix_N, char * input_N,
999 int radix_RR, char * input_RR, int radix_X,
1000 char * input_X, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +00001001{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001002 mbedtls_mpi A, E, N, RR, Z, X;
Paul Bakker367dae42009-06-28 21:50:27 +00001003 int res;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001004 mbedtls_mpi_init( &A ); mbedtls_mpi_init( &E ); mbedtls_mpi_init( &N );
1005 mbedtls_mpi_init( &RR ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +00001006
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001007 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
1008 TEST_ASSERT( mbedtls_mpi_read_string( &E, radix_E, input_E ) == 0 );
1009 TEST_ASSERT( mbedtls_mpi_read_string( &N, radix_N, input_N ) == 0 );
1010 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +00001011
Paul Bakker33b43f12013-08-20 11:48:36 +02001012 if( strlen( input_RR ) )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001013 TEST_ASSERT( mbedtls_mpi_read_string( &RR, radix_RR, input_RR ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +00001014
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001015 res = mbedtls_mpi_exp_mod( &Z, &A, &E, &N, &RR );
Paul Bakker33b43f12013-08-20 11:48:36 +02001016 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +00001017 if( res == 0 )
1018 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001019 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &X ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +00001020 }
Paul Bakker6c591fa2011-05-05 11:49:20 +00001021
Paul Bakkerbd51b262014-07-10 15:26:12 +02001022exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001023 mbedtls_mpi_free( &A ); mbedtls_mpi_free( &E ); mbedtls_mpi_free( &N );
1024 mbedtls_mpi_free( &RR ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +00001025}
Paul Bakker33b43f12013-08-20 11:48:36 +02001026/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +00001027
Paul Bakker33b43f12013-08-20 11:48:36 +02001028/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +01001029void mbedtls_mpi_inv_mod( int radix_X, char * input_X, int radix_Y,
1030 char * input_Y, int radix_A, char * input_A,
1031 int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +00001032{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001033 mbedtls_mpi X, Y, Z, A;
Paul Bakker367dae42009-06-28 21:50:27 +00001034 int res;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001035 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +00001036
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001037 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
1038 TEST_ASSERT( mbedtls_mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
1039 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
1040 res = mbedtls_mpi_inv_mod( &Z, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +02001041 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +00001042 if( res == 0 )
1043 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001044 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +00001045 }
Paul Bakker6c591fa2011-05-05 11:49:20 +00001046
Paul Bakkerbd51b262014-07-10 15:26:12 +02001047exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001048 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +00001049}
Paul Bakker33b43f12013-08-20 11:48:36 +02001050/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +00001051
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001052/* BEGIN_CASE depends_on:MBEDTLS_GENPRIME */
Azim Khanf1aaec92017-05-30 14:23:15 +01001053void mbedtls_mpi_is_prime( int radix_X, char * input_X, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +00001054{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001055 mbedtls_mpi X;
Paul Bakker367dae42009-06-28 21:50:27 +00001056 int res;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001057 mbedtls_mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +00001058
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001059 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
Janos Follatha0b67c22018-09-18 14:48:23 +01001060 res = mbedtls_mpi_is_prime_ext( &X, 40, rnd_std_rand, NULL );
Paul Bakker33b43f12013-08-20 11:48:36 +02001061 TEST_ASSERT( res == div_result );
Paul Bakker6c591fa2011-05-05 11:49:20 +00001062
Paul Bakkerbd51b262014-07-10 15:26:12 +02001063exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001064 mbedtls_mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +00001065}
Paul Bakker33b43f12013-08-20 11:48:36 +02001066/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +00001067
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001068/* BEGIN_CASE depends_on:MBEDTLS_GENPRIME */
Janos Follath64eca052018-09-05 17:04:49 +01001069void mbedtls_mpi_is_prime_det( data_t * input_X, data_t * witnesses,
Darryl Greenac2ead02018-10-02 15:30:39 +01001070 int chunk_len, int rounds )
Janos Follath64eca052018-09-05 17:04:49 +01001071{
1072 mbedtls_mpi X;
1073 int res;
1074 mbedtls_test_mpi_random rand;
1075
1076 mbedtls_mpi_init( &X );
1077 rand.data = witnesses;
1078 rand.pos = 0;
1079 rand.chunk_len = chunk_len;
1080
1081 TEST_ASSERT( mbedtls_mpi_read_binary( &X, input_X->x, input_X->len ) == 0 );
Darryl Greenac2ead02018-10-02 15:30:39 +01001082 res = mbedtls_mpi_is_prime_ext( &X, rounds - 1,
1083 mbedtls_test_mpi_miller_rabin_determinizer,
1084 &rand );
1085 TEST_ASSERT( res == 0 );
1086
1087 rand.data = witnesses;
1088 rand.pos = 0;
1089 rand.chunk_len = chunk_len;
1090
Janos Follatha0b67c22018-09-18 14:48:23 +01001091 res = mbedtls_mpi_is_prime_ext( &X, rounds,
1092 mbedtls_test_mpi_miller_rabin_determinizer,
Janos Follath64eca052018-09-05 17:04:49 +01001093 &rand );
Darryl Greenac2ead02018-10-02 15:30:39 +01001094 TEST_ASSERT( res == MBEDTLS_ERR_MPI_NOT_ACCEPTABLE );
Janos Follath64eca052018-09-05 17:04:49 +01001095
1096exit:
1097 mbedtls_mpi_free( &X );
1098}
1099/* END_CASE */
1100
1101/* BEGIN_CASE depends_on:MBEDTLS_GENPRIME */
Janos Follatha3cb7eb2018-08-14 15:31:54 +01001102void mbedtls_mpi_gen_prime( int bits, int flags, int ref_ret )
Manuel Pégourié-Gonnard15f58a82014-06-16 17:12:40 +02001103{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001104 mbedtls_mpi X;
Manuel Pégourié-Gonnard15f58a82014-06-16 17:12:40 +02001105 int my_ret;
1106
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001107 mbedtls_mpi_init( &X );
Manuel Pégourié-Gonnard15f58a82014-06-16 17:12:40 +02001108
Janos Follatha3cb7eb2018-08-14 15:31:54 +01001109 my_ret = mbedtls_mpi_gen_prime( &X, bits, flags, rnd_std_rand, NULL );
Manuel Pégourié-Gonnard15f58a82014-06-16 17:12:40 +02001110 TEST_ASSERT( my_ret == ref_ret );
1111
1112 if( ref_ret == 0 )
1113 {
Manuel Pégourié-Gonnardc0696c22015-06-18 16:47:17 +02001114 size_t actual_bits = mbedtls_mpi_bitlen( &X );
Manuel Pégourié-Gonnard15f58a82014-06-16 17:12:40 +02001115
1116 TEST_ASSERT( actual_bits >= (size_t) bits );
1117 TEST_ASSERT( actual_bits <= (size_t) bits + 1 );
1118
Janos Follatha0b67c22018-09-18 14:48:23 +01001119 TEST_ASSERT( mbedtls_mpi_is_prime_ext( &X, 40, rnd_std_rand, NULL )
1120 == 0 );
Janos Follatha3cb7eb2018-08-14 15:31:54 +01001121 if( flags & MBEDTLS_MPI_GEN_PRIME_FLAG_DH )
Manuel Pégourié-Gonnard15f58a82014-06-16 17:12:40 +02001122 {
Hanno Beckerd4d60572018-01-10 07:12:01 +00001123 /* X = ( X - 1 ) / 2 */
1124 TEST_ASSERT( mbedtls_mpi_shift_r( &X, 1 ) == 0 );
Janos Follatha0b67c22018-09-18 14:48:23 +01001125 TEST_ASSERT( mbedtls_mpi_is_prime_ext( &X, 40, rnd_std_rand, NULL )
1126 == 0 );
Manuel Pégourié-Gonnard15f58a82014-06-16 17:12:40 +02001127 }
1128 }
1129
Paul Bakkerbd51b262014-07-10 15:26:12 +02001130exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001131 mbedtls_mpi_free( &X );
Manuel Pégourié-Gonnard15f58a82014-06-16 17:12:40 +02001132}
1133/* END_CASE */
1134
Paul Bakker33b43f12013-08-20 11:48:36 +02001135/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +01001136void mbedtls_mpi_shift_l( int radix_X, char * input_X, int shift_X,
1137 int radix_A, char * input_A )
Paul Bakker367dae42009-06-28 21:50:27 +00001138{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001139 mbedtls_mpi X, A;
1140 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +00001141
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001142 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
1143 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
1144 TEST_ASSERT( mbedtls_mpi_shift_l( &X, shift_X ) == 0 );
1145 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +00001146
Paul Bakkerbd51b262014-07-10 15:26:12 +02001147exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001148 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +00001149}
Paul Bakker33b43f12013-08-20 11:48:36 +02001150/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +00001151
Paul Bakker33b43f12013-08-20 11:48:36 +02001152/* BEGIN_CASE */
Azim Khanf1aaec92017-05-30 14:23:15 +01001153void mbedtls_mpi_shift_r( int radix_X, char * input_X, int shift_X,
1154 int radix_A, char * input_A )
Paul Bakker367dae42009-06-28 21:50:27 +00001155{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001156 mbedtls_mpi X, A;
1157 mbedtls_mpi_init( &X ); mbedtls_mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +00001158
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001159 TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == 0 );
1160 TEST_ASSERT( mbedtls_mpi_read_string( &A, radix_A, input_A ) == 0 );
1161 TEST_ASSERT( mbedtls_mpi_shift_r( &X, shift_X ) == 0 );
1162 TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +00001163
Paul Bakkerbd51b262014-07-10 15:26:12 +02001164exit:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001165 mbedtls_mpi_free( &X ); mbedtls_mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +00001166}
Paul Bakker33b43f12013-08-20 11:48:36 +02001167/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +00001168
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001169/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
Azim Khanf1aaec92017-05-30 14:23:15 +01001170void mpi_selftest( )
Paul Bakkere896fea2009-07-06 06:40:23 +00001171{
Andres AG93012e82016-09-09 09:10:28 +01001172 TEST_ASSERT( mbedtls_mpi_self_test( 1 ) == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +00001173}
Paul Bakker33b43f12013-08-20 11:48:36 +02001174/* END_CASE */