blob: ee9b94a5be2a1c3db3588aea1861d4077d2fd9ef [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é-Gonnard71c2c212013-11-21 16:56:39 +0100312void mpi_safe_cond_assign( char *x_str, char *y_str )
313{
314 mpi X, Y, XX;
315 mpi_init( &X ); mpi_init( &Y ); mpi_init( &XX );
316
317 TEST_ASSERT( mpi_read_string( &X, 16, x_str ) == 0 );
318 TEST_ASSERT( mpi_read_string( &Y, 16, y_str ) == 0 );
319 TEST_ASSERT( mpi_copy( &XX, &X ) == 0 );
320
321 TEST_ASSERT( mpi_safe_cond_assign( &X, &Y, 0 ) == 0 );
322 TEST_ASSERT( mpi_cmp_mpi( &X, &XX ) == 0 );
323
324 TEST_ASSERT( mpi_safe_cond_assign( &X, &Y, 1 ) == 0 );
325 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == 0 );
326
327 mpi_free( &X ); mpi_free( &Y ); mpi_free( &XX );
328}
329/* END_CASE */
330
331/* BEGIN_CASE */
Paul Bakker33b43f12013-08-20 11:48:36 +0200332void mpi_swap( int input_X, int input_Y )
Paul Bakker367dae42009-06-28 21:50:27 +0000333{
334 mpi X, Y, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000335 mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000336
Paul Bakker33b43f12013-08-20 11:48:36 +0200337 TEST_ASSERT( mpi_lset( &X, input_X ) == 0 );
338 TEST_ASSERT( mpi_lset( &Y, input_Y ) == 0 );
339 TEST_ASSERT( mpi_lset( &A, input_X ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000340 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 );
341 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
342 mpi_swap( &X, &Y );
343 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 );
344 TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000345
346 mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000347}
Paul Bakker33b43f12013-08-20 11:48:36 +0200348/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000349
Paul Bakker33b43f12013-08-20 11:48:36 +0200350/* BEGIN_CASE */
351void mpi_add_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
352 int radix_A, char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000353{
354 mpi X, Y, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000355 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000356
Paul Bakker33b43f12013-08-20 11:48:36 +0200357 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
358 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
359 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000360 TEST_ASSERT( mpi_add_mpi( &Z, &X, &Y ) == 0 );
361 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000362
363 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000364}
Paul Bakker33b43f12013-08-20 11:48:36 +0200365/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000366
Paul Bakker33b43f12013-08-20 11:48:36 +0200367/* BEGIN_CASE */
368void mpi_add_abs( int radix_X, char *input_X, int radix_Y, char *input_Y,
369 int radix_A, char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000370{
371 mpi X, Y, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000372 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000373
Paul Bakker33b43f12013-08-20 11:48:36 +0200374 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
375 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
376 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000377 TEST_ASSERT( mpi_add_abs( &Z, &X, &Y ) == 0 );
378 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000379
380 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000381}
Paul Bakker33b43f12013-08-20 11:48:36 +0200382/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000383
Paul Bakker33b43f12013-08-20 11:48:36 +0200384/* BEGIN_CASE */
385void mpi_add_abs_add_first( int radix_X, char *input_X, int radix_Y,
386 char *input_Y, int radix_A, char *input_A )
Paul Bakkerba48cb22009-07-12 11:01:32 +0000387{
388 mpi X, Y, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000389 mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000390
Paul Bakker33b43f12013-08-20 11:48:36 +0200391 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
392 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
393 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000394 TEST_ASSERT( mpi_add_abs( &X, &X, &Y ) == 0 );
395 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000396
397 mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000398}
Paul Bakker33b43f12013-08-20 11:48:36 +0200399/* END_CASE */
Paul Bakkerba48cb22009-07-12 11:01:32 +0000400
Paul Bakker33b43f12013-08-20 11:48:36 +0200401/* BEGIN_CASE */
402void mpi_add_abs_add_second( int radix_X, char *input_X, int radix_Y,
403 char *input_Y, int radix_A, char *input_A )
Paul Bakkerba48cb22009-07-12 11:01:32 +0000404{
405 mpi X, Y, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000406 mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000407
Paul Bakker33b43f12013-08-20 11:48:36 +0200408 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
409 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
410 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000411 TEST_ASSERT( mpi_add_abs( &Y, &X, &Y ) == 0 );
412 TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000413
414 mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000415}
Paul Bakker33b43f12013-08-20 11:48:36 +0200416/* END_CASE */
Paul Bakkerba48cb22009-07-12 11:01:32 +0000417
Paul Bakker33b43f12013-08-20 11:48:36 +0200418/* BEGIN_CASE */
419void mpi_add_int( int radix_X, char *input_X, int input_Y, int radix_A,
420 char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000421{
422 mpi X, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000423 mpi_init( &X ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000424
Paul Bakker33b43f12013-08-20 11:48:36 +0200425 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
426 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
427 TEST_ASSERT( mpi_add_int( &Z, &X, input_Y ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000428 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000429
430 mpi_free( &X ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000431}
Paul Bakker33b43f12013-08-20 11:48:36 +0200432/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000433
Paul Bakker33b43f12013-08-20 11:48:36 +0200434/* BEGIN_CASE */
435void mpi_sub_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
436 int radix_A, char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000437{
438 mpi X, Y, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000439 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +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 Bakker367dae42009-06-28 21:50:27 +0000444 TEST_ASSERT( mpi_sub_mpi( &Z, &X, &Y ) == 0 );
445 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000446
447 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000448}
Paul Bakker33b43f12013-08-20 11:48:36 +0200449/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000450
Paul Bakker33b43f12013-08-20 11:48:36 +0200451/* BEGIN_CASE */
452void mpi_sub_abs( int radix_X, char *input_X, int radix_Y, char *input_Y,
453 int radix_A, char *input_A, int sub_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000454{
455 mpi X, Y, Z, A;
456 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000457 mpi_init( &X ); mpi_init( &Y ); 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( &Y, radix_Y, input_Y ) == 0 );
461 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000462
463 res = mpi_sub_abs( &Z, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200464 TEST_ASSERT( res == sub_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000465 if( res == 0 )
466 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000467
468 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000469}
Paul Bakker33b43f12013-08-20 11:48:36 +0200470/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000471
Paul Bakker33b43f12013-08-20 11:48:36 +0200472/* BEGIN_CASE */
473void mpi_sub_int( int radix_X, char *input_X, int input_Y, int radix_A,
474 char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000475{
476 mpi X, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000477 mpi_init( &X ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000478
Paul Bakker33b43f12013-08-20 11:48:36 +0200479 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
480 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
481 TEST_ASSERT( mpi_sub_int( &Z, &X, input_Y ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000482 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000483
484 mpi_free( &X ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000485}
Paul Bakker33b43f12013-08-20 11:48:36 +0200486/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000487
Paul Bakker33b43f12013-08-20 11:48:36 +0200488/* BEGIN_CASE */
489void mpi_mul_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
490 int radix_A, char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000491{
492 mpi X, Y, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000493 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000494
Paul Bakker33b43f12013-08-20 11:48:36 +0200495 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
496 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
497 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000498 TEST_ASSERT( mpi_mul_mpi( &Z, &X, &Y ) == 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_mul_int( int radix_X, char *input_X, int input_Y, int radix_A,
507 char *input_A, char *result_comparison )
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_mul_int( &Z, &X, input_Y ) == 0 );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200515 if( strcmp( result_comparison, "==" ) == 0 )
516 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
517 else if( strcmp( result_comparison, "!=" ) == 0 )
518 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) != 0 );
519 else
520 TEST_ASSERT( "unknown operator" == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000521
522 mpi_free( &X ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000523}
Paul Bakker33b43f12013-08-20 11:48:36 +0200524/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000525
Paul Bakker33b43f12013-08-20 11:48:36 +0200526/* BEGIN_CASE */
527void mpi_div_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
528 int radix_A, char *input_A, int radix_B, char *input_B,
529 int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000530{
531 mpi X, Y, Q, R, A, B;
532 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000533 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Q ); mpi_init( &R );
534 mpi_init( &A ); mpi_init( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000535
Paul Bakker33b43f12013-08-20 11:48:36 +0200536 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
537 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
538 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
539 TEST_ASSERT( mpi_read_string( &B, radix_B, input_B ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000540 res = mpi_div_mpi( &Q, &R, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200541 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000542 if( res == 0 )
543 {
544 TEST_ASSERT( mpi_cmp_mpi( &Q, &A ) == 0 );
545 TEST_ASSERT( mpi_cmp_mpi( &R, &B ) == 0 );
546 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000547
548 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Q ); mpi_free( &R );
549 mpi_free( &A ); mpi_free( &B );
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 */
554void mpi_div_int( int radix_X, char *input_X, int input_Y, int radix_A,
555 char *input_A, int radix_B, char *input_B, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000556{
557 mpi X, Q, R, A, B;
558 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000559 mpi_init( &X ); mpi_init( &Q ); mpi_init( &R ); mpi_init( &A );
560 mpi_init( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000561
Paul Bakker33b43f12013-08-20 11:48:36 +0200562 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
563 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
564 TEST_ASSERT( mpi_read_string( &B, radix_B, input_B ) == 0 );
565 res = mpi_div_int( &Q, &R, &X, input_Y );
566 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000567 if( res == 0 )
568 {
569 TEST_ASSERT( mpi_cmp_mpi( &Q, &A ) == 0 );
570 TEST_ASSERT( mpi_cmp_mpi( &R, &B ) == 0 );
571 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000572
573 mpi_free( &X ); mpi_free( &Q ); mpi_free( &R ); mpi_free( &A );
574 mpi_free( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000575}
Paul Bakker33b43f12013-08-20 11:48:36 +0200576/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000577
Paul Bakker33b43f12013-08-20 11:48:36 +0200578/* BEGIN_CASE */
579void mpi_mod_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
580 int radix_A, char *input_A, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000581{
Paul Bakkerf02c5642012-11-13 10:25:21 +0000582 mpi X, Y, A;
Paul Bakker367dae42009-06-28 21:50:27 +0000583 int res;
Paul Bakkerf02c5642012-11-13 10:25:21 +0000584 mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000585
Paul Bakker33b43f12013-08-20 11:48:36 +0200586 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
587 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
588 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakkerf02c5642012-11-13 10:25:21 +0000589 res = mpi_mod_mpi( &X, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200590 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000591 if( res == 0 )
592 {
Paul Bakkerf02c5642012-11-13 10:25:21 +0000593 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000594 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000595
Paul Bakkerf02c5642012-11-13 10:25:21 +0000596 mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000597}
Paul Bakker33b43f12013-08-20 11:48:36 +0200598/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000599
Paul Bakker33b43f12013-08-20 11:48:36 +0200600/* BEGIN_CASE */
601void mpi_mod_int( int radix_X, char *input_X, int input_Y, int input_A,
602 int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000603{
604 mpi X;
605 int res;
Paul Bakkera755ca12011-04-24 09:11:17 +0000606 t_uint r;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000607 mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000608
Paul Bakker33b43f12013-08-20 11:48:36 +0200609 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
610 res = mpi_mod_int( &r, &X, input_Y );
611 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000612 if( res == 0 )
613 {
Paul Bakker33b43f12013-08-20 11:48:36 +0200614 TEST_ASSERT( r == (t_uint) input_A );
Paul Bakker367dae42009-06-28 21:50:27 +0000615 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000616
617 mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000618}
Paul Bakker33b43f12013-08-20 11:48:36 +0200619/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000620
Paul Bakker33b43f12013-08-20 11:48:36 +0200621/* BEGIN_CASE */
622void mpi_exp_mod( int radix_A, char *input_A, int radix_E, char *input_E,
623 int radix_N, char *input_N, int radix_RR, char *input_RR,
624 int radix_X, char *input_X, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000625{
626 mpi A, E, N, RR, Z, X;
627 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000628 mpi_init( &A ); mpi_init( &E ); mpi_init( &N );
629 mpi_init( &RR ); mpi_init( &Z ); mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000630
Paul Bakker33b43f12013-08-20 11:48:36 +0200631 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
632 TEST_ASSERT( mpi_read_string( &E, radix_E, input_E ) == 0 );
633 TEST_ASSERT( mpi_read_string( &N, radix_N, input_N ) == 0 );
634 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000635
Paul Bakker33b43f12013-08-20 11:48:36 +0200636 if( strlen( input_RR ) )
637 TEST_ASSERT( mpi_read_string( &RR, radix_RR, input_RR ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000638
639 res = mpi_exp_mod( &Z, &A, &E, &N, &RR );
Paul Bakker33b43f12013-08-20 11:48:36 +0200640 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000641 if( res == 0 )
642 {
643 TEST_ASSERT( mpi_cmp_mpi( &Z, &X ) == 0 );
644 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000645
646 mpi_free( &A ); mpi_free( &E ); mpi_free( &N );
647 mpi_free( &RR ); mpi_free( &Z ); mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000648}
Paul Bakker33b43f12013-08-20 11:48:36 +0200649/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000650
Paul Bakker33b43f12013-08-20 11:48:36 +0200651/* BEGIN_CASE */
652void mpi_inv_mod( int radix_X, char *input_X, int radix_Y, char *input_Y,
653 int radix_A, char *input_A, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000654{
655 mpi X, Y, Z, A;
656 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000657 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000658
Paul Bakker33b43f12013-08-20 11:48:36 +0200659 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
660 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
661 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000662 res = mpi_inv_mod( &Z, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200663 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000664 if( res == 0 )
665 {
666 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
667 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000668
669 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000670}
Paul Bakker33b43f12013-08-20 11:48:36 +0200671/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000672
Manuel Pégourié-Gonnarddf0142b2013-08-22 18:29:07 +0200673/* BEGIN_CASE depends_on:POLARSSL_GENPRIME */
Paul Bakker33b43f12013-08-20 11:48:36 +0200674void mpi_is_prime( int radix_X, char *input_X, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000675{
676 mpi X;
677 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000678 mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000679
Paul Bakker33b43f12013-08-20 11:48:36 +0200680 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
Paul Bakker5690efc2011-05-26 13:16:06 +0000681 res = mpi_is_prime( &X, rnd_std_rand, NULL );
Paul Bakker33b43f12013-08-20 11:48:36 +0200682 TEST_ASSERT( res == div_result );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000683
684 mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000685}
Paul Bakker33b43f12013-08-20 11:48:36 +0200686/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000687
Paul Bakker33b43f12013-08-20 11:48:36 +0200688/* BEGIN_CASE */
689void mpi_shift_l( int radix_X, char *input_X, int shift_X, int radix_A,
690 char *input_A)
Paul Bakker367dae42009-06-28 21:50:27 +0000691{
692 mpi X, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000693 mpi_init( &X ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000694
Paul Bakker33b43f12013-08-20 11:48:36 +0200695 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
696 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
697 TEST_ASSERT( mpi_shift_l( &X, shift_X ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000698 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000699
700 mpi_free( &X ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000701}
Paul Bakker33b43f12013-08-20 11:48:36 +0200702/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000703
Paul Bakker33b43f12013-08-20 11:48:36 +0200704/* BEGIN_CASE */
705void mpi_shift_r( int radix_X, char *input_X, int shift_X, int radix_A,
706 char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000707{
708 mpi X, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000709 mpi_init( &X ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000710
Paul Bakker33b43f12013-08-20 11:48:36 +0200711 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
712 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
713 TEST_ASSERT( mpi_shift_r( &X, shift_X ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000714 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000715
716 mpi_free( &X ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000717}
Paul Bakker33b43f12013-08-20 11:48:36 +0200718/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000719
Manuel Pégourié-Gonnard20140162013-10-10 12:48:03 +0200720/* BEGIN_CASE depends_on:POLARSSL_SELF_TEST */
Paul Bakker33b43f12013-08-20 11:48:36 +0200721void mpi_selftest()
Paul Bakkere896fea2009-07-06 06:40:23 +0000722{
723 TEST_ASSERT( mpi_self_test( 0 ) == 0 );
724}
Paul Bakker33b43f12013-08-20 11:48:36 +0200725/* END_CASE */