blob: 620c36851d5e62bb72e6f3c5b0ff2e8eb3363f81 [file] [log] [blame]
Paul Bakker33b43f12013-08-20 11:48:36 +02001/* BEGIN_HEADER */
Paul Bakker367dae42009-06-28 21:50:27 +00002#include <polarssl/bignum.h>
Paul Bakker33b43f12013-08-20 11:48:36 +02003/* END_HEADER */
Paul Bakker367dae42009-06-28 21:50:27 +00004
Paul Bakker33b43f12013-08-20 11:48:36 +02005/* BEGIN_DEPENDENCIES
6 * depends_on:POLARSSL_BIGNUM_C
7 * END_DEPENDENCIES
8 */
Paul Bakker5690efc2011-05-26 13:16:06 +00009
Paul Bakker33b43f12013-08-20 11:48:36 +020010/* BEGIN_CASE */
11void mpi_read_write_string( int radix_X, char *input_X, int radix_A,
12 char *input_A, int output_size, int result_read,
13 int result_write )
Paul Bakker367dae42009-06-28 21:50:27 +000014{
15 mpi X;
16 char str[1000];
Paul Bakker33b43f12013-08-20 11:48:36 +020017 size_t len = output_size;
Paul Bakker367dae42009-06-28 21:50:27 +000018
Paul Bakker6c591fa2011-05-05 11:49:20 +000019 mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +000020
Paul Bakker33b43f12013-08-20 11:48:36 +020021 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == result_read );
22 if( result_read == 0 )
Paul Bakkerba48cb22009-07-12 11:01:32 +000023 {
Paul Bakker33b43f12013-08-20 11:48:36 +020024 TEST_ASSERT( mpi_write_string( &X, radix_A, str, &len ) == result_write );
25 if( result_write == 0 )
Paul Bakkerba48cb22009-07-12 11:01:32 +000026 {
Paul Bakker33b43f12013-08-20 11:48:36 +020027 TEST_ASSERT( strcasecmp( str, input_A ) == 0 );
Paul Bakkerba48cb22009-07-12 11:01:32 +000028 }
29 }
Paul Bakker6c591fa2011-05-05 11:49:20 +000030
31 mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +000032}
Paul Bakker33b43f12013-08-20 11:48:36 +020033/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +000034
Paul Bakker33b43f12013-08-20 11:48:36 +020035/* BEGIN_CASE */
36void mpi_read_binary( char *input_X, int radix_A, char *input_A )
Paul Bakkere896fea2009-07-06 06:40:23 +000037{
38 mpi X;
39 unsigned char str[1000];
40 unsigned char buf[1000];
Paul Bakkerf4a3f302011-04-24 15:53:29 +000041 size_t len = 1000;
42 size_t input_len;
Paul Bakkere896fea2009-07-06 06:40:23 +000043
Paul Bakker6c591fa2011-05-05 11:49:20 +000044 mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +000045
Paul Bakker33b43f12013-08-20 11:48:36 +020046 input_len = unhexify( buf, input_X );
Paul Bakkere896fea2009-07-06 06:40:23 +000047
48 TEST_ASSERT( mpi_read_binary( &X, buf, input_len ) == 0 );
Paul Bakker33b43f12013-08-20 11:48:36 +020049 TEST_ASSERT( mpi_write_string( &X, radix_A, (char *) str, &len ) == 0 );
50 TEST_ASSERT( strcmp( (char *) str, input_A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +000051
52 mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +000053}
Paul Bakker33b43f12013-08-20 11:48:36 +020054/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +000055
Paul Bakker33b43f12013-08-20 11:48:36 +020056/* BEGIN_CASE */
57void mpi_write_binary( int radix_X, char *input_X, char *input_A,
58 int output_size, int result )
Paul Bakkere896fea2009-07-06 06:40:23 +000059{
60 mpi X;
61 unsigned char str[1000];
62 unsigned char buf[1000];
Paul Bakkerf4a3f302011-04-24 15:53:29 +000063 size_t buflen;
Paul Bakkere896fea2009-07-06 06:40:23 +000064
65 memset( buf, 0x00, 1000 );
66 memset( str, 0x00, 1000 );
67
Paul Bakker6c591fa2011-05-05 11:49:20 +000068 mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +000069
Paul Bakker33b43f12013-08-20 11:48:36 +020070 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +000071
Paul Bakker69998dd2009-07-11 19:15:20 +000072 buflen = mpi_size( &X );
Paul Bakker33b43f12013-08-20 11:48:36 +020073 if( buflen > (size_t) output_size )
74 buflen = (size_t) output_size;
Paul Bakkere896fea2009-07-06 06:40:23 +000075
Paul Bakker33b43f12013-08-20 11:48:36 +020076 TEST_ASSERT( mpi_write_binary( &X, buf, buflen ) == result );
77 if( result == 0)
Paul Bakkerba48cb22009-07-12 11:01:32 +000078 {
79 hexify( str, buf, buflen );
Paul Bakkere896fea2009-07-06 06:40:23 +000080
Paul Bakker33b43f12013-08-20 11:48:36 +020081 TEST_ASSERT( strcasecmp( (char *) str, input_A ) == 0 );
Paul Bakkerba48cb22009-07-12 11:01:32 +000082 }
Paul Bakker6c591fa2011-05-05 11:49:20 +000083
84 mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +000085}
Paul Bakker33b43f12013-08-20 11:48:36 +020086/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +000087
Paul Bakker428b9ba2013-09-15 15:20:37 +020088/* BEGIN_CASE depends_on:POLARSSL_FS_IO */
Paul Bakker33b43f12013-08-20 11:48:36 +020089void mpi_read_file( int radix_X, char *input_file, char *input_A,
90 int result )
Paul Bakkere896fea2009-07-06 06:40:23 +000091{
92 mpi X;
93 unsigned char str[1000];
94 unsigned char buf[1000];
Paul Bakkerf4a3f302011-04-24 15:53:29 +000095 size_t buflen;
Paul Bakker69998dd2009-07-11 19:15:20 +000096 FILE *file;
Paul Bakkere896fea2009-07-06 06:40:23 +000097
98 memset( buf, 0x00, 1000 );
99 memset( str, 0x00, 1000 );
100
Paul Bakker6c591fa2011-05-05 11:49:20 +0000101 mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000102
Paul Bakker33b43f12013-08-20 11:48:36 +0200103 file = fopen( input_file, "r" );
104 TEST_ASSERT( mpi_read_file( &X, radix_X, file ) == result );
Paul Bakkere896fea2009-07-06 06:40:23 +0000105 fclose(file);
106
Paul Bakker33b43f12013-08-20 11:48:36 +0200107 if( result == 0 )
Paul Bakkerba48cb22009-07-12 11:01:32 +0000108 {
109 buflen = mpi_size( &X );
110 TEST_ASSERT( mpi_write_binary( &X, buf, buflen ) == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000111
Paul Bakkerba48cb22009-07-12 11:01:32 +0000112 hexify( str, buf, buflen );
Paul Bakkere896fea2009-07-06 06:40:23 +0000113
Paul Bakker33b43f12013-08-20 11:48:36 +0200114 TEST_ASSERT( strcasecmp( (char *) str, input_A ) == 0 );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000115 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000116
117 mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000118}
Paul Bakker33b43f12013-08-20 11:48:36 +0200119/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000120
Paul Bakker428b9ba2013-09-15 15:20:37 +0200121/* BEGIN_CASE depends_on:POLARSSL_FS_IO */
Paul Bakker33b43f12013-08-20 11:48:36 +0200122void mpi_write_file( int radix_X, char *input_X, int output_radix,
123 char *output_file )
Paul Bakkere896fea2009-07-06 06:40:23 +0000124{
125 mpi X, Y;
Paul Bakker69998dd2009-07-11 19:15:20 +0000126 FILE *file_out, *file_in;
127
Paul Bakker6c591fa2011-05-05 11:49:20 +0000128 mpi_init( &X ); mpi_init( &Y );
Paul Bakkere896fea2009-07-06 06:40:23 +0000129
Paul Bakker33b43f12013-08-20 11:48:36 +0200130 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000131
Paul Bakker33b43f12013-08-20 11:48:36 +0200132 file_out = fopen( output_file, "w" );
Paul Bakker5690efc2011-05-26 13:16:06 +0000133 TEST_ASSERT( file_out != NULL );
Paul Bakker33b43f12013-08-20 11:48:36 +0200134 TEST_ASSERT( mpi_write_file( NULL, &X, output_radix, file_out ) == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000135 fclose(file_out);
136
Paul Bakker33b43f12013-08-20 11:48:36 +0200137 file_in = fopen( output_file, "r" );
Paul Bakker5690efc2011-05-26 13:16:06 +0000138 TEST_ASSERT( file_in != NULL );
Paul Bakker33b43f12013-08-20 11:48:36 +0200139 TEST_ASSERT( mpi_read_file( &Y, output_radix, file_in ) == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000140 fclose(file_in);
141
142 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000143
144 mpi_free( &X ); mpi_free( &Y );
Paul Bakkere896fea2009-07-06 06:40:23 +0000145}
Paul Bakker33b43f12013-08-20 11:48:36 +0200146/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000147
Paul Bakker33b43f12013-08-20 11:48:36 +0200148/* BEGIN_CASE */
149void mpi_get_bit( int radix_X, char *input_X, int pos, int val )
Paul Bakker2f5947e2011-05-18 15:47:11 +0000150{
151 mpi X;
152 mpi_init( &X );
Paul Bakker33b43f12013-08-20 11:48:36 +0200153 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
154 TEST_ASSERT( mpi_get_bit( &X, pos ) == val );
Paul Bakker2f5947e2011-05-18 15:47:11 +0000155
156 mpi_free( &X );
157}
Paul Bakker33b43f12013-08-20 11:48:36 +0200158/* END_CASE */
Paul Bakker2f5947e2011-05-18 15:47:11 +0000159
Paul Bakker33b43f12013-08-20 11:48:36 +0200160/* BEGIN_CASE */
161void mpi_set_bit( int radix_X, char *input_X, int pos, int val, int radix_Y,
162 char *output_Y )
Paul Bakker2f5947e2011-05-18 15:47:11 +0000163{
164 mpi X, Y;
165 mpi_init( &X ); mpi_init( &Y );
166
Paul Bakker33b43f12013-08-20 11:48:36 +0200167 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
168 TEST_ASSERT( mpi_read_string( &Y, radix_Y, output_Y ) == 0 );
169 TEST_ASSERT( mpi_set_bit( &X, pos, val ) == 0 );
Paul Bakker2f5947e2011-05-18 15:47:11 +0000170 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == 0 );
171
Manuel Pégourié-Gonnarde44ec102012-11-17 12:42:51 +0100172 mpi_free( &X ); mpi_free( &Y );
Paul Bakker2f5947e2011-05-18 15:47:11 +0000173}
Paul Bakker33b43f12013-08-20 11:48:36 +0200174/* END_CASE */
Paul Bakker2f5947e2011-05-18 15:47:11 +0000175
Paul Bakker33b43f12013-08-20 11:48:36 +0200176/* BEGIN_CASE */
177void mpi_lsb( int radix_X, char *input_X, int nr_bits )
Paul Bakkere896fea2009-07-06 06:40:23 +0000178{
179 mpi X;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000180 mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000181
Paul Bakker33b43f12013-08-20 11:48:36 +0200182 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
183 TEST_ASSERT( mpi_lsb( &X ) == (size_t) nr_bits );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000184
185 mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000186}
Paul Bakker33b43f12013-08-20 11:48:36 +0200187/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000188
Paul Bakker33b43f12013-08-20 11:48:36 +0200189/* BEGIN_CASE */
190void mpi_msb( int radix_X, char *input_X, int nr_bits )
Paul Bakkere896fea2009-07-06 06:40:23 +0000191{
192 mpi X;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000193 mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000194
Paul Bakker33b43f12013-08-20 11:48:36 +0200195 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
196 TEST_ASSERT( mpi_msb( &X ) == (size_t) nr_bits );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000197
198 mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000199}
Paul Bakker33b43f12013-08-20 11:48:36 +0200200/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000201
Paul Bakker33b43f12013-08-20 11:48:36 +0200202/* BEGIN_CASE */
203void mpi_gcd( int radix_X, char *input_X, int radix_Y, char *input_Y,
204 int radix_A, char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000205{
206 mpi A, X, Y, Z;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000207 mpi_init( &A ); mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z );
Paul Bakker367dae42009-06-28 21:50:27 +0000208
Paul Bakker33b43f12013-08-20 11:48:36 +0200209 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
210 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
211 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000212 TEST_ASSERT( mpi_gcd( &Z, &X, &Y ) == 0 );
213 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000214
215 mpi_free( &A ); mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z );
Paul Bakker367dae42009-06-28 21:50:27 +0000216}
Paul Bakker33b43f12013-08-20 11:48:36 +0200217/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000218
Paul Bakker33b43f12013-08-20 11:48:36 +0200219/* BEGIN_CASE */
220void mpi_cmp_int( int input_X, int input_A, int result_CMP )
Paul Bakker367dae42009-06-28 21:50:27 +0000221{
222 mpi X;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000223 mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000224
Paul Bakker33b43f12013-08-20 11:48:36 +0200225 TEST_ASSERT( mpi_lset( &X, input_X ) == 0);
226 TEST_ASSERT( mpi_cmp_int( &X, input_A ) == result_CMP);
Paul Bakker6c591fa2011-05-05 11:49:20 +0000227
228 mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000229}
Paul Bakker33b43f12013-08-20 11:48:36 +0200230/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000231
Paul Bakker33b43f12013-08-20 11:48:36 +0200232/* BEGIN_CASE */
233void mpi_cmp_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
234 int input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000235{
236 mpi X, Y;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000237 mpi_init( &X ); mpi_init( &Y );
Paul Bakker367dae42009-06-28 21:50:27 +0000238
Paul Bakker33b43f12013-08-20 11:48:36 +0200239 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
240 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
241 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == input_A );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000242
243 mpi_free( &X ); mpi_free( &Y );
Paul Bakker367dae42009-06-28 21:50:27 +0000244}
Paul Bakker33b43f12013-08-20 11:48:36 +0200245/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000246
Paul Bakker33b43f12013-08-20 11:48:36 +0200247/* BEGIN_CASE */
248void mpi_cmp_abs( int radix_X, char *input_X, int radix_Y, char *input_Y,
249 int input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000250{
251 mpi X, Y;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000252 mpi_init( &X ); mpi_init( &Y );
Paul Bakker367dae42009-06-28 21:50:27 +0000253
Paul Bakker33b43f12013-08-20 11:48:36 +0200254 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
255 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
256 TEST_ASSERT( mpi_cmp_abs( &X, &Y ) == input_A );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000257
258 mpi_free( &X ); mpi_free( &Y );
Paul Bakker367dae42009-06-28 21:50:27 +0000259}
Paul Bakker33b43f12013-08-20 11:48:36 +0200260/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000261
Paul Bakker33b43f12013-08-20 11:48:36 +0200262/* BEGIN_CASE */
263void mpi_copy( int input_X, int input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000264{
265 mpi X, Y, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000266 mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000267
Paul Bakker33b43f12013-08-20 11:48:36 +0200268 TEST_ASSERT( mpi_lset( &X, input_X ) == 0 );
269 TEST_ASSERT( mpi_lset( &Y, input_A ) == 0 );
270 TEST_ASSERT( mpi_lset( &A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000271 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 );
272 TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) == 0 );
273 TEST_ASSERT( mpi_copy( &Y, &X ) == 0 );
274 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == 0 );
275 TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) != 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000276
277 mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000278}
Paul Bakker33b43f12013-08-20 11:48:36 +0200279/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000280
Paul Bakker33b43f12013-08-20 11:48:36 +0200281/* BEGIN_CASE */
282void mpi_copy_self( int input_X )
Paul Bakkere896fea2009-07-06 06:40:23 +0000283{
284 mpi X;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000285 mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000286
Paul Bakker33b43f12013-08-20 11:48:36 +0200287 TEST_ASSERT( mpi_lset( &X, input_X ) == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000288 TEST_ASSERT( mpi_copy( &X, &X ) == 0 );
Paul Bakker33b43f12013-08-20 11:48:36 +0200289 TEST_ASSERT( mpi_cmp_int( &X, input_X ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000290
291 mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000292}
Paul Bakker33b43f12013-08-20 11:48:36 +0200293/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000294
Paul Bakker33b43f12013-08-20 11:48:36 +0200295/* BEGIN_CASE */
Manuel Pégourié-Gonnard58681632013-11-21 10:39:37 +0100296void mpi_shrink( int before, int used, int min, int after )
297{
298 mpi X;
299 mpi_init( &X );
300
301 TEST_ASSERT( mpi_grow( &X, before ) == 0 );
302 TEST_ASSERT( used <= before );
303 memset( X.p, 0x2a, used * sizeof( t_uint ) );
304 TEST_ASSERT( mpi_shrink( &X, min ) == 0 );
305 TEST_ASSERT( X.n == (size_t) after );
306
307 mpi_free( &X );
308}
309/* END_CASE */
310
311/* BEGIN_CASE */
Manuel Pégourié-Gonnard3e3d2b82013-11-21 21:12:26 +0100312void mpi_safe_cond_assign( int x_sign, char *x_str,
313 int y_sign, char *y_str )
Manuel Pégourié-Gonnard71c2c212013-11-21 16:56:39 +0100314{
315 mpi X, Y, XX;
316 mpi_init( &X ); mpi_init( &Y ); mpi_init( &XX );
317
318 TEST_ASSERT( mpi_read_string( &X, 16, x_str ) == 0 );
Manuel Pégourié-Gonnard3e3d2b82013-11-21 21:12:26 +0100319 X.s = x_sign;
Manuel Pégourié-Gonnard71c2c212013-11-21 16:56:39 +0100320 TEST_ASSERT( mpi_read_string( &Y, 16, y_str ) == 0 );
Manuel Pégourié-Gonnard3e3d2b82013-11-21 21:12:26 +0100321 Y.s = y_sign;
Manuel Pégourié-Gonnard71c2c212013-11-21 16:56:39 +0100322 TEST_ASSERT( mpi_copy( &XX, &X ) == 0 );
323
324 TEST_ASSERT( mpi_safe_cond_assign( &X, &Y, 0 ) == 0 );
325 TEST_ASSERT( mpi_cmp_mpi( &X, &XX ) == 0 );
326
327 TEST_ASSERT( mpi_safe_cond_assign( &X, &Y, 1 ) == 0 );
328 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == 0 );
329
330 mpi_free( &X ); mpi_free( &Y ); mpi_free( &XX );
331}
332/* END_CASE */
333
334/* BEGIN_CASE */
Manuel Pégourié-Gonnarda60fe892013-12-04 21:41:50 +0100335void mpi_safe_cond_swap( int x_sign, char *x_str,
336 int y_sign, char *y_str )
337{
338 mpi X, Y, XX, YY;
339
340 mpi_init( &X ); mpi_init( &Y );
341 mpi_init( &XX ); mpi_init( &YY );
342
343 TEST_ASSERT( mpi_read_string( &X, 16, x_str ) == 0 );
344 X.s = x_sign;
345 TEST_ASSERT( mpi_read_string( &Y, 16, y_str ) == 0 );
346 Y.s = y_sign;
347
348 TEST_ASSERT( mpi_copy( &XX, &X ) == 0 );
349 TEST_ASSERT( mpi_copy( &YY, &Y ) == 0 );
350
351 TEST_ASSERT( mpi_safe_cond_swap( &X, &Y, 0 ) == 0 );
352 TEST_ASSERT( mpi_cmp_mpi( &X, &XX ) == 0 );
353 TEST_ASSERT( mpi_cmp_mpi( &Y, &YY ) == 0 );
354
355 TEST_ASSERT( mpi_safe_cond_swap( &X, &Y, 1 ) == 0 );
356 TEST_ASSERT( mpi_cmp_mpi( &Y, &XX ) == 0 );
357 TEST_ASSERT( mpi_cmp_mpi( &X, &YY ) == 0 );
358
359 mpi_free( &X ); mpi_free( &Y );
360 mpi_free( &XX ); mpi_free( &YY );
361}
362/* END_CASE */
363
364/* BEGIN_CASE */
Paul Bakker33b43f12013-08-20 11:48:36 +0200365void mpi_swap( int input_X, int input_Y )
Paul Bakker367dae42009-06-28 21:50:27 +0000366{
367 mpi X, Y, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000368 mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000369
Paul Bakker33b43f12013-08-20 11:48:36 +0200370 TEST_ASSERT( mpi_lset( &X, input_X ) == 0 );
371 TEST_ASSERT( mpi_lset( &Y, input_Y ) == 0 );
372 TEST_ASSERT( mpi_lset( &A, input_X ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000373 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 );
374 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
375 mpi_swap( &X, &Y );
376 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 );
377 TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000378
379 mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000380}
Paul Bakker33b43f12013-08-20 11:48:36 +0200381/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000382
Paul Bakker33b43f12013-08-20 11:48:36 +0200383/* BEGIN_CASE */
384void mpi_add_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
385 int radix_A, char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000386{
387 mpi X, Y, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000388 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000389
Paul Bakker33b43f12013-08-20 11:48:36 +0200390 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
391 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
392 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000393 TEST_ASSERT( mpi_add_mpi( &Z, &X, &Y ) == 0 );
394 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000395
396 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000397}
Paul Bakker33b43f12013-08-20 11:48:36 +0200398/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000399
Paul Bakker33b43f12013-08-20 11:48:36 +0200400/* BEGIN_CASE */
401void mpi_add_abs( int radix_X, char *input_X, int radix_Y, char *input_Y,
402 int radix_A, char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000403{
404 mpi X, Y, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000405 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000406
Paul Bakker33b43f12013-08-20 11:48:36 +0200407 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
408 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
409 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000410 TEST_ASSERT( mpi_add_abs( &Z, &X, &Y ) == 0 );
411 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000412
413 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000414}
Paul Bakker33b43f12013-08-20 11:48:36 +0200415/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000416
Paul Bakker33b43f12013-08-20 11:48:36 +0200417/* BEGIN_CASE */
418void mpi_add_abs_add_first( int radix_X, char *input_X, int radix_Y,
419 char *input_Y, int radix_A, char *input_A )
Paul Bakkerba48cb22009-07-12 11:01:32 +0000420{
421 mpi X, Y, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000422 mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000423
Paul Bakker33b43f12013-08-20 11:48:36 +0200424 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
425 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
426 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000427 TEST_ASSERT( mpi_add_abs( &X, &X, &Y ) == 0 );
428 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000429
430 mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000431}
Paul Bakker33b43f12013-08-20 11:48:36 +0200432/* END_CASE */
Paul Bakkerba48cb22009-07-12 11:01:32 +0000433
Paul Bakker33b43f12013-08-20 11:48:36 +0200434/* BEGIN_CASE */
435void mpi_add_abs_add_second( int radix_X, char *input_X, int radix_Y,
436 char *input_Y, int radix_A, char *input_A )
Paul Bakkerba48cb22009-07-12 11:01:32 +0000437{
438 mpi X, Y, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000439 mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000440
Paul Bakker33b43f12013-08-20 11:48:36 +0200441 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
442 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
443 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000444 TEST_ASSERT( mpi_add_abs( &Y, &X, &Y ) == 0 );
445 TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000446
447 mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000448}
Paul Bakker33b43f12013-08-20 11:48:36 +0200449/* END_CASE */
Paul Bakkerba48cb22009-07-12 11:01:32 +0000450
Paul Bakker33b43f12013-08-20 11:48:36 +0200451/* BEGIN_CASE */
452void mpi_add_int( int radix_X, char *input_X, int input_Y, int radix_A,
453 char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000454{
455 mpi X, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000456 mpi_init( &X ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000457
Paul Bakker33b43f12013-08-20 11:48:36 +0200458 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
459 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
460 TEST_ASSERT( mpi_add_int( &Z, &X, input_Y ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000461 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000462
463 mpi_free( &X ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000464}
Paul Bakker33b43f12013-08-20 11:48:36 +0200465/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000466
Paul Bakker33b43f12013-08-20 11:48:36 +0200467/* BEGIN_CASE */
468void mpi_sub_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
469 int radix_A, char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000470{
471 mpi X, Y, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000472 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000473
Paul Bakker33b43f12013-08-20 11:48:36 +0200474 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
475 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
476 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000477 TEST_ASSERT( mpi_sub_mpi( &Z, &X, &Y ) == 0 );
478 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000479
480 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000481}
Paul Bakker33b43f12013-08-20 11:48:36 +0200482/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000483
Paul Bakker33b43f12013-08-20 11:48:36 +0200484/* BEGIN_CASE */
485void mpi_sub_abs( int radix_X, char *input_X, int radix_Y, char *input_Y,
486 int radix_A, char *input_A, int sub_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000487{
488 mpi X, Y, Z, A;
489 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000490 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000491
Paul Bakker33b43f12013-08-20 11:48:36 +0200492 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
493 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
494 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000495
496 res = mpi_sub_abs( &Z, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200497 TEST_ASSERT( res == sub_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000498 if( res == 0 )
499 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000500
501 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
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 */
506void mpi_sub_int( int radix_X, char *input_X, int input_Y, int radix_A,
507 char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000508{
509 mpi X, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000510 mpi_init( &X ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000511
Paul Bakker33b43f12013-08-20 11:48:36 +0200512 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
513 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
514 TEST_ASSERT( mpi_sub_int( &Z, &X, input_Y ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000515 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000516
517 mpi_free( &X ); mpi_free( &Z ); mpi_free( &A );
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 */
522void mpi_mul_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
523 int radix_A, char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000524{
525 mpi X, Y, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000526 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000527
Paul Bakker33b43f12013-08-20 11:48:36 +0200528 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
529 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
530 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000531 TEST_ASSERT( mpi_mul_mpi( &Z, &X, &Y ) == 0 );
532 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000533
534 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000535}
Paul Bakker33b43f12013-08-20 11:48:36 +0200536/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000537
Paul Bakker33b43f12013-08-20 11:48:36 +0200538/* BEGIN_CASE */
539void mpi_mul_int( int radix_X, char *input_X, int input_Y, int radix_A,
540 char *input_A, char *result_comparison )
Paul Bakker367dae42009-06-28 21:50:27 +0000541{
542 mpi X, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000543 mpi_init( &X ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000544
Paul Bakker33b43f12013-08-20 11:48:36 +0200545 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
546 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
547 TEST_ASSERT( mpi_mul_int( &Z, &X, input_Y ) == 0 );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200548 if( strcmp( result_comparison, "==" ) == 0 )
549 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
550 else if( strcmp( result_comparison, "!=" ) == 0 )
551 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) != 0 );
552 else
553 TEST_ASSERT( "unknown operator" == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000554
555 mpi_free( &X ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000556}
Paul Bakker33b43f12013-08-20 11:48:36 +0200557/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000558
Paul Bakker33b43f12013-08-20 11:48:36 +0200559/* BEGIN_CASE */
560void mpi_div_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
561 int radix_A, char *input_A, int radix_B, char *input_B,
562 int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000563{
564 mpi X, Y, Q, R, A, B;
565 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000566 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Q ); mpi_init( &R );
567 mpi_init( &A ); mpi_init( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000568
Paul Bakker33b43f12013-08-20 11:48:36 +0200569 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
570 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
571 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
572 TEST_ASSERT( mpi_read_string( &B, radix_B, input_B ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000573 res = mpi_div_mpi( &Q, &R, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200574 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000575 if( res == 0 )
576 {
577 TEST_ASSERT( mpi_cmp_mpi( &Q, &A ) == 0 );
578 TEST_ASSERT( mpi_cmp_mpi( &R, &B ) == 0 );
579 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000580
581 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Q ); mpi_free( &R );
582 mpi_free( &A ); mpi_free( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000583}
Paul Bakker33b43f12013-08-20 11:48:36 +0200584/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000585
Paul Bakker33b43f12013-08-20 11:48:36 +0200586/* BEGIN_CASE */
587void mpi_div_int( int radix_X, char *input_X, int input_Y, int radix_A,
588 char *input_A, int radix_B, char *input_B, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000589{
590 mpi X, Q, R, A, B;
591 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000592 mpi_init( &X ); mpi_init( &Q ); mpi_init( &R ); mpi_init( &A );
593 mpi_init( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000594
Paul Bakker33b43f12013-08-20 11:48:36 +0200595 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
596 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
597 TEST_ASSERT( mpi_read_string( &B, radix_B, input_B ) == 0 );
598 res = mpi_div_int( &Q, &R, &X, input_Y );
599 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000600 if( res == 0 )
601 {
602 TEST_ASSERT( mpi_cmp_mpi( &Q, &A ) == 0 );
603 TEST_ASSERT( mpi_cmp_mpi( &R, &B ) == 0 );
604 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000605
606 mpi_free( &X ); mpi_free( &Q ); mpi_free( &R ); mpi_free( &A );
607 mpi_free( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000608}
Paul Bakker33b43f12013-08-20 11:48:36 +0200609/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000610
Paul Bakker33b43f12013-08-20 11:48:36 +0200611/* BEGIN_CASE */
612void mpi_mod_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
613 int radix_A, char *input_A, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000614{
Paul Bakkerf02c5642012-11-13 10:25:21 +0000615 mpi X, Y, A;
Paul Bakker367dae42009-06-28 21:50:27 +0000616 int res;
Paul Bakkerf02c5642012-11-13 10:25:21 +0000617 mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000618
Paul Bakker33b43f12013-08-20 11:48:36 +0200619 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
620 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
621 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakkerf02c5642012-11-13 10:25:21 +0000622 res = mpi_mod_mpi( &X, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200623 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000624 if( res == 0 )
625 {
Paul Bakkerf02c5642012-11-13 10:25:21 +0000626 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000627 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000628
Paul Bakkerf02c5642012-11-13 10:25:21 +0000629 mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000630}
Paul Bakker33b43f12013-08-20 11:48:36 +0200631/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000632
Paul Bakker33b43f12013-08-20 11:48:36 +0200633/* BEGIN_CASE */
634void mpi_mod_int( int radix_X, char *input_X, int input_Y, int input_A,
635 int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000636{
637 mpi X;
638 int res;
Paul Bakkera755ca12011-04-24 09:11:17 +0000639 t_uint r;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000640 mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000641
Paul Bakker33b43f12013-08-20 11:48:36 +0200642 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
643 res = mpi_mod_int( &r, &X, input_Y );
644 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000645 if( res == 0 )
646 {
Paul Bakker33b43f12013-08-20 11:48:36 +0200647 TEST_ASSERT( r == (t_uint) input_A );
Paul Bakker367dae42009-06-28 21:50:27 +0000648 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000649
650 mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000651}
Paul Bakker33b43f12013-08-20 11:48:36 +0200652/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000653
Paul Bakker33b43f12013-08-20 11:48:36 +0200654/* BEGIN_CASE */
655void mpi_exp_mod( int radix_A, char *input_A, int radix_E, char *input_E,
656 int radix_N, char *input_N, int radix_RR, char *input_RR,
657 int radix_X, char *input_X, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000658{
659 mpi A, E, N, RR, Z, X;
660 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000661 mpi_init( &A ); mpi_init( &E ); mpi_init( &N );
662 mpi_init( &RR ); mpi_init( &Z ); mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000663
Paul Bakker33b43f12013-08-20 11:48:36 +0200664 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
665 TEST_ASSERT( mpi_read_string( &E, radix_E, input_E ) == 0 );
666 TEST_ASSERT( mpi_read_string( &N, radix_N, input_N ) == 0 );
667 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000668
Paul Bakker33b43f12013-08-20 11:48:36 +0200669 if( strlen( input_RR ) )
670 TEST_ASSERT( mpi_read_string( &RR, radix_RR, input_RR ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000671
672 res = mpi_exp_mod( &Z, &A, &E, &N, &RR );
Paul Bakker33b43f12013-08-20 11:48:36 +0200673 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000674 if( res == 0 )
675 {
676 TEST_ASSERT( mpi_cmp_mpi( &Z, &X ) == 0 );
677 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000678
679 mpi_free( &A ); mpi_free( &E ); mpi_free( &N );
680 mpi_free( &RR ); mpi_free( &Z ); mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000681}
Paul Bakker33b43f12013-08-20 11:48:36 +0200682/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000683
Paul Bakker33b43f12013-08-20 11:48:36 +0200684/* BEGIN_CASE */
685void mpi_inv_mod( int radix_X, char *input_X, int radix_Y, char *input_Y,
686 int radix_A, char *input_A, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000687{
688 mpi X, Y, Z, A;
689 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000690 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000691
Paul Bakker33b43f12013-08-20 11:48:36 +0200692 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
693 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
694 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000695 res = mpi_inv_mod( &Z, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200696 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000697 if( res == 0 )
698 {
699 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
700 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000701
702 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000703}
Paul Bakker33b43f12013-08-20 11:48:36 +0200704/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000705
Manuel Pégourié-Gonnarddf0142b2013-08-22 18:29:07 +0200706/* BEGIN_CASE depends_on:POLARSSL_GENPRIME */
Paul Bakker33b43f12013-08-20 11:48:36 +0200707void mpi_is_prime( int radix_X, char *input_X, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000708{
709 mpi X;
710 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000711 mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000712
Paul Bakker33b43f12013-08-20 11:48:36 +0200713 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
Paul Bakker5690efc2011-05-26 13:16:06 +0000714 res = mpi_is_prime( &X, rnd_std_rand, NULL );
Paul Bakker33b43f12013-08-20 11:48:36 +0200715 TEST_ASSERT( res == div_result );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000716
717 mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000718}
Paul Bakker33b43f12013-08-20 11:48:36 +0200719/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000720
Paul Bakker33b43f12013-08-20 11:48:36 +0200721/* BEGIN_CASE */
722void mpi_shift_l( int radix_X, char *input_X, int shift_X, int radix_A,
723 char *input_A)
Paul Bakker367dae42009-06-28 21:50:27 +0000724{
725 mpi X, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000726 mpi_init( &X ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000727
Paul Bakker33b43f12013-08-20 11:48:36 +0200728 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
729 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
730 TEST_ASSERT( mpi_shift_l( &X, shift_X ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000731 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000732
733 mpi_free( &X ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000734}
Paul Bakker33b43f12013-08-20 11:48:36 +0200735/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000736
Paul Bakker33b43f12013-08-20 11:48:36 +0200737/* BEGIN_CASE */
738void mpi_shift_r( int radix_X, char *input_X, int shift_X, int radix_A,
739 char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000740{
741 mpi X, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000742 mpi_init( &X ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000743
Paul Bakker33b43f12013-08-20 11:48:36 +0200744 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
745 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
746 TEST_ASSERT( mpi_shift_r( &X, shift_X ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000747 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000748
749 mpi_free( &X ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000750}
Paul Bakker33b43f12013-08-20 11:48:36 +0200751/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000752
Manuel Pégourié-Gonnard20140162013-10-10 12:48:03 +0200753/* BEGIN_CASE depends_on:POLARSSL_SELF_TEST */
Paul Bakker33b43f12013-08-20 11:48:36 +0200754void mpi_selftest()
Paul Bakkere896fea2009-07-06 06:40:23 +0000755{
756 TEST_ASSERT( mpi_self_test( 0 ) == 0 );
757}
Paul Bakker33b43f12013-08-20 11:48:36 +0200758/* END_CASE */