blob: d3a0d48981d9dc864601ea8504aa935a4c304a01 [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 */
Paul Bakker33b43f12013-08-20 11:48:36 +0200312void mpi_swap( int input_X, int input_Y )
Paul Bakker367dae42009-06-28 21:50:27 +0000313{
314 mpi X, Y, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000315 mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000316
Paul Bakker33b43f12013-08-20 11:48:36 +0200317 TEST_ASSERT( mpi_lset( &X, input_X ) == 0 );
318 TEST_ASSERT( mpi_lset( &Y, input_Y ) == 0 );
319 TEST_ASSERT( mpi_lset( &A, input_X ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000320 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 );
321 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
322 mpi_swap( &X, &Y );
323 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 );
324 TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000325
326 mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000327}
Paul Bakker33b43f12013-08-20 11:48:36 +0200328/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000329
Paul Bakker33b43f12013-08-20 11:48:36 +0200330/* BEGIN_CASE */
331void mpi_add_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
332 int radix_A, char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000333{
334 mpi X, Y, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000335 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000336
Paul Bakker33b43f12013-08-20 11:48:36 +0200337 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
338 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
339 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000340 TEST_ASSERT( mpi_add_mpi( &Z, &X, &Y ) == 0 );
341 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000342
343 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000344}
Paul Bakker33b43f12013-08-20 11:48:36 +0200345/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000346
Paul Bakker33b43f12013-08-20 11:48:36 +0200347/* BEGIN_CASE */
348void mpi_add_abs( int radix_X, char *input_X, int radix_Y, char *input_Y,
349 int radix_A, char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000350{
351 mpi X, Y, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000352 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000353
Paul Bakker33b43f12013-08-20 11:48:36 +0200354 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
355 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
356 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000357 TEST_ASSERT( mpi_add_abs( &Z, &X, &Y ) == 0 );
358 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000359
360 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000361}
Paul Bakker33b43f12013-08-20 11:48:36 +0200362/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000363
Paul Bakker33b43f12013-08-20 11:48:36 +0200364/* BEGIN_CASE */
365void mpi_add_abs_add_first( int radix_X, char *input_X, int radix_Y,
366 char *input_Y, int radix_A, char *input_A )
Paul Bakkerba48cb22009-07-12 11:01:32 +0000367{
368 mpi X, Y, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000369 mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000370
Paul Bakker33b43f12013-08-20 11:48:36 +0200371 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
372 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
373 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000374 TEST_ASSERT( mpi_add_abs( &X, &X, &Y ) == 0 );
375 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000376
377 mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000378}
Paul Bakker33b43f12013-08-20 11:48:36 +0200379/* END_CASE */
Paul Bakkerba48cb22009-07-12 11:01:32 +0000380
Paul Bakker33b43f12013-08-20 11:48:36 +0200381/* BEGIN_CASE */
382void mpi_add_abs_add_second( int radix_X, char *input_X, int radix_Y,
383 char *input_Y, int radix_A, char *input_A )
Paul Bakkerba48cb22009-07-12 11:01:32 +0000384{
385 mpi X, Y, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000386 mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000387
Paul Bakker33b43f12013-08-20 11:48:36 +0200388 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
389 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
390 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000391 TEST_ASSERT( mpi_add_abs( &Y, &X, &Y ) == 0 );
392 TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000393
394 mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000395}
Paul Bakker33b43f12013-08-20 11:48:36 +0200396/* END_CASE */
Paul Bakkerba48cb22009-07-12 11:01:32 +0000397
Paul Bakker33b43f12013-08-20 11:48:36 +0200398/* BEGIN_CASE */
399void mpi_add_int( int radix_X, char *input_X, int input_Y, int radix_A,
400 char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000401{
402 mpi X, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000403 mpi_init( &X ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000404
Paul Bakker33b43f12013-08-20 11:48:36 +0200405 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
406 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
407 TEST_ASSERT( mpi_add_int( &Z, &X, input_Y ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000408 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000409
410 mpi_free( &X ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000411}
Paul Bakker33b43f12013-08-20 11:48:36 +0200412/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000413
Paul Bakker33b43f12013-08-20 11:48:36 +0200414/* BEGIN_CASE */
415void mpi_sub_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
416 int radix_A, char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000417{
418 mpi X, Y, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000419 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000420
Paul Bakker33b43f12013-08-20 11:48:36 +0200421 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
422 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
423 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000424 TEST_ASSERT( mpi_sub_mpi( &Z, &X, &Y ) == 0 );
425 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000426
427 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000428}
Paul Bakker33b43f12013-08-20 11:48:36 +0200429/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000430
Paul Bakker33b43f12013-08-20 11:48:36 +0200431/* BEGIN_CASE */
432void mpi_sub_abs( int radix_X, char *input_X, int radix_Y, char *input_Y,
433 int radix_A, char *input_A, int sub_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000434{
435 mpi X, Y, Z, A;
436 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000437 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000438
Paul Bakker33b43f12013-08-20 11:48:36 +0200439 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
440 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
441 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000442
443 res = mpi_sub_abs( &Z, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200444 TEST_ASSERT( res == sub_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000445 if( res == 0 )
446 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000447
448 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000449}
Paul Bakker33b43f12013-08-20 11:48:36 +0200450/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000451
Paul Bakker33b43f12013-08-20 11:48:36 +0200452/* BEGIN_CASE */
453void mpi_sub_int( int radix_X, char *input_X, int input_Y, int radix_A,
454 char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000455{
456 mpi X, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000457 mpi_init( &X ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000458
Paul Bakker33b43f12013-08-20 11:48:36 +0200459 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
460 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
461 TEST_ASSERT( mpi_sub_int( &Z, &X, input_Y ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000462 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000463
464 mpi_free( &X ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000465}
Paul Bakker33b43f12013-08-20 11:48:36 +0200466/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000467
Paul Bakker33b43f12013-08-20 11:48:36 +0200468/* BEGIN_CASE */
469void mpi_mul_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
470 int radix_A, char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000471{
472 mpi X, Y, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000473 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000474
Paul Bakker33b43f12013-08-20 11:48:36 +0200475 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
476 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
477 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000478 TEST_ASSERT( mpi_mul_mpi( &Z, &X, &Y ) == 0 );
479 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000480
481 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000482}
Paul Bakker33b43f12013-08-20 11:48:36 +0200483/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000484
Paul Bakker33b43f12013-08-20 11:48:36 +0200485/* BEGIN_CASE */
486void mpi_mul_int( int radix_X, char *input_X, int input_Y, int radix_A,
487 char *input_A, char *result_comparison )
Paul Bakker367dae42009-06-28 21:50:27 +0000488{
489 mpi X, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000490 mpi_init( &X ); 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( &A, radix_A, input_A ) == 0 );
494 TEST_ASSERT( mpi_mul_int( &Z, &X, input_Y ) == 0 );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200495 if( strcmp( result_comparison, "==" ) == 0 )
496 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
497 else if( strcmp( result_comparison, "!=" ) == 0 )
498 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) != 0 );
499 else
500 TEST_ASSERT( "unknown operator" == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000501
502 mpi_free( &X ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000503}
Paul Bakker33b43f12013-08-20 11:48:36 +0200504/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000505
Paul Bakker33b43f12013-08-20 11:48:36 +0200506/* BEGIN_CASE */
507void mpi_div_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
508 int radix_A, char *input_A, int radix_B, char *input_B,
509 int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000510{
511 mpi X, Y, Q, R, A, B;
512 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000513 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Q ); mpi_init( &R );
514 mpi_init( &A ); mpi_init( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000515
Paul Bakker33b43f12013-08-20 11:48:36 +0200516 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
517 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
518 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
519 TEST_ASSERT( mpi_read_string( &B, radix_B, input_B ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000520 res = mpi_div_mpi( &Q, &R, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200521 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000522 if( res == 0 )
523 {
524 TEST_ASSERT( mpi_cmp_mpi( &Q, &A ) == 0 );
525 TEST_ASSERT( mpi_cmp_mpi( &R, &B ) == 0 );
526 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000527
528 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Q ); mpi_free( &R );
529 mpi_free( &A ); mpi_free( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000530}
Paul Bakker33b43f12013-08-20 11:48:36 +0200531/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000532
Paul Bakker33b43f12013-08-20 11:48:36 +0200533/* BEGIN_CASE */
534void mpi_div_int( int radix_X, char *input_X, int input_Y, int radix_A,
535 char *input_A, int radix_B, char *input_B, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000536{
537 mpi X, Q, R, A, B;
538 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000539 mpi_init( &X ); mpi_init( &Q ); mpi_init( &R ); mpi_init( &A );
540 mpi_init( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000541
Paul Bakker33b43f12013-08-20 11:48:36 +0200542 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
543 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
544 TEST_ASSERT( mpi_read_string( &B, radix_B, input_B ) == 0 );
545 res = mpi_div_int( &Q, &R, &X, input_Y );
546 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000547 if( res == 0 )
548 {
549 TEST_ASSERT( mpi_cmp_mpi( &Q, &A ) == 0 );
550 TEST_ASSERT( mpi_cmp_mpi( &R, &B ) == 0 );
551 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000552
553 mpi_free( &X ); mpi_free( &Q ); mpi_free( &R ); mpi_free( &A );
554 mpi_free( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000555}
Paul Bakker33b43f12013-08-20 11:48:36 +0200556/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000557
Paul Bakker33b43f12013-08-20 11:48:36 +0200558/* BEGIN_CASE */
559void mpi_mod_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
560 int radix_A, char *input_A, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000561{
Paul Bakkerf02c5642012-11-13 10:25:21 +0000562 mpi X, Y, A;
Paul Bakker367dae42009-06-28 21:50:27 +0000563 int res;
Paul Bakkerf02c5642012-11-13 10:25:21 +0000564 mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000565
Paul Bakker33b43f12013-08-20 11:48:36 +0200566 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
567 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
568 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakkerf02c5642012-11-13 10:25:21 +0000569 res = mpi_mod_mpi( &X, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200570 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000571 if( res == 0 )
572 {
Paul Bakkerf02c5642012-11-13 10:25:21 +0000573 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000574 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000575
Paul Bakkerf02c5642012-11-13 10:25:21 +0000576 mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000577}
Paul Bakker33b43f12013-08-20 11:48:36 +0200578/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000579
Paul Bakker33b43f12013-08-20 11:48:36 +0200580/* BEGIN_CASE */
581void mpi_mod_int( int radix_X, char *input_X, int input_Y, int input_A,
582 int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000583{
584 mpi X;
585 int res;
Paul Bakkera755ca12011-04-24 09:11:17 +0000586 t_uint r;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000587 mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000588
Paul Bakker33b43f12013-08-20 11:48:36 +0200589 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
590 res = mpi_mod_int( &r, &X, input_Y );
591 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000592 if( res == 0 )
593 {
Paul Bakker33b43f12013-08-20 11:48:36 +0200594 TEST_ASSERT( r == (t_uint) input_A );
Paul Bakker367dae42009-06-28 21:50:27 +0000595 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000596
597 mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000598}
Paul Bakker33b43f12013-08-20 11:48:36 +0200599/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000600
Paul Bakker33b43f12013-08-20 11:48:36 +0200601/* BEGIN_CASE */
602void mpi_exp_mod( int radix_A, char *input_A, int radix_E, char *input_E,
603 int radix_N, char *input_N, int radix_RR, char *input_RR,
604 int radix_X, char *input_X, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000605{
606 mpi A, E, N, RR, Z, X;
607 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000608 mpi_init( &A ); mpi_init( &E ); mpi_init( &N );
609 mpi_init( &RR ); mpi_init( &Z ); mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000610
Paul Bakker33b43f12013-08-20 11:48:36 +0200611 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
612 TEST_ASSERT( mpi_read_string( &E, radix_E, input_E ) == 0 );
613 TEST_ASSERT( mpi_read_string( &N, radix_N, input_N ) == 0 );
614 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000615
Paul Bakker33b43f12013-08-20 11:48:36 +0200616 if( strlen( input_RR ) )
617 TEST_ASSERT( mpi_read_string( &RR, radix_RR, input_RR ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000618
619 res = mpi_exp_mod( &Z, &A, &E, &N, &RR );
Paul Bakker33b43f12013-08-20 11:48:36 +0200620 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000621 if( res == 0 )
622 {
623 TEST_ASSERT( mpi_cmp_mpi( &Z, &X ) == 0 );
624 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000625
626 mpi_free( &A ); mpi_free( &E ); mpi_free( &N );
627 mpi_free( &RR ); mpi_free( &Z ); mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000628}
Paul Bakker33b43f12013-08-20 11:48:36 +0200629/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000630
Paul Bakker33b43f12013-08-20 11:48:36 +0200631/* BEGIN_CASE */
632void mpi_inv_mod( int radix_X, char *input_X, int radix_Y, char *input_Y,
633 int radix_A, char *input_A, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000634{
635 mpi X, Y, Z, A;
636 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000637 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000638
Paul Bakker33b43f12013-08-20 11:48:36 +0200639 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
640 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
641 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000642 res = mpi_inv_mod( &Z, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200643 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000644 if( res == 0 )
645 {
646 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
647 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000648
649 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000650}
Paul Bakker33b43f12013-08-20 11:48:36 +0200651/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000652
Manuel Pégourié-Gonnarddf0142b2013-08-22 18:29:07 +0200653/* BEGIN_CASE depends_on:POLARSSL_GENPRIME */
Paul Bakker33b43f12013-08-20 11:48:36 +0200654void mpi_is_prime( int radix_X, char *input_X, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000655{
656 mpi X;
657 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000658 mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000659
Paul Bakker33b43f12013-08-20 11:48:36 +0200660 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
Paul Bakker5690efc2011-05-26 13:16:06 +0000661 res = mpi_is_prime( &X, rnd_std_rand, NULL );
Paul Bakker33b43f12013-08-20 11:48:36 +0200662 TEST_ASSERT( res == div_result );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000663
664 mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000665}
Paul Bakker33b43f12013-08-20 11:48:36 +0200666/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000667
Paul Bakker33b43f12013-08-20 11:48:36 +0200668/* BEGIN_CASE */
669void mpi_shift_l( int radix_X, char *input_X, int shift_X, int radix_A,
670 char *input_A)
Paul Bakker367dae42009-06-28 21:50:27 +0000671{
672 mpi X, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000673 mpi_init( &X ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000674
Paul Bakker33b43f12013-08-20 11:48:36 +0200675 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
676 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
677 TEST_ASSERT( mpi_shift_l( &X, shift_X ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000678 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000679
680 mpi_free( &X ); mpi_free( &A );
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_shift_r( int radix_X, char *input_X, int shift_X, int radix_A,
686 char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000687{
688 mpi X, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000689 mpi_init( &X ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000690
Paul Bakker33b43f12013-08-20 11:48:36 +0200691 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
692 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
693 TEST_ASSERT( mpi_shift_r( &X, shift_X ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000694 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000695
696 mpi_free( &X ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000697}
Paul Bakker33b43f12013-08-20 11:48:36 +0200698/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000699
Manuel Pégourié-Gonnard20140162013-10-10 12:48:03 +0200700/* BEGIN_CASE depends_on:POLARSSL_SELF_TEST */
Paul Bakker33b43f12013-08-20 11:48:36 +0200701void mpi_selftest()
Paul Bakkere896fea2009-07-06 06:40:23 +0000702{
703 TEST_ASSERT( mpi_self_test( 0 ) == 0 );
704}
Paul Bakker33b43f12013-08-20 11:48:36 +0200705/* END_CASE */