blob: 023cab412502e461cc08d816b9ee27f38e2494a6 [file] [log] [blame]
Paul Bakker33b43f12013-08-20 11:48:36 +02001/* BEGIN_HEADER */
Rich Evansce2f2372015-02-06 13:57:42 +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 */
Manuel Pégourié-Gonnard770b5e12015-04-29 17:02:01 +020011void mpi_null( )
12{
13 mpi X, Y, Z;
14
15 mpi_init( &X );
16 mpi_init( &Y );
17 mpi_init( &Z );
18
19 TEST_ASSERT( mpi_get_bit( &X, 42 ) == 0 );
20 TEST_ASSERT( mpi_lsb( &X ) == 0 );
21 TEST_ASSERT( mpi_msb( &X ) == 0 );
22 TEST_ASSERT( mpi_size( &X ) == 0 );
23
24exit:
25 mpi_free( &X );
26}
27/* END_CASE */
28
29/* BEGIN_CASE */
Paul Bakker33b43f12013-08-20 11:48:36 +020030void mpi_read_write_string( int radix_X, char *input_X, int radix_A,
31 char *input_A, int output_size, int result_read,
32 int result_write )
Paul Bakker367dae42009-06-28 21:50:27 +000033{
34 mpi X;
35 char str[1000];
Paul Bakker33b43f12013-08-20 11:48:36 +020036 size_t len = output_size;
Paul Bakker367dae42009-06-28 21:50:27 +000037
Paul Bakker6c591fa2011-05-05 11:49:20 +000038 mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +000039
Paul Bakker33b43f12013-08-20 11:48:36 +020040 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == result_read );
41 if( result_read == 0 )
Paul Bakkerba48cb22009-07-12 11:01:32 +000042 {
Paul Bakker33b43f12013-08-20 11:48:36 +020043 TEST_ASSERT( mpi_write_string( &X, radix_A, str, &len ) == result_write );
44 if( result_write == 0 )
Paul Bakkerba48cb22009-07-12 11:01:32 +000045 {
Paul Bakker33b43f12013-08-20 11:48:36 +020046 TEST_ASSERT( strcasecmp( str, input_A ) == 0 );
Paul Bakkerba48cb22009-07-12 11:01:32 +000047 }
48 }
Paul Bakker6c591fa2011-05-05 11:49:20 +000049
Paul Bakkerbd51b262014-07-10 15:26:12 +020050exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +000051 mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +000052}
Paul Bakker33b43f12013-08-20 11:48:36 +020053/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +000054
Paul Bakker33b43f12013-08-20 11:48:36 +020055/* BEGIN_CASE */
56void mpi_read_binary( char *input_X, int radix_A, char *input_A )
Paul Bakkere896fea2009-07-06 06:40:23 +000057{
58 mpi X;
59 unsigned char str[1000];
60 unsigned char buf[1000];
Paul Bakkerf4a3f302011-04-24 15:53:29 +000061 size_t len = 1000;
62 size_t input_len;
Paul Bakkere896fea2009-07-06 06:40:23 +000063
Paul Bakker6c591fa2011-05-05 11:49:20 +000064 mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +000065
Paul Bakker33b43f12013-08-20 11:48:36 +020066 input_len = unhexify( buf, input_X );
Paul Bakkere896fea2009-07-06 06:40:23 +000067
68 TEST_ASSERT( mpi_read_binary( &X, buf, input_len ) == 0 );
Paul Bakker33b43f12013-08-20 11:48:36 +020069 TEST_ASSERT( mpi_write_string( &X, radix_A, (char *) str, &len ) == 0 );
70 TEST_ASSERT( strcmp( (char *) str, input_A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +000071
Paul Bakkerbd51b262014-07-10 15:26:12 +020072exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +000073 mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +000074}
Paul Bakker33b43f12013-08-20 11:48:36 +020075/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +000076
Paul Bakker33b43f12013-08-20 11:48:36 +020077/* BEGIN_CASE */
78void mpi_write_binary( int radix_X, char *input_X, char *input_A,
79 int output_size, int result )
Paul Bakkere896fea2009-07-06 06:40:23 +000080{
81 mpi X;
82 unsigned char str[1000];
83 unsigned char buf[1000];
Paul Bakkerf4a3f302011-04-24 15:53:29 +000084 size_t buflen;
Paul Bakkere896fea2009-07-06 06:40:23 +000085
86 memset( buf, 0x00, 1000 );
87 memset( str, 0x00, 1000 );
88
Paul Bakker6c591fa2011-05-05 11:49:20 +000089 mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +000090
Paul Bakker33b43f12013-08-20 11:48:36 +020091 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +000092
Paul Bakker69998dd2009-07-11 19:15:20 +000093 buflen = mpi_size( &X );
Paul Bakker33b43f12013-08-20 11:48:36 +020094 if( buflen > (size_t) output_size )
95 buflen = (size_t) output_size;
Paul Bakkere896fea2009-07-06 06:40:23 +000096
Paul Bakker33b43f12013-08-20 11:48:36 +020097 TEST_ASSERT( mpi_write_binary( &X, buf, buflen ) == result );
98 if( result == 0)
Paul Bakkerba48cb22009-07-12 11:01:32 +000099 {
100 hexify( str, buf, buflen );
Paul Bakkere896fea2009-07-06 06:40:23 +0000101
Paul Bakker33b43f12013-08-20 11:48:36 +0200102 TEST_ASSERT( strcasecmp( (char *) str, input_A ) == 0 );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000103 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000104
Paul Bakkerbd51b262014-07-10 15:26:12 +0200105exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000106 mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000107}
Paul Bakker33b43f12013-08-20 11:48:36 +0200108/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000109
Paul Bakker428b9ba2013-09-15 15:20:37 +0200110/* BEGIN_CASE depends_on:POLARSSL_FS_IO */
Paul Bakker33b43f12013-08-20 11:48:36 +0200111void mpi_read_file( int radix_X, char *input_file, char *input_A,
112 int result )
Paul Bakkere896fea2009-07-06 06:40:23 +0000113{
114 mpi X;
115 unsigned char str[1000];
116 unsigned char buf[1000];
Paul Bakkerf4a3f302011-04-24 15:53:29 +0000117 size_t buflen;
Paul Bakker69998dd2009-07-11 19:15:20 +0000118 FILE *file;
Manuel Pégourié-Gonnarde43187d2015-02-14 16:01:34 +0000119 int ret;
Paul Bakkere896fea2009-07-06 06:40:23 +0000120
121 memset( buf, 0x00, 1000 );
122 memset( str, 0x00, 1000 );
123
Paul Bakker6c591fa2011-05-05 11:49:20 +0000124 mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000125
Paul Bakker33b43f12013-08-20 11:48:36 +0200126 file = fopen( input_file, "r" );
Paul Bakker8a0c0a92014-04-17 16:08:20 +0200127 TEST_ASSERT( file != NULL );
Manuel Pégourié-Gonnarde43187d2015-02-14 16:01:34 +0000128 ret = mpi_read_file( &X, radix_X, file );
Paul Bakkere896fea2009-07-06 06:40:23 +0000129 fclose(file);
Manuel Pégourié-Gonnarde43187d2015-02-14 16:01:34 +0000130 TEST_ASSERT( ret == result );
Paul Bakkere896fea2009-07-06 06:40:23 +0000131
Paul Bakker33b43f12013-08-20 11:48:36 +0200132 if( result == 0 )
Paul Bakkerba48cb22009-07-12 11:01:32 +0000133 {
134 buflen = mpi_size( &X );
135 TEST_ASSERT( mpi_write_binary( &X, buf, buflen ) == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000136
Paul Bakkerba48cb22009-07-12 11:01:32 +0000137 hexify( str, buf, buflen );
Paul Bakkere896fea2009-07-06 06:40:23 +0000138
Paul Bakker33b43f12013-08-20 11:48:36 +0200139 TEST_ASSERT( strcasecmp( (char *) str, input_A ) == 0 );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000140 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000141
Paul Bakkerbd51b262014-07-10 15:26:12 +0200142exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000143 mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000144}
Paul Bakker33b43f12013-08-20 11:48:36 +0200145/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000146
Paul Bakker428b9ba2013-09-15 15:20:37 +0200147/* BEGIN_CASE depends_on:POLARSSL_FS_IO */
Paul Bakker33b43f12013-08-20 11:48:36 +0200148void mpi_write_file( int radix_X, char *input_X, int output_radix,
149 char *output_file )
Paul Bakkere896fea2009-07-06 06:40:23 +0000150{
151 mpi X, Y;
Paul Bakker69998dd2009-07-11 19:15:20 +0000152 FILE *file_out, *file_in;
153
Paul Bakker6c591fa2011-05-05 11:49:20 +0000154 mpi_init( &X ); mpi_init( &Y );
Paul Bakkere896fea2009-07-06 06:40:23 +0000155
Paul Bakker33b43f12013-08-20 11:48:36 +0200156 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000157
Paul Bakker33b43f12013-08-20 11:48:36 +0200158 file_out = fopen( output_file, "w" );
Paul Bakker5690efc2011-05-26 13:16:06 +0000159 TEST_ASSERT( file_out != NULL );
Paul Bakker33b43f12013-08-20 11:48:36 +0200160 TEST_ASSERT( mpi_write_file( NULL, &X, output_radix, file_out ) == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000161 fclose(file_out);
162
Paul Bakker33b43f12013-08-20 11:48:36 +0200163 file_in = fopen( output_file, "r" );
Paul Bakker5690efc2011-05-26 13:16:06 +0000164 TEST_ASSERT( file_in != NULL );
Paul Bakker33b43f12013-08-20 11:48:36 +0200165 TEST_ASSERT( mpi_read_file( &Y, output_radix, file_in ) == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000166 fclose(file_in);
167
168 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000169
Paul Bakkerbd51b262014-07-10 15:26:12 +0200170exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000171 mpi_free( &X ); mpi_free( &Y );
Paul Bakkere896fea2009-07-06 06:40:23 +0000172}
Paul Bakker33b43f12013-08-20 11:48:36 +0200173/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000174
Paul Bakker33b43f12013-08-20 11:48:36 +0200175/* BEGIN_CASE */
176void mpi_get_bit( int radix_X, char *input_X, int pos, int val )
Paul Bakker2f5947e2011-05-18 15:47:11 +0000177{
178 mpi X;
179 mpi_init( &X );
Paul Bakker33b43f12013-08-20 11:48:36 +0200180 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
181 TEST_ASSERT( mpi_get_bit( &X, pos ) == val );
Paul Bakker2f5947e2011-05-18 15:47:11 +0000182
Paul Bakkerbd51b262014-07-10 15:26:12 +0200183exit:
Paul Bakker2f5947e2011-05-18 15:47:11 +0000184 mpi_free( &X );
185}
Paul Bakker33b43f12013-08-20 11:48:36 +0200186/* END_CASE */
Paul Bakker2f5947e2011-05-18 15:47:11 +0000187
Paul Bakker33b43f12013-08-20 11:48:36 +0200188/* BEGIN_CASE */
189void mpi_set_bit( int radix_X, char *input_X, int pos, int val, int radix_Y,
190 char *output_Y )
Paul Bakker2f5947e2011-05-18 15:47:11 +0000191{
192 mpi X, Y;
193 mpi_init( &X ); mpi_init( &Y );
194
Paul Bakker33b43f12013-08-20 11:48:36 +0200195 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
196 TEST_ASSERT( mpi_read_string( &Y, radix_Y, output_Y ) == 0 );
197 TEST_ASSERT( mpi_set_bit( &X, pos, val ) == 0 );
Paul Bakker2f5947e2011-05-18 15:47:11 +0000198 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == 0 );
199
Paul Bakkerbd51b262014-07-10 15:26:12 +0200200exit:
Manuel Pégourié-Gonnarde44ec102012-11-17 12:42:51 +0100201 mpi_free( &X ); mpi_free( &Y );
Paul Bakker2f5947e2011-05-18 15:47:11 +0000202}
Paul Bakker33b43f12013-08-20 11:48:36 +0200203/* END_CASE */
Paul Bakker2f5947e2011-05-18 15:47:11 +0000204
Paul Bakker33b43f12013-08-20 11:48:36 +0200205/* BEGIN_CASE */
206void mpi_lsb( int radix_X, char *input_X, int nr_bits )
Paul Bakkere896fea2009-07-06 06:40:23 +0000207{
208 mpi X;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000209 mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000210
Paul Bakker33b43f12013-08-20 11:48:36 +0200211 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
212 TEST_ASSERT( mpi_lsb( &X ) == (size_t) nr_bits );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000213
Paul Bakkerbd51b262014-07-10 15:26:12 +0200214exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000215 mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000216}
Paul Bakker33b43f12013-08-20 11:48:36 +0200217/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000218
Paul Bakker33b43f12013-08-20 11:48:36 +0200219/* BEGIN_CASE */
220void mpi_msb( int radix_X, char *input_X, int nr_bits )
Paul Bakkere896fea2009-07-06 06:40:23 +0000221{
222 mpi X;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000223 mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000224
Paul Bakker33b43f12013-08-20 11:48:36 +0200225 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
226 TEST_ASSERT( mpi_msb( &X ) == (size_t) nr_bits );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000227
Paul Bakkerbd51b262014-07-10 15:26:12 +0200228exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000229 mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000230}
Paul Bakker33b43f12013-08-20 11:48:36 +0200231/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000232
Paul Bakker33b43f12013-08-20 11:48:36 +0200233/* BEGIN_CASE */
234void mpi_gcd( int radix_X, char *input_X, int radix_Y, char *input_Y,
235 int radix_A, char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000236{
237 mpi A, X, Y, Z;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000238 mpi_init( &A ); mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z );
Paul Bakker367dae42009-06-28 21:50:27 +0000239
Paul Bakker33b43f12013-08-20 11:48:36 +0200240 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
241 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
242 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000243 TEST_ASSERT( mpi_gcd( &Z, &X, &Y ) == 0 );
244 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000245
Paul Bakkerbd51b262014-07-10 15:26:12 +0200246exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000247 mpi_free( &A ); mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z );
Paul Bakker367dae42009-06-28 21:50:27 +0000248}
Paul Bakker33b43f12013-08-20 11:48:36 +0200249/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000250
Paul Bakker33b43f12013-08-20 11:48:36 +0200251/* BEGIN_CASE */
252void mpi_cmp_int( int input_X, int input_A, int result_CMP )
Paul Bakker367dae42009-06-28 21:50:27 +0000253{
254 mpi X;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000255 mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000256
Paul Bakker33b43f12013-08-20 11:48:36 +0200257 TEST_ASSERT( mpi_lset( &X, input_X ) == 0);
258 TEST_ASSERT( mpi_cmp_int( &X, input_A ) == result_CMP);
Paul Bakker6c591fa2011-05-05 11:49:20 +0000259
Paul Bakkerbd51b262014-07-10 15:26:12 +0200260exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000261 mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000262}
Paul Bakker33b43f12013-08-20 11:48:36 +0200263/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000264
Paul Bakker33b43f12013-08-20 11:48:36 +0200265/* BEGIN_CASE */
266void mpi_cmp_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
267 int input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000268{
269 mpi X, Y;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000270 mpi_init( &X ); mpi_init( &Y );
Paul Bakker367dae42009-06-28 21:50:27 +0000271
Paul Bakker33b43f12013-08-20 11:48:36 +0200272 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
273 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
274 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == input_A );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000275
Paul Bakkerbd51b262014-07-10 15:26:12 +0200276exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000277 mpi_free( &X ); mpi_free( &Y );
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_cmp_abs( int radix_X, char *input_X, int radix_Y, char *input_Y,
283 int input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000284{
285 mpi X, Y;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000286 mpi_init( &X ); mpi_init( &Y );
Paul Bakker367dae42009-06-28 21:50:27 +0000287
Paul Bakker33b43f12013-08-20 11:48:36 +0200288 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
289 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
290 TEST_ASSERT( mpi_cmp_abs( &X, &Y ) == input_A );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000291
Paul Bakkerbd51b262014-07-10 15:26:12 +0200292exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000293 mpi_free( &X ); mpi_free( &Y );
Paul Bakker367dae42009-06-28 21:50:27 +0000294}
Paul Bakker33b43f12013-08-20 11:48:36 +0200295/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000296
Paul Bakker33b43f12013-08-20 11:48:36 +0200297/* BEGIN_CASE */
298void mpi_copy( int input_X, int input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000299{
300 mpi X, Y, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000301 mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000302
Paul Bakker33b43f12013-08-20 11:48:36 +0200303 TEST_ASSERT( mpi_lset( &X, input_X ) == 0 );
304 TEST_ASSERT( mpi_lset( &Y, input_A ) == 0 );
305 TEST_ASSERT( mpi_lset( &A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000306 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 );
307 TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) == 0 );
308 TEST_ASSERT( mpi_copy( &Y, &X ) == 0 );
309 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == 0 );
310 TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) != 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000311
Paul Bakkerbd51b262014-07-10 15:26:12 +0200312exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000313 mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000314}
Paul Bakker33b43f12013-08-20 11:48:36 +0200315/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000316
Paul Bakker33b43f12013-08-20 11:48:36 +0200317/* BEGIN_CASE */
318void mpi_copy_self( int input_X )
Paul Bakkere896fea2009-07-06 06:40:23 +0000319{
320 mpi X;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000321 mpi_init( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000322
Paul Bakker33b43f12013-08-20 11:48:36 +0200323 TEST_ASSERT( mpi_lset( &X, input_X ) == 0 );
Paul Bakkere896fea2009-07-06 06:40:23 +0000324 TEST_ASSERT( mpi_copy( &X, &X ) == 0 );
Paul Bakker33b43f12013-08-20 11:48:36 +0200325 TEST_ASSERT( mpi_cmp_int( &X, input_X ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000326
Paul Bakkerbd51b262014-07-10 15:26:12 +0200327exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000328 mpi_free( &X );
Paul Bakkere896fea2009-07-06 06:40:23 +0000329}
Paul Bakker33b43f12013-08-20 11:48:36 +0200330/* END_CASE */
Paul Bakkere896fea2009-07-06 06:40:23 +0000331
Paul Bakker33b43f12013-08-20 11:48:36 +0200332/* BEGIN_CASE */
Manuel Pégourié-Gonnard58681632013-11-21 10:39:37 +0100333void mpi_shrink( int before, int used, int min, int after )
334{
335 mpi X;
336 mpi_init( &X );
337
338 TEST_ASSERT( mpi_grow( &X, before ) == 0 );
339 TEST_ASSERT( used <= before );
340 memset( X.p, 0x2a, used * sizeof( t_uint ) );
341 TEST_ASSERT( mpi_shrink( &X, min ) == 0 );
342 TEST_ASSERT( X.n == (size_t) after );
343
Paul Bakkerbd51b262014-07-10 15:26:12 +0200344exit:
Manuel Pégourié-Gonnard58681632013-11-21 10:39:37 +0100345 mpi_free( &X );
346}
347/* END_CASE */
348
349/* BEGIN_CASE */
Manuel Pégourié-Gonnard3e3d2b82013-11-21 21:12:26 +0100350void mpi_safe_cond_assign( int x_sign, char *x_str,
351 int y_sign, char *y_str )
Manuel Pégourié-Gonnard71c2c212013-11-21 16:56:39 +0100352{
353 mpi X, Y, XX;
354 mpi_init( &X ); mpi_init( &Y ); mpi_init( &XX );
355
356 TEST_ASSERT( mpi_read_string( &X, 16, x_str ) == 0 );
Manuel Pégourié-Gonnard3e3d2b82013-11-21 21:12:26 +0100357 X.s = x_sign;
Manuel Pégourié-Gonnard71c2c212013-11-21 16:56:39 +0100358 TEST_ASSERT( mpi_read_string( &Y, 16, y_str ) == 0 );
Manuel Pégourié-Gonnard3e3d2b82013-11-21 21:12:26 +0100359 Y.s = y_sign;
Manuel Pégourié-Gonnard71c2c212013-11-21 16:56:39 +0100360 TEST_ASSERT( mpi_copy( &XX, &X ) == 0 );
361
362 TEST_ASSERT( mpi_safe_cond_assign( &X, &Y, 0 ) == 0 );
363 TEST_ASSERT( mpi_cmp_mpi( &X, &XX ) == 0 );
364
365 TEST_ASSERT( mpi_safe_cond_assign( &X, &Y, 1 ) == 0 );
366 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == 0 );
367
Paul Bakkerbd51b262014-07-10 15:26:12 +0200368exit:
Manuel Pégourié-Gonnard71c2c212013-11-21 16:56:39 +0100369 mpi_free( &X ); mpi_free( &Y ); mpi_free( &XX );
370}
371/* END_CASE */
372
373/* BEGIN_CASE */
Manuel Pégourié-Gonnarda60fe892013-12-04 21:41:50 +0100374void mpi_safe_cond_swap( int x_sign, char *x_str,
375 int y_sign, char *y_str )
376{
377 mpi X, Y, XX, YY;
378
379 mpi_init( &X ); mpi_init( &Y );
380 mpi_init( &XX ); mpi_init( &YY );
381
382 TEST_ASSERT( mpi_read_string( &X, 16, x_str ) == 0 );
383 X.s = x_sign;
384 TEST_ASSERT( mpi_read_string( &Y, 16, y_str ) == 0 );
385 Y.s = y_sign;
386
387 TEST_ASSERT( mpi_copy( &XX, &X ) == 0 );
388 TEST_ASSERT( mpi_copy( &YY, &Y ) == 0 );
389
390 TEST_ASSERT( mpi_safe_cond_swap( &X, &Y, 0 ) == 0 );
391 TEST_ASSERT( mpi_cmp_mpi( &X, &XX ) == 0 );
392 TEST_ASSERT( mpi_cmp_mpi( &Y, &YY ) == 0 );
393
394 TEST_ASSERT( mpi_safe_cond_swap( &X, &Y, 1 ) == 0 );
395 TEST_ASSERT( mpi_cmp_mpi( &Y, &XX ) == 0 );
396 TEST_ASSERT( mpi_cmp_mpi( &X, &YY ) == 0 );
397
Paul Bakkerbd51b262014-07-10 15:26:12 +0200398exit:
Manuel Pégourié-Gonnarda60fe892013-12-04 21:41:50 +0100399 mpi_free( &X ); mpi_free( &Y );
400 mpi_free( &XX ); mpi_free( &YY );
401}
402/* END_CASE */
403
404/* BEGIN_CASE */
Paul Bakker33b43f12013-08-20 11:48:36 +0200405void mpi_swap( int input_X, int input_Y )
Paul Bakker367dae42009-06-28 21:50:27 +0000406{
407 mpi X, Y, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000408 mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000409
Paul Bakker33b43f12013-08-20 11:48:36 +0200410 TEST_ASSERT( mpi_lset( &X, input_X ) == 0 );
411 TEST_ASSERT( mpi_lset( &Y, input_Y ) == 0 );
412 TEST_ASSERT( mpi_lset( &A, input_X ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000413 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 );
414 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
415 mpi_swap( &X, &Y );
416 TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 );
417 TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000418
Paul Bakkerbd51b262014-07-10 15:26:12 +0200419exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000420 mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000421}
Paul Bakker33b43f12013-08-20 11:48:36 +0200422/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000423
Paul Bakker33b43f12013-08-20 11:48:36 +0200424/* BEGIN_CASE */
425void mpi_add_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
426 int radix_A, char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000427{
428 mpi X, Y, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000429 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000430
Paul Bakker33b43f12013-08-20 11:48:36 +0200431 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
432 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
433 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000434 TEST_ASSERT( mpi_add_mpi( &Z, &X, &Y ) == 0 );
435 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000436
Paul Bakkerbd51b262014-07-10 15:26:12 +0200437exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000438 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000439}
Paul Bakker33b43f12013-08-20 11:48:36 +0200440/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000441
Paul Bakker33b43f12013-08-20 11:48:36 +0200442/* BEGIN_CASE */
443void mpi_add_abs( int radix_X, char *input_X, int radix_Y, char *input_Y,
444 int radix_A, char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000445{
446 mpi X, Y, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000447 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000448
Paul Bakker33b43f12013-08-20 11:48:36 +0200449 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
450 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
451 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000452 TEST_ASSERT( mpi_add_abs( &Z, &X, &Y ) == 0 );
453 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000454
Paul Bakkerbd51b262014-07-10 15:26:12 +0200455exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000456 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000457}
Paul Bakker33b43f12013-08-20 11:48:36 +0200458/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000459
Paul Bakker33b43f12013-08-20 11:48:36 +0200460/* BEGIN_CASE */
461void mpi_add_abs_add_first( int radix_X, char *input_X, int radix_Y,
462 char *input_Y, int radix_A, char *input_A )
Paul Bakkerba48cb22009-07-12 11:01:32 +0000463{
464 mpi X, Y, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000465 mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000466
Paul Bakker33b43f12013-08-20 11:48:36 +0200467 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
468 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
469 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000470 TEST_ASSERT( mpi_add_abs( &X, &X, &Y ) == 0 );
471 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000472
Paul Bakkerbd51b262014-07-10 15:26:12 +0200473exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000474 mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000475}
Paul Bakker33b43f12013-08-20 11:48:36 +0200476/* END_CASE */
Paul Bakkerba48cb22009-07-12 11:01:32 +0000477
Paul Bakker33b43f12013-08-20 11:48:36 +0200478/* BEGIN_CASE */
479void mpi_add_abs_add_second( int radix_X, char *input_X, int radix_Y,
480 char *input_Y, int radix_A, char *input_A )
Paul Bakkerba48cb22009-07-12 11:01:32 +0000481{
482 mpi X, Y, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000483 mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000484
Paul Bakker33b43f12013-08-20 11:48:36 +0200485 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
486 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
487 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000488 TEST_ASSERT( mpi_add_abs( &Y, &X, &Y ) == 0 );
489 TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000490
Paul Bakkerbd51b262014-07-10 15:26:12 +0200491exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000492 mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
Paul Bakkerba48cb22009-07-12 11:01:32 +0000493}
Paul Bakker33b43f12013-08-20 11:48:36 +0200494/* END_CASE */
Paul Bakkerba48cb22009-07-12 11:01:32 +0000495
Paul Bakker33b43f12013-08-20 11:48:36 +0200496/* BEGIN_CASE */
497void mpi_add_int( int radix_X, char *input_X, int input_Y, int radix_A,
498 char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000499{
500 mpi X, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000501 mpi_init( &X ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000502
Paul Bakker33b43f12013-08-20 11:48:36 +0200503 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
504 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
505 TEST_ASSERT( mpi_add_int( &Z, &X, input_Y ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000506 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000507
Paul Bakkerbd51b262014-07-10 15:26:12 +0200508exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000509 mpi_free( &X ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000510}
Paul Bakker33b43f12013-08-20 11:48:36 +0200511/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000512
Paul Bakker33b43f12013-08-20 11:48:36 +0200513/* BEGIN_CASE */
514void mpi_sub_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
515 int radix_A, char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000516{
517 mpi X, Y, Z, A;
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 TEST_ASSERT( mpi_sub_mpi( &Z, &X, &Y ) == 0 );
524 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000525
Paul Bakkerbd51b262014-07-10 15:26:12 +0200526exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000527 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000528}
Paul Bakker33b43f12013-08-20 11:48:36 +0200529/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000530
Paul Bakker33b43f12013-08-20 11:48:36 +0200531/* BEGIN_CASE */
532void mpi_sub_abs( int radix_X, char *input_X, int radix_Y, char *input_Y,
533 int radix_A, char *input_A, int sub_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000534{
535 mpi X, Y, Z, A;
536 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000537 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000538
Paul Bakker33b43f12013-08-20 11:48:36 +0200539 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
540 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
541 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000542
543 res = mpi_sub_abs( &Z, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200544 TEST_ASSERT( res == sub_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000545 if( res == 0 )
546 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000547
Paul Bakkerbd51b262014-07-10 15:26:12 +0200548exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000549 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
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_sub_int( int radix_X, char *input_X, int input_Y, int radix_A,
555 char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000556{
557 mpi X, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000558 mpi_init( &X ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000559
Paul Bakker33b43f12013-08-20 11:48:36 +0200560 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
561 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
562 TEST_ASSERT( mpi_sub_int( &Z, &X, input_Y ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000563 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000564
Paul Bakkerbd51b262014-07-10 15:26:12 +0200565exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000566 mpi_free( &X ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000567}
Paul Bakker33b43f12013-08-20 11:48:36 +0200568/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000569
Paul Bakker33b43f12013-08-20 11:48:36 +0200570/* BEGIN_CASE */
571void mpi_mul_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
572 int radix_A, char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000573{
574 mpi X, Y, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000575 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000576
Paul Bakker33b43f12013-08-20 11:48:36 +0200577 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
578 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
579 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000580 TEST_ASSERT( mpi_mul_mpi( &Z, &X, &Y ) == 0 );
581 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000582
Paul Bakkerbd51b262014-07-10 15:26:12 +0200583exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000584 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000585}
Paul Bakker33b43f12013-08-20 11:48:36 +0200586/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000587
Paul Bakker33b43f12013-08-20 11:48:36 +0200588/* BEGIN_CASE */
589void mpi_mul_int( int radix_X, char *input_X, int input_Y, int radix_A,
590 char *input_A, char *result_comparison )
Paul Bakker367dae42009-06-28 21:50:27 +0000591{
592 mpi X, Z, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000593 mpi_init( &X ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000594
Paul Bakker33b43f12013-08-20 11:48:36 +0200595 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
596 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
597 TEST_ASSERT( mpi_mul_int( &Z, &X, input_Y ) == 0 );
Paul Bakkerdbd443d2013-08-16 13:38:47 +0200598 if( strcmp( result_comparison, "==" ) == 0 )
599 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
600 else if( strcmp( result_comparison, "!=" ) == 0 )
601 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) != 0 );
602 else
603 TEST_ASSERT( "unknown operator" == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000604
Paul Bakkerbd51b262014-07-10 15:26:12 +0200605exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000606 mpi_free( &X ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000607}
Paul Bakker33b43f12013-08-20 11:48:36 +0200608/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000609
Paul Bakker33b43f12013-08-20 11:48:36 +0200610/* BEGIN_CASE */
611void mpi_div_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
612 int radix_A, char *input_A, int radix_B, char *input_B,
613 int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000614{
615 mpi X, Y, Q, R, A, B;
616 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000617 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Q ); mpi_init( &R );
618 mpi_init( &A ); mpi_init( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000619
Paul Bakker33b43f12013-08-20 11:48:36 +0200620 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
621 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
622 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
623 TEST_ASSERT( mpi_read_string( &B, radix_B, input_B ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000624 res = mpi_div_mpi( &Q, &R, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200625 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000626 if( res == 0 )
627 {
628 TEST_ASSERT( mpi_cmp_mpi( &Q, &A ) == 0 );
629 TEST_ASSERT( mpi_cmp_mpi( &R, &B ) == 0 );
630 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000631
Paul Bakkerbd51b262014-07-10 15:26:12 +0200632exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000633 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Q ); mpi_free( &R );
634 mpi_free( &A ); mpi_free( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000635}
Paul Bakker33b43f12013-08-20 11:48:36 +0200636/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000637
Paul Bakker33b43f12013-08-20 11:48:36 +0200638/* BEGIN_CASE */
639void mpi_div_int( int radix_X, char *input_X, int input_Y, int radix_A,
640 char *input_A, int radix_B, char *input_B, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000641{
642 mpi X, Q, R, A, B;
643 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000644 mpi_init( &X ); mpi_init( &Q ); mpi_init( &R ); mpi_init( &A );
645 mpi_init( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000646
Paul Bakker33b43f12013-08-20 11:48:36 +0200647 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
648 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
649 TEST_ASSERT( mpi_read_string( &B, radix_B, input_B ) == 0 );
650 res = mpi_div_int( &Q, &R, &X, input_Y );
651 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000652 if( res == 0 )
653 {
654 TEST_ASSERT( mpi_cmp_mpi( &Q, &A ) == 0 );
655 TEST_ASSERT( mpi_cmp_mpi( &R, &B ) == 0 );
656 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000657
Paul Bakkerbd51b262014-07-10 15:26:12 +0200658exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000659 mpi_free( &X ); mpi_free( &Q ); mpi_free( &R ); mpi_free( &A );
660 mpi_free( &B );
Paul Bakker367dae42009-06-28 21:50:27 +0000661}
Paul Bakker33b43f12013-08-20 11:48:36 +0200662/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000663
Paul Bakker33b43f12013-08-20 11:48:36 +0200664/* BEGIN_CASE */
665void mpi_mod_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
666 int radix_A, char *input_A, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000667{
Paul Bakkerf02c5642012-11-13 10:25:21 +0000668 mpi X, Y, A;
Paul Bakker367dae42009-06-28 21:50:27 +0000669 int res;
Paul Bakkerf02c5642012-11-13 10:25:21 +0000670 mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000671
Paul Bakker33b43f12013-08-20 11:48:36 +0200672 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
673 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
674 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakkerf02c5642012-11-13 10:25:21 +0000675 res = mpi_mod_mpi( &X, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200676 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000677 if( res == 0 )
678 {
Paul Bakkerf02c5642012-11-13 10:25:21 +0000679 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000680 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000681
Paul Bakkerbd51b262014-07-10 15:26:12 +0200682exit:
Paul Bakkerf02c5642012-11-13 10:25:21 +0000683 mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000684}
Paul Bakker33b43f12013-08-20 11:48:36 +0200685/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000686
Paul Bakker33b43f12013-08-20 11:48:36 +0200687/* BEGIN_CASE */
688void mpi_mod_int( int radix_X, char *input_X, int input_Y, int input_A,
689 int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000690{
691 mpi X;
692 int res;
Paul Bakkera755ca12011-04-24 09:11:17 +0000693 t_uint r;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000694 mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000695
Paul Bakker33b43f12013-08-20 11:48:36 +0200696 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
697 res = mpi_mod_int( &r, &X, input_Y );
698 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000699 if( res == 0 )
700 {
Paul Bakker33b43f12013-08-20 11:48:36 +0200701 TEST_ASSERT( r == (t_uint) input_A );
Paul Bakker367dae42009-06-28 21:50:27 +0000702 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000703
Paul Bakkerbd51b262014-07-10 15:26:12 +0200704exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000705 mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000706}
Paul Bakker33b43f12013-08-20 11:48:36 +0200707/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000708
Paul Bakker33b43f12013-08-20 11:48:36 +0200709/* BEGIN_CASE */
710void mpi_exp_mod( int radix_A, char *input_A, int radix_E, char *input_E,
711 int radix_N, char *input_N, int radix_RR, char *input_RR,
712 int radix_X, char *input_X, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000713{
714 mpi A, E, N, RR, Z, X;
715 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000716 mpi_init( &A ); mpi_init( &E ); mpi_init( &N );
717 mpi_init( &RR ); mpi_init( &Z ); mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000718
Paul Bakker33b43f12013-08-20 11:48:36 +0200719 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
720 TEST_ASSERT( mpi_read_string( &E, radix_E, input_E ) == 0 );
721 TEST_ASSERT( mpi_read_string( &N, radix_N, input_N ) == 0 );
722 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000723
Paul Bakker33b43f12013-08-20 11:48:36 +0200724 if( strlen( input_RR ) )
725 TEST_ASSERT( mpi_read_string( &RR, radix_RR, input_RR ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000726
727 res = mpi_exp_mod( &Z, &A, &E, &N, &RR );
Paul Bakker33b43f12013-08-20 11:48:36 +0200728 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000729 if( res == 0 )
730 {
731 TEST_ASSERT( mpi_cmp_mpi( &Z, &X ) == 0 );
732 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000733
Paul Bakkerbd51b262014-07-10 15:26:12 +0200734exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000735 mpi_free( &A ); mpi_free( &E ); mpi_free( &N );
736 mpi_free( &RR ); mpi_free( &Z ); mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000737}
Paul Bakker33b43f12013-08-20 11:48:36 +0200738/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000739
Paul Bakker33b43f12013-08-20 11:48:36 +0200740/* BEGIN_CASE */
741void mpi_inv_mod( int radix_X, char *input_X, int radix_Y, char *input_Y,
742 int radix_A, char *input_A, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000743{
744 mpi X, Y, Z, A;
745 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000746 mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000747
Paul Bakker33b43f12013-08-20 11:48:36 +0200748 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
749 TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
750 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000751 res = mpi_inv_mod( &Z, &X, &Y );
Paul Bakker33b43f12013-08-20 11:48:36 +0200752 TEST_ASSERT( res == div_result );
Paul Bakker367dae42009-06-28 21:50:27 +0000753 if( res == 0 )
754 {
755 TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
756 }
Paul Bakker6c591fa2011-05-05 11:49:20 +0000757
Paul Bakkerbd51b262014-07-10 15:26:12 +0200758exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000759 mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000760}
Paul Bakker33b43f12013-08-20 11:48:36 +0200761/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000762
Manuel Pégourié-Gonnarddf0142b2013-08-22 18:29:07 +0200763/* BEGIN_CASE depends_on:POLARSSL_GENPRIME */
Paul Bakker33b43f12013-08-20 11:48:36 +0200764void mpi_is_prime( int radix_X, char *input_X, int div_result )
Paul Bakker367dae42009-06-28 21:50:27 +0000765{
766 mpi X;
767 int res;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000768 mpi_init( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000769
Paul Bakker33b43f12013-08-20 11:48:36 +0200770 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
Paul Bakker5690efc2011-05-26 13:16:06 +0000771 res = mpi_is_prime( &X, rnd_std_rand, NULL );
Paul Bakker33b43f12013-08-20 11:48:36 +0200772 TEST_ASSERT( res == div_result );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000773
Paul Bakkerbd51b262014-07-10 15:26:12 +0200774exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000775 mpi_free( &X );
Paul Bakker367dae42009-06-28 21:50:27 +0000776}
Paul Bakker33b43f12013-08-20 11:48:36 +0200777/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000778
Manuel Pégourié-Gonnard15f58a82014-06-16 17:12:40 +0200779/* BEGIN_CASE depends_on:POLARSSL_GENPRIME */
780void mpi_gen_prime( int bits, int safe, int ref_ret )
781{
782 mpi X;
783 int my_ret;
784
785 mpi_init( &X );
786
787 my_ret = mpi_gen_prime( &X, bits, safe, rnd_std_rand, NULL );
788 TEST_ASSERT( my_ret == ref_ret );
789
790 if( ref_ret == 0 )
791 {
792 size_t actual_bits = mpi_msb( &X );
793
794 TEST_ASSERT( actual_bits >= (size_t) bits );
795 TEST_ASSERT( actual_bits <= (size_t) bits + 1 );
796
797 TEST_ASSERT( mpi_is_prime( &X, rnd_std_rand, NULL ) == 0 );
798 if( safe )
799 {
800 mpi_shift_r( &X, 1 ); /* X = ( X - 1 ) / 2 */
801 TEST_ASSERT( mpi_is_prime( &X, rnd_std_rand, NULL ) == 0 );
802 }
803 }
804
Paul Bakkerbd51b262014-07-10 15:26:12 +0200805exit:
Manuel Pégourié-Gonnard15f58a82014-06-16 17:12:40 +0200806 mpi_free( &X );
807}
808/* END_CASE */
809
Paul Bakker33b43f12013-08-20 11:48:36 +0200810/* BEGIN_CASE */
811void mpi_shift_l( int radix_X, char *input_X, int shift_X, int radix_A,
812 char *input_A)
Paul Bakker367dae42009-06-28 21:50:27 +0000813{
814 mpi X, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000815 mpi_init( &X ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000816
Paul Bakker33b43f12013-08-20 11:48:36 +0200817 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
818 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
819 TEST_ASSERT( mpi_shift_l( &X, shift_X ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000820 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000821
Paul Bakkerbd51b262014-07-10 15:26:12 +0200822exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000823 mpi_free( &X ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000824}
Paul Bakker33b43f12013-08-20 11:48:36 +0200825/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000826
Paul Bakker33b43f12013-08-20 11:48:36 +0200827/* BEGIN_CASE */
828void mpi_shift_r( int radix_X, char *input_X, int shift_X, int radix_A,
829 char *input_A )
Paul Bakker367dae42009-06-28 21:50:27 +0000830{
831 mpi X, A;
Paul Bakker6c591fa2011-05-05 11:49:20 +0000832 mpi_init( &X ); mpi_init( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000833
Paul Bakker33b43f12013-08-20 11:48:36 +0200834 TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
835 TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
836 TEST_ASSERT( mpi_shift_r( &X, shift_X ) == 0 );
Paul Bakker367dae42009-06-28 21:50:27 +0000837 TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
Paul Bakker6c591fa2011-05-05 11:49:20 +0000838
Paul Bakkerbd51b262014-07-10 15:26:12 +0200839exit:
Paul Bakker6c591fa2011-05-05 11:49:20 +0000840 mpi_free( &X ); mpi_free( &A );
Paul Bakker367dae42009-06-28 21:50:27 +0000841}
Paul Bakker33b43f12013-08-20 11:48:36 +0200842/* END_CASE */
Paul Bakker367dae42009-06-28 21:50:27 +0000843
Manuel Pégourié-Gonnard20140162013-10-10 12:48:03 +0200844/* BEGIN_CASE depends_on:POLARSSL_SELF_TEST */
Paul Bakker33b43f12013-08-20 11:48:36 +0200845void mpi_selftest()
Paul Bakkere896fea2009-07-06 06:40:23 +0000846{
847 TEST_ASSERT( mpi_self_test( 0 ) == 0 );
848}
Paul Bakker33b43f12013-08-20 11:48:36 +0200849/* END_CASE */