blob: 75c8d30f1944220efab3a71adc13c60704a83df5 [file] [log] [blame]
Paul Bakker33b43f12013-08-20 11:48:36 +02001/* BEGIN_HEADER */
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +00002#include "mbedtls/bignum.h"
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
Paul Bakkerbd51b262014-07-10 15:26:12 +020031exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +000032 mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +000033}
Paul Bakker33b43f12013-08-20 11:48:36 +020034/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +000035
Paul Bakker33b43f12013-08-20 11:48:36 +020036/* BEGIN_CASE */
37void mpi_read_binary( char *input_X, int radix_A, char *input_A )
Paul Bakkere896fea2009-07-06 06:40:23 +000038{
39 mpi X;
40 unsigned char str[1000];
41 unsigned char buf[1000];
Paul Bakkerf4a3f302011-04-24 15:53:29 +000042 size_t len = 1000;
43 size_t input_len;
Paul Bakkere896fea2009-07-06 06:40:23 +000044
Paul Bakker6c591fa2011-05-05 11:49:20 +000045 mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +000046
Paul Bakker33b43f12013-08-20 11:48:36 +020047 input_len = unhexify( buf, input_X );
Paul Bakkere896fea2009-07-06 06:40:23 +000048
49 TEST_ASSERT( mpi_read_binary( &X, buf, input_len ) == 0 );
Paul Bakker33b43f12013-08-20 11:48:36 +020050 TEST_ASSERT( mpi_write_string( &X, radix_A, (char *) str, &len ) == 0 );
51 TEST_ASSERT( strcmp( (char *) str, input_A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +000052
Paul Bakkerbd51b262014-07-10 15:26:12 +020053exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +000054 mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +000055}
Paul Bakker33b43f12013-08-20 11:48:36 +020056/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +000057
Paul Bakker33b43f12013-08-20 11:48:36 +020058/* BEGIN_CASE */
59void mpi_write_binary( int radix_X, char *input_X, char *input_A,
60 int output_size, int result )
Paul Bakkere896fea2009-07-06 06:40:23 +000061{
62 mpi X;
63 unsigned char str[1000];
64 unsigned char buf[1000];
Paul Bakkerf4a3f302011-04-24 15:53:29 +000065 size_t buflen;
Paul Bakkere896fea2009-07-06 06:40:23 +000066
67 memset( buf, 0x00, 1000 );
68 memset( str, 0x00, 1000 );
69
Paul Bakker6c591fa2011-05-05 11:49:20 +000070 mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +000071
Paul Bakker33b43f12013-08-20 11:48:36 +020072 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +000073
Paul Bakker69998dd2009-07-11 19:15:20 +000074 buflen = mpi_size( &X );
Paul Bakker33b43f12013-08-20 11:48:36 +020075 if( buflen > (size_t) output_size )
76 buflen = (size_t) output_size;
Paul Bakkere896fea2009-07-06 06:40:23 +000077
Paul Bakker33b43f12013-08-20 11:48:36 +020078 TEST_ASSERT( mpi_write_binary( &X, buf, buflen ) == result );
79 if( result == 0)
Paul Bakkerba48cb22009-07-12 11:01:32 +000080 {
81 hexify( str, buf, buflen );
Paul Bakkere896fea2009-07-06 06:40:23 +000082
Paul Bakker33b43f12013-08-20 11:48:36 +020083 TEST_ASSERT( strcasecmp( (char *) str, input_A ) == 0 );
Paul Bakkerba48cb22009-07-12 11:01:32 +000084 }
Paul Bakker6c591fa2011-05-05 11:49:20 +000085
Paul Bakkerbd51b262014-07-10 15:26:12 +020086exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +000087 mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +000088}
Paul Bakker33b43f12013-08-20 11:48:36 +020089/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +000090
Paul Bakker428b9ba2013-09-15 15:20:37 +020091/* BEGIN_CASE depends_on:POLARSSL_FS_IO */
Paul Bakker33b43f12013-08-20 11:48:36 +020092void mpi_read_file( int radix_X, char *input_file, char *input_A,
93 int result )
Paul Bakkere896fea2009-07-06 06:40:23 +000094{
95 mpi X;
96 unsigned char str[1000];
97 unsigned char buf[1000];
Paul Bakkerf4a3f302011-04-24 15:53:29 +000098 size_t buflen;
Paul Bakker69998dd2009-07-11 19:15:20 +000099 FILE *file;
Manuel Pégourié-Gonnarde43187d2015-02-14 16:01:34 +0000100 int ret;
Paul Bakkere896fea2009-07-06 06:40:23 +0000101
102 memset( buf, 0x00, 1000 );
103 memset( str, 0x00, 1000 );
104
Paul Bakker6c591fa2011-05-05 11:49:20 +0000105 mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000106
Paul Bakker33b43f12013-08-20 11:48:36 +0200107 file = fopen( input_file, "r" );
Paul Bakker8a0c0a92014-04-17 16:08:20 +0200108 TEST_ASSERT( file != NULL );
Manuel Pégourié-Gonnarde43187d2015-02-14 16:01:34 +0000109 ret = mpi_read_file( &X, radix_X, file );
Paul Bakkere896fea2009-07-06 06:40:23 +0000110 fclose(file);
Manuel Pégourié-Gonnarde43187d2015-02-14 16:01:34 +0000111 TEST_ASSERT( ret == result );
Paul Bakkere896fea2009-07-06 06:40:23 +0000112
Paul Bakker33b43f12013-08-20 11:48:36 +0200113 if( result == 0 )
Paul Bakkerba48cb22009-07-12 11:01:32 +0000114 {
115 buflen = mpi_size( &X );
116 TEST_ASSERT( mpi_write_binary( &X, buf, buflen ) == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000117
Paul Bakkerba48cb22009-07-12 11:01:32 +0000118 hexify( str, buf, buflen );
Paul Bakkere896fea2009-07-06 06:40:23 +0000119
Paul Bakker33b43f12013-08-20 11:48:36 +0200120 TEST_ASSERT( strcasecmp( (char *) str, input_A ) == 0 );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000121 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000122
Paul Bakkerbd51b262014-07-10 15:26:12 +0200123exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000124 mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000125}
Paul Bakker33b43f12013-08-20 11:48:36 +0200126/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000127
Paul Bakker428b9ba2013-09-15 15:20:37 +0200128/* BEGIN_CASE depends_on:POLARSSL_FS_IO */
Paul Bakker33b43f12013-08-20 11:48:36 +0200129void mpi_write_file( int radix_X, char *input_X, int output_radix,
130 char *output_file )
Paul Bakkere896fea2009-07-06 06:40:23 +0000131{
132 mpi X, Y;
Paul Bakker69998dd2009-07-11 19:15:20 +0000133 FILE *file_out, *file_in;
134
Paul Bakker6c591fa2011-05-05 11:49:20 +0000135 mpi_init( &X ); mpi_init( &Y );
Paul Bakkere896fea2009-07-06 06:40:23 +0000136
Paul Bakker33b43f12013-08-20 11:48:36 +0200137 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000138
Paul Bakker33b43f12013-08-20 11:48:36 +0200139 file_out = fopen( output_file, "w" );
Paul Bakker5690efc2011-05-26 13:16:06 +0000140 TEST_ASSERT( file_out != NULL );
Paul Bakker33b43f12013-08-20 11:48:36 +0200141 TEST_ASSERT( mpi_write_file( NULL, &X, output_radix, file_out ) == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000142 fclose(file_out);
143
Paul Bakker33b43f12013-08-20 11:48:36 +0200144 file_in = fopen( output_file, "r" );
Paul Bakker5690efc2011-05-26 13:16:06 +0000145 TEST_ASSERT( file_in != NULL );
Paul Bakker33b43f12013-08-20 11:48:36 +0200146 TEST_ASSERT( mpi_read_file( &Y, output_radix, file_in ) == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000147 fclose(file_in);
148
149 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000150
Paul Bakkerbd51b262014-07-10 15:26:12 +0200151exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000152 mpi_free( &X ); mpi_free( &Y );
Paul Bakkere896fea2009-07-06 06:40:23 +0000153}
Paul Bakker33b43f12013-08-20 11:48:36 +0200154/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000155
Paul Bakker33b43f12013-08-20 11:48:36 +0200156/* BEGIN_CASE */
157void mpi_get_bit( int radix_X, char *input_X, int pos, int val )
Paul Bakker2f5947e2011-05-18 15:47:11 +0000158{
159 mpi X;
160 mpi_init( &X );
Paul Bakker33b43f12013-08-20 11:48:36 +0200161 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
162 TEST_ASSERT( mpi_get_bit( &X, pos ) == val );
Paul Bakker2f5947e2011-05-18 15:47:11 +0000163
Paul Bakkerbd51b262014-07-10 15:26:12 +0200164exit:
Paul Bakker2f5947e2011-05-18 15:47:11 +0000165 mpi_free( &X );
166}
Paul Bakker33b43f12013-08-20 11:48:36 +0200167/* END_CASE */
Paul Bakker2f5947e2011-05-18 15:47:11 +0000168
Paul Bakker33b43f12013-08-20 11:48:36 +0200169/* BEGIN_CASE */
170void mpi_set_bit( int radix_X, char *input_X, int pos, int val, int radix_Y,
171 char *output_Y )
Paul Bakker2f5947e2011-05-18 15:47:11 +0000172{
173 mpi X, Y;
174 mpi_init( &X ); mpi_init( &Y );
175
Paul Bakker33b43f12013-08-20 11:48:36 +0200176 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
177 TEST_ASSERT( mpi_read_string( &Y, radix_Y, output_Y ) == 0 );
178 TEST_ASSERT( mpi_set_bit( &X, pos, val ) == 0 );
Paul Bakker2f5947e2011-05-18 15:47:11 +0000179 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == 0 );
180
Paul Bakkerbd51b262014-07-10 15:26:12 +0200181exit:
Manuel Pégourié-Gonnarde44ec102012-11-17 12:42:51 +0100182 mpi_free( &X ); mpi_free( &Y );
Paul Bakker2f5947e2011-05-18 15:47:11 +0000183}
Paul Bakker33b43f12013-08-20 11:48:36 +0200184/* END_CASE */
Paul Bakker2f5947e2011-05-18 15:47:11 +0000185
Paul Bakker33b43f12013-08-20 11:48:36 +0200186/* BEGIN_CASE */
187void mpi_lsb( int radix_X, char *input_X, int nr_bits )
Paul Bakkere896fea2009-07-06 06:40:23 +0000188{
189 mpi X;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000190 mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000191
Paul Bakker33b43f12013-08-20 11:48:36 +0200192 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
193 TEST_ASSERT( mpi_lsb( &X ) == (size_t) nr_bits );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000194
Paul Bakkerbd51b262014-07-10 15:26:12 +0200195exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000196 mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000197}
Paul Bakker33b43f12013-08-20 11:48:36 +0200198/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000199
Paul Bakker33b43f12013-08-20 11:48:36 +0200200/* BEGIN_CASE */
201void mpi_msb( int radix_X, char *input_X, int nr_bits )
Paul Bakkere896fea2009-07-06 06:40:23 +0000202{
203 mpi X;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000204 mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000205
Paul Bakker33b43f12013-08-20 11:48:36 +0200206 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
207 TEST_ASSERT( mpi_msb( &X ) == (size_t) nr_bits );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000208
Paul Bakkerbd51b262014-07-10 15:26:12 +0200209exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000210 mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000211}
Paul Bakker33b43f12013-08-20 11:48:36 +0200212/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000213
Paul Bakker33b43f12013-08-20 11:48:36 +0200214/* BEGIN_CASE */
215void mpi_gcd( int radix_X, char *input_X, int radix_Y, char *input_Y,
216 int radix_A, char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000217{
218 mpi A, X, Y, Z;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000219 mpi_init( &A ); mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z );
Paul Bakker367dae42009-06-28 21:50:27 +0000220
Paul Bakker33b43f12013-08-20 11:48:36 +0200221 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
222 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
223 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000224 TEST_ASSERT( mpi_gcd( &Z, &X, &Y ) == 0 );
225 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000226
Paul Bakkerbd51b262014-07-10 15:26:12 +0200227exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000228 mpi_free( &A ); mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z );
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_int( int input_X, int input_A, int result_CMP )
Paul Bakker367dae42009-06-28 21:50:27 +0000234{
235 mpi X;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000236 mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000237
Paul Bakker33b43f12013-08-20 11:48:36 +0200238 TEST_ASSERT( mpi_lset( &X, input_X ) == 0);
239 TEST_ASSERT( mpi_cmp_int( &X, input_A ) == result_CMP);
Paul Bakker6c591fa2011-05-05 11:49:20 +0000240
Paul Bakkerbd51b262014-07-10 15:26:12 +0200241exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000242 mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000243}
Paul Bakker33b43f12013-08-20 11:48:36 +0200244/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000245
Paul Bakker33b43f12013-08-20 11:48:36 +0200246/* BEGIN_CASE */
247void mpi_cmp_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
248 int input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000249{
250 mpi X, Y;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000251 mpi_init( &X ); mpi_init( &Y );
Paul Bakker367dae42009-06-28 21:50:27 +0000252
Paul Bakker33b43f12013-08-20 11:48:36 +0200253 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
254 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
255 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == input_A );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000256
Paul Bakkerbd51b262014-07-10 15:26:12 +0200257exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000258 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_cmp_abs( int radix_X, char *input_X, int radix_Y, char *input_Y,
264 int input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000265{
266 mpi X, Y;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000267 mpi_init( &X ); mpi_init( &Y );
Paul Bakker367dae42009-06-28 21:50:27 +0000268
Paul Bakker33b43f12013-08-20 11:48:36 +0200269 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
270 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
271 TEST_ASSERT( mpi_cmp_abs( &X, &Y ) == input_A );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000272
Paul Bakkerbd51b262014-07-10 15:26:12 +0200273exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000274 mpi_free( &X ); mpi_free( &Y );
Paul Bakker367dae42009-06-28 21:50:27 +0000275}
Paul Bakker33b43f12013-08-20 11:48:36 +0200276/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000277
Paul Bakker33b43f12013-08-20 11:48:36 +0200278/* BEGIN_CASE */
279void mpi_copy( int input_X, int input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000280{
281 mpi X, Y, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000282 mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000283
Paul Bakker33b43f12013-08-20 11:48:36 +0200284 TEST_ASSERT( mpi_lset( &X, input_X ) == 0 );
285 TEST_ASSERT( mpi_lset( &Y, input_A ) == 0 );
286 TEST_ASSERT( mpi_lset( &A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000287 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 );
288 TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) == 0 );
289 TEST_ASSERT( mpi_copy( &Y, &X ) == 0 );
290 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == 0 );
291 TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) != 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000292
Paul Bakkerbd51b262014-07-10 15:26:12 +0200293exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000294 mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000295}
Paul Bakker33b43f12013-08-20 11:48:36 +0200296/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000297
Paul Bakker33b43f12013-08-20 11:48:36 +0200298/* BEGIN_CASE */
299void mpi_copy_self( int input_X )
Paul Bakkere896fea2009-07-06 06:40:23 +0000300{
301 mpi X;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000302 mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000303
Paul Bakker33b43f12013-08-20 11:48:36 +0200304 TEST_ASSERT( mpi_lset( &X, input_X ) == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000305 TEST_ASSERT( mpi_copy( &X, &X ) == 0 );
Paul Bakker33b43f12013-08-20 11:48:36 +0200306 TEST_ASSERT( mpi_cmp_int( &X, input_X ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000307
Paul Bakkerbd51b262014-07-10 15:26:12 +0200308exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000309 mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000310}
Paul Bakker33b43f12013-08-20 11:48:36 +0200311/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000312
Paul Bakker33b43f12013-08-20 11:48:36 +0200313/* BEGIN_CASE */
Manuel Pégourié-Gonnard58681632013-11-21 10:39:37 +0100314void mpi_shrink( int before, int used, int min, int after )
315{
316 mpi X;
317 mpi_init( &X );
318
319 TEST_ASSERT( mpi_grow( &X, before ) == 0 );
320 TEST_ASSERT( used <= before );
321 memset( X.p, 0x2a, used * sizeof( t_uint ) );
322 TEST_ASSERT( mpi_shrink( &X, min ) == 0 );
323 TEST_ASSERT( X.n == (size_t) after );
324
Paul Bakkerbd51b262014-07-10 15:26:12 +0200325exit:
Manuel Pégourié-Gonnard58681632013-11-21 10:39:37 +0100326 mpi_free( &X );
327}
328/* END_CASE */
329
330/* BEGIN_CASE */
Manuel Pégourié-Gonnard3e3d2b82013-11-21 21:12:26 +0100331void mpi_safe_cond_assign( int x_sign, char *x_str,
332 int y_sign, char *y_str )
Manuel Pégourié-Gonnard71c2c212013-11-21 16:56:39 +0100333{
334 mpi X, Y, XX;
335 mpi_init( &X ); mpi_init( &Y ); mpi_init( &XX );
336
337 TEST_ASSERT( mpi_read_string( &X, 16, x_str ) == 0 );
Manuel Pégourié-Gonnard3e3d2b82013-11-21 21:12:26 +0100338 X.s = x_sign;
Manuel Pégourié-Gonnard71c2c212013-11-21 16:56:39 +0100339 TEST_ASSERT( mpi_read_string( &Y, 16, y_str ) == 0 );
Manuel Pégourié-Gonnard3e3d2b82013-11-21 21:12:26 +0100340 Y.s = y_sign;
Manuel Pégourié-Gonnard71c2c212013-11-21 16:56:39 +0100341 TEST_ASSERT( mpi_copy( &XX, &X ) == 0 );
342
343 TEST_ASSERT( mpi_safe_cond_assign( &X, &Y, 0 ) == 0 );
344 TEST_ASSERT( mpi_cmp_mpi( &X, &XX ) == 0 );
345
346 TEST_ASSERT( mpi_safe_cond_assign( &X, &Y, 1 ) == 0 );
347 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == 0 );
348
Paul Bakkerbd51b262014-07-10 15:26:12 +0200349exit:
Manuel Pégourié-Gonnard71c2c212013-11-21 16:56:39 +0100350 mpi_free( &X ); mpi_free( &Y ); mpi_free( &XX );
351}
352/* END_CASE */
353
354/* BEGIN_CASE */
Manuel Pégourié-Gonnarda60fe892013-12-04 21:41:50 +0100355void mpi_safe_cond_swap( int x_sign, char *x_str,
356 int y_sign, char *y_str )
357{
358 mpi X, Y, XX, YY;
359
360 mpi_init( &X ); mpi_init( &Y );
361 mpi_init( &XX ); mpi_init( &YY );
362
363 TEST_ASSERT( mpi_read_string( &X, 16, x_str ) == 0 );
364 X.s = x_sign;
365 TEST_ASSERT( mpi_read_string( &Y, 16, y_str ) == 0 );
366 Y.s = y_sign;
367
368 TEST_ASSERT( mpi_copy( &XX, &X ) == 0 );
369 TEST_ASSERT( mpi_copy( &YY, &Y ) == 0 );
370
371 TEST_ASSERT( mpi_safe_cond_swap( &X, &Y, 0 ) == 0 );
372 TEST_ASSERT( mpi_cmp_mpi( &X, &XX ) == 0 );
373 TEST_ASSERT( mpi_cmp_mpi( &Y, &YY ) == 0 );
374
375 TEST_ASSERT( mpi_safe_cond_swap( &X, &Y, 1 ) == 0 );
376 TEST_ASSERT( mpi_cmp_mpi( &Y, &XX ) == 0 );
377 TEST_ASSERT( mpi_cmp_mpi( &X, &YY ) == 0 );
378
Paul Bakkerbd51b262014-07-10 15:26:12 +0200379exit:
Manuel Pégourié-Gonnarda60fe892013-12-04 21:41:50 +0100380 mpi_free( &X ); mpi_free( &Y );
381 mpi_free( &XX ); mpi_free( &YY );
382}
383/* END_CASE */
384
385/* BEGIN_CASE */
Paul Bakker33b43f12013-08-20 11:48:36 +0200386void mpi_swap( int input_X, int input_Y )
Paul Bakker367dae42009-06-28 21:50:27 +0000387{
388 mpi X, Y, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000389 mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000390
Paul Bakker33b43f12013-08-20 11:48:36 +0200391 TEST_ASSERT( mpi_lset( &X, input_X ) == 0 );
392 TEST_ASSERT( mpi_lset( &Y, input_Y ) == 0 );
393 TEST_ASSERT( mpi_lset( &A, input_X ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000394 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 );
395 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
396 mpi_swap( &X, &Y );
397 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 );
398 TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000399
Paul Bakkerbd51b262014-07-10 15:26:12 +0200400exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000401 mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000402}
Paul Bakker33b43f12013-08-20 11:48:36 +0200403/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000404
Paul Bakker33b43f12013-08-20 11:48:36 +0200405/* BEGIN_CASE */
406void mpi_add_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
407 int radix_A, char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000408{
409 mpi X, Y, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000410 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000411
Paul Bakker33b43f12013-08-20 11:48:36 +0200412 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
413 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
414 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000415 TEST_ASSERT( mpi_add_mpi( &Z, &X, &Y ) == 0 );
416 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000417
Paul Bakkerbd51b262014-07-10 15:26:12 +0200418exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000419 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000420}
Paul Bakker33b43f12013-08-20 11:48:36 +0200421/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000422
Paul Bakker33b43f12013-08-20 11:48:36 +0200423/* BEGIN_CASE */
424void mpi_add_abs( int radix_X, char *input_X, int radix_Y, char *input_Y,
425 int radix_A, char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000426{
427 mpi X, Y, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000428 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000429
Paul Bakker33b43f12013-08-20 11:48:36 +0200430 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
431 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
432 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000433 TEST_ASSERT( mpi_add_abs( &Z, &X, &Y ) == 0 );
434 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000435
Paul Bakkerbd51b262014-07-10 15:26:12 +0200436exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000437 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000438}
Paul Bakker33b43f12013-08-20 11:48:36 +0200439/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000440
Paul Bakker33b43f12013-08-20 11:48:36 +0200441/* BEGIN_CASE */
442void mpi_add_abs_add_first( int radix_X, char *input_X, int radix_Y,
443 char *input_Y, int radix_A, char *input_A )
Paul Bakkerba48cb22009-07-12 11:01:32 +0000444{
445 mpi X, Y, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000446 mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000447
Paul Bakker33b43f12013-08-20 11:48:36 +0200448 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
449 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
450 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000451 TEST_ASSERT( mpi_add_abs( &X, &X, &Y ) == 0 );
452 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000453
Paul Bakkerbd51b262014-07-10 15:26:12 +0200454exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000455 mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000456}
Paul Bakker33b43f12013-08-20 11:48:36 +0200457/* END_CASE */
Paul Bakkerba48cb22009-07-12 11:01:32 +0000458
Paul Bakker33b43f12013-08-20 11:48:36 +0200459/* BEGIN_CASE */
460void mpi_add_abs_add_second( int radix_X, char *input_X, int radix_Y,
461 char *input_Y, int radix_A, char *input_A )
Paul Bakkerba48cb22009-07-12 11:01:32 +0000462{
463 mpi X, Y, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000464 mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000465
Paul Bakker33b43f12013-08-20 11:48:36 +0200466 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
467 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
468 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000469 TEST_ASSERT( mpi_add_abs( &Y, &X, &Y ) == 0 );
470 TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000471
Paul Bakkerbd51b262014-07-10 15:26:12 +0200472exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000473 mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000474}
Paul Bakker33b43f12013-08-20 11:48:36 +0200475/* END_CASE */
Paul Bakkerba48cb22009-07-12 11:01:32 +0000476
Paul Bakker33b43f12013-08-20 11:48:36 +0200477/* BEGIN_CASE */
478void mpi_add_int( int radix_X, char *input_X, int input_Y, int radix_A,
479 char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000480{
481 mpi X, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000482 mpi_init( &X ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000483
Paul Bakker33b43f12013-08-20 11:48:36 +0200484 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
485 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
486 TEST_ASSERT( mpi_add_int( &Z, &X, input_Y ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000487 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000488
Paul Bakkerbd51b262014-07-10 15:26:12 +0200489exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000490 mpi_free( &X ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000491}
Paul Bakker33b43f12013-08-20 11:48:36 +0200492/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000493
Paul Bakker33b43f12013-08-20 11:48:36 +0200494/* BEGIN_CASE */
495void mpi_sub_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
496 int radix_A, char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000497{
498 mpi X, Y, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000499 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000500
Paul Bakker33b43f12013-08-20 11:48:36 +0200501 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
502 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
503 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000504 TEST_ASSERT( mpi_sub_mpi( &Z, &X, &Y ) == 0 );
505 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000506
Paul Bakkerbd51b262014-07-10 15:26:12 +0200507exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000508 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000509}
Paul Bakker33b43f12013-08-20 11:48:36 +0200510/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000511
Paul Bakker33b43f12013-08-20 11:48:36 +0200512/* BEGIN_CASE */
513void mpi_sub_abs( int radix_X, char *input_X, int radix_Y, char *input_Y,
514 int radix_A, char *input_A, int sub_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000515{
516 mpi X, Y, Z, A;
517 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000518 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000519
Paul Bakker33b43f12013-08-20 11:48:36 +0200520 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
521 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
522 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000523
524 res = mpi_sub_abs( &Z, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200525 TEST_ASSERT( res == sub_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000526 if( res == 0 )
527 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000528
Paul Bakkerbd51b262014-07-10 15:26:12 +0200529exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000530 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000531}
Paul Bakker33b43f12013-08-20 11:48:36 +0200532/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000533
Paul Bakker33b43f12013-08-20 11:48:36 +0200534/* BEGIN_CASE */
535void mpi_sub_int( int radix_X, char *input_X, int input_Y, int radix_A,
536 char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000537{
538 mpi X, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000539 mpi_init( &X ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000540
Paul Bakker33b43f12013-08-20 11:48:36 +0200541 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
542 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
543 TEST_ASSERT( mpi_sub_int( &Z, &X, input_Y ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000544 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000545
Paul Bakkerbd51b262014-07-10 15:26:12 +0200546exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000547 mpi_free( &X ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000548}
Paul Bakker33b43f12013-08-20 11:48:36 +0200549/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000550
Paul Bakker33b43f12013-08-20 11:48:36 +0200551/* BEGIN_CASE */
552void mpi_mul_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
553 int radix_A, char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000554{
555 mpi X, Y, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000556 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000557
Paul Bakker33b43f12013-08-20 11:48:36 +0200558 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
559 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
560 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000561 TEST_ASSERT( mpi_mul_mpi( &Z, &X, &Y ) == 0 );
562 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000563
Paul Bakkerbd51b262014-07-10 15:26:12 +0200564exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000565 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000566}
Paul Bakker33b43f12013-08-20 11:48:36 +0200567/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000568
Paul Bakker33b43f12013-08-20 11:48:36 +0200569/* BEGIN_CASE */
570void mpi_mul_int( int radix_X, char *input_X, int input_Y, int radix_A,
571 char *input_A, char *result_comparison )
Paul Bakker367dae42009-06-28 21:50:27 +0000572{
573 mpi X, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000574 mpi_init( &X ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000575
Paul Bakker33b43f12013-08-20 11:48:36 +0200576 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
577 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
578 TEST_ASSERT( mpi_mul_int( &Z, &X, input_Y ) == 0 );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200579 if( strcmp( result_comparison, "==" ) == 0 )
580 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
581 else if( strcmp( result_comparison, "!=" ) == 0 )
582 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) != 0 );
583 else
584 TEST_ASSERT( "unknown operator" == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000585
Paul Bakkerbd51b262014-07-10 15:26:12 +0200586exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000587 mpi_free( &X ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000588}
Paul Bakker33b43f12013-08-20 11:48:36 +0200589/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000590
Paul Bakker33b43f12013-08-20 11:48:36 +0200591/* BEGIN_CASE */
592void mpi_div_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
593 int radix_A, char *input_A, int radix_B, char *input_B,
594 int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000595{
596 mpi X, Y, Q, R, A, B;
597 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000598 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Q ); mpi_init( &R );
599 mpi_init( &A ); mpi_init( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000600
Paul Bakker33b43f12013-08-20 11:48:36 +0200601 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
602 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
603 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
604 TEST_ASSERT( mpi_read_string( &B, radix_B, input_B ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000605 res = mpi_div_mpi( &Q, &R, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200606 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000607 if( res == 0 )
608 {
609 TEST_ASSERT( mpi_cmp_mpi( &Q, &A ) == 0 );
610 TEST_ASSERT( mpi_cmp_mpi( &R, &B ) == 0 );
611 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000612
Paul Bakkerbd51b262014-07-10 15:26:12 +0200613exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000614 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Q ); mpi_free( &R );
615 mpi_free( &A ); mpi_free( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000616}
Paul Bakker33b43f12013-08-20 11:48:36 +0200617/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000618
Paul Bakker33b43f12013-08-20 11:48:36 +0200619/* BEGIN_CASE */
620void mpi_div_int( int radix_X, char *input_X, int input_Y, int radix_A,
621 char *input_A, int radix_B, char *input_B, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000622{
623 mpi X, Q, R, A, B;
624 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000625 mpi_init( &X ); mpi_init( &Q ); mpi_init( &R ); mpi_init( &A );
626 mpi_init( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000627
Paul Bakker33b43f12013-08-20 11:48:36 +0200628 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
629 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
630 TEST_ASSERT( mpi_read_string( &B, radix_B, input_B ) == 0 );
631 res = mpi_div_int( &Q, &R, &X, input_Y );
632 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000633 if( res == 0 )
634 {
635 TEST_ASSERT( mpi_cmp_mpi( &Q, &A ) == 0 );
636 TEST_ASSERT( mpi_cmp_mpi( &R, &B ) == 0 );
637 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000638
Paul Bakkerbd51b262014-07-10 15:26:12 +0200639exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000640 mpi_free( &X ); mpi_free( &Q ); mpi_free( &R ); mpi_free( &A );
641 mpi_free( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000642}
Paul Bakker33b43f12013-08-20 11:48:36 +0200643/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000644
Paul Bakker33b43f12013-08-20 11:48:36 +0200645/* BEGIN_CASE */
646void mpi_mod_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
647 int radix_A, char *input_A, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000648{
Paul Bakkerf02c5642012-11-13 10:25:21 +0000649 mpi X, Y, A;
Paul Bakker367dae42009-06-28 21:50:27 +0000650 int res;
Paul Bakkerf02c5642012-11-13 10:25:21 +0000651 mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000652
Paul Bakker33b43f12013-08-20 11:48:36 +0200653 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
654 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
655 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakkerf02c5642012-11-13 10:25:21 +0000656 res = mpi_mod_mpi( &X, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200657 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000658 if( res == 0 )
659 {
Paul Bakkerf02c5642012-11-13 10:25:21 +0000660 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000661 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000662
Paul Bakkerbd51b262014-07-10 15:26:12 +0200663exit:
Paul Bakkerf02c5642012-11-13 10:25:21 +0000664 mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
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_mod_int( int radix_X, char *input_X, int input_Y, int input_A,
670 int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000671{
672 mpi X;
673 int res;
Paul Bakkera755ca12011-04-24 09:11:17 +0000674 t_uint r;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000675 mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000676
Paul Bakker33b43f12013-08-20 11:48:36 +0200677 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
678 res = mpi_mod_int( &r, &X, input_Y );
679 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000680 if( res == 0 )
681 {
Paul Bakker33b43f12013-08-20 11:48:36 +0200682 TEST_ASSERT( r == (t_uint) input_A );
Paul Bakker367dae42009-06-28 21:50:27 +0000683 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000684
Paul Bakkerbd51b262014-07-10 15:26:12 +0200685exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000686 mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000687}
Paul Bakker33b43f12013-08-20 11:48:36 +0200688/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000689
Paul Bakker33b43f12013-08-20 11:48:36 +0200690/* BEGIN_CASE */
691void mpi_exp_mod( int radix_A, char *input_A, int radix_E, char *input_E,
692 int radix_N, char *input_N, int radix_RR, char *input_RR,
693 int radix_X, char *input_X, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000694{
695 mpi A, E, N, RR, Z, X;
696 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000697 mpi_init( &A ); mpi_init( &E ); mpi_init( &N );
698 mpi_init( &RR ); mpi_init( &Z ); mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000699
Paul Bakker33b43f12013-08-20 11:48:36 +0200700 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
701 TEST_ASSERT( mpi_read_string( &E, radix_E, input_E ) == 0 );
702 TEST_ASSERT( mpi_read_string( &N, radix_N, input_N ) == 0 );
703 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000704
Paul Bakker33b43f12013-08-20 11:48:36 +0200705 if( strlen( input_RR ) )
706 TEST_ASSERT( mpi_read_string( &RR, radix_RR, input_RR ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000707
708 res = mpi_exp_mod( &Z, &A, &E, &N, &RR );
Paul Bakker33b43f12013-08-20 11:48:36 +0200709 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000710 if( res == 0 )
711 {
712 TEST_ASSERT( mpi_cmp_mpi( &Z, &X ) == 0 );
713 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000714
Paul Bakkerbd51b262014-07-10 15:26:12 +0200715exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000716 mpi_free( &A ); mpi_free( &E ); mpi_free( &N );
717 mpi_free( &RR ); mpi_free( &Z ); 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_inv_mod( int radix_X, char *input_X, int radix_Y, char *input_Y,
723 int radix_A, char *input_A, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000724{
725 mpi X, Y, Z, A;
726 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000727 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000728
Paul Bakker33b43f12013-08-20 11:48:36 +0200729 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
730 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
731 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000732 res = mpi_inv_mod( &Z, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200733 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000734 if( res == 0 )
735 {
736 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
737 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000738
Paul Bakkerbd51b262014-07-10 15:26:12 +0200739exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000740 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000741}
Paul Bakker33b43f12013-08-20 11:48:36 +0200742/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000743
Manuel Pégourié-Gonnarddf0142b2013-08-22 18:29:07 +0200744/* BEGIN_CASE depends_on:POLARSSL_GENPRIME */
Paul Bakker33b43f12013-08-20 11:48:36 +0200745void mpi_is_prime( int radix_X, char *input_X, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000746{
747 mpi X;
748 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000749 mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000750
Paul Bakker33b43f12013-08-20 11:48:36 +0200751 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
Paul Bakker5690efc2011-05-26 13:16:06 +0000752 res = mpi_is_prime( &X, rnd_std_rand, NULL );
Paul Bakker33b43f12013-08-20 11:48:36 +0200753 TEST_ASSERT( res == div_result );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000754
Paul Bakkerbd51b262014-07-10 15:26:12 +0200755exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000756 mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000757}
Paul Bakker33b43f12013-08-20 11:48:36 +0200758/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000759
Manuel Pégourié-Gonnard15f58a82014-06-16 17:12:40 +0200760/* BEGIN_CASE depends_on:POLARSSL_GENPRIME */
761void mpi_gen_prime( int bits, int safe, int ref_ret )
762{
763 mpi X;
764 int my_ret;
765
766 mpi_init( &X );
767
768 my_ret = mpi_gen_prime( &X, bits, safe, rnd_std_rand, NULL );
769 TEST_ASSERT( my_ret == ref_ret );
770
771 if( ref_ret == 0 )
772 {
773 size_t actual_bits = mpi_msb( &X );
774
775 TEST_ASSERT( actual_bits >= (size_t) bits );
776 TEST_ASSERT( actual_bits <= (size_t) bits + 1 );
777
778 TEST_ASSERT( mpi_is_prime( &X, rnd_std_rand, NULL ) == 0 );
779 if( safe )
780 {
781 mpi_shift_r( &X, 1 ); /* X = ( X - 1 ) / 2 */
782 TEST_ASSERT( mpi_is_prime( &X, rnd_std_rand, NULL ) == 0 );
783 }
784 }
785
Paul Bakkerbd51b262014-07-10 15:26:12 +0200786exit:
Manuel Pégourié-Gonnard15f58a82014-06-16 17:12:40 +0200787 mpi_free( &X );
788}
789/* END_CASE */
790
Paul Bakker33b43f12013-08-20 11:48:36 +0200791/* BEGIN_CASE */
792void mpi_shift_l( int radix_X, char *input_X, int shift_X, int radix_A,
793 char *input_A)
Paul Bakker367dae42009-06-28 21:50:27 +0000794{
795 mpi X, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000796 mpi_init( &X ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000797
Paul Bakker33b43f12013-08-20 11:48:36 +0200798 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
799 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
800 TEST_ASSERT( mpi_shift_l( &X, shift_X ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000801 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000802
Paul Bakkerbd51b262014-07-10 15:26:12 +0200803exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000804 mpi_free( &X ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000805}
Paul Bakker33b43f12013-08-20 11:48:36 +0200806/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000807
Paul Bakker33b43f12013-08-20 11:48:36 +0200808/* BEGIN_CASE */
809void mpi_shift_r( int radix_X, char *input_X, int shift_X, int radix_A,
810 char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000811{
812 mpi X, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000813 mpi_init( &X ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000814
Paul Bakker33b43f12013-08-20 11:48:36 +0200815 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
816 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
817 TEST_ASSERT( mpi_shift_r( &X, shift_X ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000818 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000819
Paul Bakkerbd51b262014-07-10 15:26:12 +0200820exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000821 mpi_free( &X ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000822}
Paul Bakker33b43f12013-08-20 11:48:36 +0200823/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000824
Manuel Pégourié-Gonnard20140162013-10-10 12:48:03 +0200825/* BEGIN_CASE depends_on:POLARSSL_SELF_TEST */
Paul Bakker33b43f12013-08-20 11:48:36 +0200826void mpi_selftest()
Paul Bakkere896fea2009-07-06 06:40:23 +0000827{
828 TEST_ASSERT( mpi_self_test( 0 ) == 0 );
829}
Paul Bakker33b43f12013-08-20 11:48:36 +0200830/* END_CASE */