PolarSSL v1.3.1
test_suite_mpi.c
Go to the documentation of this file.
1 #include <polarssl/config.h>
2 
3 #ifdef POLARSSL_BIGNUM_C
4 
5 #include <polarssl/bignum.h>
6 #endif /* POLARSSL_BIGNUM_C */
7 
8 
9 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
10 #include "polarssl/memory.h"
11 #endif
12 
13 #ifdef _MSC_VER
14 #include <basetsd.h>
15 typedef UINT32 uint32_t;
16 #else
17 #include <inttypes.h>
18 #endif
19 
20 #include <assert.h>
21 #include <stdlib.h>
22 #include <string.h>
23 
24 /*
25  * 32-bit integer manipulation macros (big endian)
26  */
27 #ifndef GET_UINT32_BE
28 #define GET_UINT32_BE(n,b,i) \
29 { \
30  (n) = ( (uint32_t) (b)[(i) ] << 24 ) \
31  | ( (uint32_t) (b)[(i) + 1] << 16 ) \
32  | ( (uint32_t) (b)[(i) + 2] << 8 ) \
33  | ( (uint32_t) (b)[(i) + 3] ); \
34 }
35 #endif
36 
37 #ifndef PUT_UINT32_BE
38 #define PUT_UINT32_BE(n,b,i) \
39 { \
40  (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
41  (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
42  (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
43  (b)[(i) + 3] = (unsigned char) ( (n) ); \
44 }
45 #endif
46 
47 static int unhexify(unsigned char *obuf, const char *ibuf)
48 {
49  unsigned char c, c2;
50  int len = strlen(ibuf) / 2;
51  assert(!(strlen(ibuf) %1)); // must be even number of bytes
52 
53  while (*ibuf != 0)
54  {
55  c = *ibuf++;
56  if( c >= '0' && c <= '9' )
57  c -= '0';
58  else if( c >= 'a' && c <= 'f' )
59  c -= 'a' - 10;
60  else if( c >= 'A' && c <= 'F' )
61  c -= 'A' - 10;
62  else
63  assert( 0 );
64 
65  c2 = *ibuf++;
66  if( c2 >= '0' && c2 <= '9' )
67  c2 -= '0';
68  else if( c2 >= 'a' && c2 <= 'f' )
69  c2 -= 'a' - 10;
70  else if( c2 >= 'A' && c2 <= 'F' )
71  c2 -= 'A' - 10;
72  else
73  assert( 0 );
74 
75  *obuf++ = ( c << 4 ) | c2;
76  }
77 
78  return len;
79 }
80 
81 static void hexify(unsigned char *obuf, const unsigned char *ibuf, int len)
82 {
83  unsigned char l, h;
84 
85  while (len != 0)
86  {
87  h = (*ibuf) / 16;
88  l = (*ibuf) % 16;
89 
90  if( h < 10 )
91  *obuf++ = '0' + h;
92  else
93  *obuf++ = 'a' + h - 10;
94 
95  if( l < 10 )
96  *obuf++ = '0' + l;
97  else
98  *obuf++ = 'a' + l - 10;
99 
100  ++ibuf;
101  len--;
102  }
103 }
104 
114 static int rnd_std_rand( void *rng_state, unsigned char *output, size_t len )
115 {
116  size_t i;
117 
118  if( rng_state != NULL )
119  rng_state = NULL;
120 
121  for( i = 0; i < len; ++i )
122  output[i] = rand();
123 
124  return( 0 );
125 }
126 
132 static int rnd_zero_rand( void *rng_state, unsigned char *output, size_t len )
133 {
134  if( rng_state != NULL )
135  rng_state = NULL;
136 
137  memset( output, 0, len );
138 
139  return( 0 );
140 }
141 
142 typedef struct
143 {
144  unsigned char *buf;
145  size_t length;
146 } rnd_buf_info;
147 
159 static int rnd_buffer_rand( void *rng_state, unsigned char *output, size_t len )
160 {
161  rnd_buf_info *info = (rnd_buf_info *) rng_state;
162  size_t use_len;
163 
164  if( rng_state == NULL )
165  return( rnd_std_rand( NULL, output, len ) );
166 
167  use_len = len;
168  if( len > info->length )
169  use_len = info->length;
170 
171  if( use_len )
172  {
173  memcpy( output, info->buf, use_len );
174  info->buf += use_len;
175  info->length -= use_len;
176  }
177 
178  if( len - use_len > 0 )
179  return( rnd_std_rand( NULL, output + use_len, len - use_len ) );
180 
181  return( 0 );
182 }
183 
191 typedef struct
192 {
193  uint32_t key[16];
194  uint32_t v0, v1;
196 
205 static int rnd_pseudo_rand( void *rng_state, unsigned char *output, size_t len )
206 {
207  rnd_pseudo_info *info = (rnd_pseudo_info *) rng_state;
208  uint32_t i, *k, sum, delta=0x9E3779B9;
209  unsigned char result[4];
210 
211  if( rng_state == NULL )
212  return( rnd_std_rand( NULL, output, len ) );
213 
214  k = info->key;
215 
216  while( len > 0 )
217  {
218  size_t use_len = ( len > 4 ) ? 4 : len;
219  sum = 0;
220 
221  for( i = 0; i < 32; i++ )
222  {
223  info->v0 += (((info->v1 << 4) ^ (info->v1 >> 5)) + info->v1) ^ (sum + k[sum & 3]);
224  sum += delta;
225  info->v1 += (((info->v0 << 4) ^ (info->v0 >> 5)) + info->v0) ^ (sum + k[(sum>>11) & 3]);
226  }
227 
228  PUT_UINT32_BE( info->v0, result, 0 );
229  memcpy( output, result, use_len );
230  len -= use_len;
231  }
232 
233  return( 0 );
234 }
235 
245 static int not_rnd( void *in, unsigned char *out, size_t len )
246 {
247  unsigned char *obuf;
248  const char *ibuf = in;
249  unsigned char c, c2;
250  assert( len == strlen(ibuf) / 2 );
251  assert(!(strlen(ibuf) %1)); // must be even number of bytes
252 
253  obuf = out + (len - 1); // sic
254  while (*ibuf != 0)
255  {
256  c = *ibuf++;
257  if( c >= '0' && c <= '9' )
258  c -= '0';
259  else if( c >= 'a' && c <= 'f' )
260  c -= 'a' - 10;
261  else if( c >= 'A' && c <= 'F' )
262  c -= 'A' - 10;
263  else
264  assert( 0 );
265 
266  c2 = *ibuf++;
267  if( c2 >= '0' && c2 <= '9' )
268  c2 -= '0';
269  else if( c2 >= 'a' && c2 <= 'f' )
270  c2 -= 'a' - 10;
271  else if( c2 >= 'A' && c2 <= 'F' )
272  c2 -= 'A' - 10;
273  else
274  assert( 0 );
275 
276  *obuf-- = ( c << 4 ) | c2; // sic
277  }
278 
279  return( 0 );
280 }
281 
282 
283 #include <stdio.h>
284 #include <string.h>
285 
286 static int test_errors = 0;
287 
288 #ifdef POLARSSL_BIGNUM_C
289 
290 #define TEST_SUITE_ACTIVE
291 
292 static int test_assert( int correct, char *test )
293 {
294  if( correct )
295  return( 0 );
296 
297  test_errors++;
298  if( test_errors == 1 )
299  printf( "FAILED\n" );
300  printf( " %s\n", test );
301 
302  return( 1 );
303 }
304 
305 #define TEST_ASSERT( TEST ) \
306  do { test_assert( (TEST) ? 1 : 0, #TEST ); \
307  if( test_errors) return; \
308  } while (0)
309 
310 int verify_string( char **str )
311 {
312  if( (*str)[0] != '"' ||
313  (*str)[strlen( *str ) - 1] != '"' )
314  {
315  printf( "Expected string (with \"\") for parameter and got: %s\n", *str );
316  return( -1 );
317  }
318 
319  (*str)++;
320  (*str)[strlen( *str ) - 1] = '\0';
321 
322  return( 0 );
323 }
324 
325 int verify_int( char *str, int *value )
326 {
327  size_t i;
328  int minus = 0;
329  int digits = 1;
330  int hex = 0;
331 
332  for( i = 0; i < strlen( str ); i++ )
333  {
334  if( i == 0 && str[i] == '-' )
335  {
336  minus = 1;
337  continue;
338  }
339 
340  if( ( ( minus && i == 2 ) || ( !minus && i == 1 ) ) &&
341  str[i - 1] == '0' && str[i] == 'x' )
342  {
343  hex = 1;
344  continue;
345  }
346 
347  if( str[i] < '0' || str[i] > '9' )
348  {
349  digits = 0;
350  break;
351  }
352  }
353 
354  if( digits )
355  {
356  if( hex )
357  *value = strtol( str, NULL, 16 );
358  else
359  *value = strtol( str, NULL, 10 );
360 
361  return( 0 );
362  }
363 
364  if( strcmp( str, "-13" ) == 0 )
365  {
366  *value = ( -13 );
367  return( 0 );
368  }
369  if( strcmp( str, "-34" ) == 0 )
370  {
371  *value = ( -34 );
372  return( 0 );
373  }
374  if( strcmp( str, "POLARSSL_ERR_MPI_NOT_ACCEPTABLE" ) == 0 )
375  {
376  *value = ( POLARSSL_ERR_MPI_NOT_ACCEPTABLE );
377  return( 0 );
378  }
379  if( strcmp( str, "POLARSSL_ERR_MPI_BAD_INPUT_DATA" ) == 0 )
380  {
381  *value = ( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
382  return( 0 );
383  }
384  if( strcmp( str, "-1" ) == 0 )
385  {
386  *value = ( -1 );
387  return( 0 );
388  }
389  if( strcmp( str, "-3" ) == 0 )
390  {
391  *value = ( -3 );
392  return( 0 );
393  }
394  if( strcmp( str, "-9871232" ) == 0 )
395  {
396  *value = ( -9871232 );
397  return( 0 );
398  }
399  if( strcmp( str, "POLARSSL_ERR_MPI_INVALID_CHARACTER" ) == 0 )
400  {
402  return( 0 );
403  }
404  if( strcmp( str, "POLARSSL_ERR_MPI_DIVISION_BY_ZERO" ) == 0 )
405  {
407  return( 0 );
408  }
409  if( strcmp( str, "POLARSSL_ERR_MPI_NEGATIVE_VALUE" ) == 0 )
410  {
411  *value = ( POLARSSL_ERR_MPI_NEGATIVE_VALUE );
412  return( 0 );
413  }
414  if( strcmp( str, "POLARSSL_ERR_MPI_BUFFER_TOO_SMALL" ) == 0 )
415  {
417  return( 0 );
418  }
419  if( strcmp( str, "POLARSSL_ERR_MPI_FILE_IO_ERROR" ) == 0 )
420  {
421  *value = ( POLARSSL_ERR_MPI_FILE_IO_ERROR );
422  return( 0 );
423  }
424  if( strcmp( str, "-2" ) == 0 )
425  {
426  *value = ( -2 );
427  return( 0 );
428  }
429 
430 
431  printf( "Expected integer for parameter and got: %s\n", str );
432  return( -1 );
433 }
434 
435 void test_suite_mpi_read_write_string( int radix_X, char *input_X, int radix_A,
436  char *input_A, int output_size, int result_read,
437  int result_write )
438 {
439  mpi X;
440  char str[1000];
441  size_t len = output_size;
442 
443  mpi_init( &X );
444 
445  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == result_read );
446  if( result_read == 0 )
447  {
448  TEST_ASSERT( mpi_write_string( &X, radix_A, str, &len ) == result_write );
449  if( result_write == 0 )
450  {
451  TEST_ASSERT( strcasecmp( str, input_A ) == 0 );
452  }
453  }
454 
455  mpi_free( &X );
456 }
457 
458 void test_suite_mpi_read_binary( char *input_X, int radix_A, char *input_A )
459 {
460  mpi X;
461  unsigned char str[1000];
462  unsigned char buf[1000];
463  size_t len = 1000;
464  size_t input_len;
465 
466  mpi_init( &X );
467 
468  input_len = unhexify( buf, input_X );
469 
470  TEST_ASSERT( mpi_read_binary( &X, buf, input_len ) == 0 );
471  TEST_ASSERT( mpi_write_string( &X, radix_A, (char *) str, &len ) == 0 );
472  TEST_ASSERT( strcmp( (char *) str, input_A ) == 0 );
473 
474  mpi_free( &X );
475 }
476 
477 void test_suite_mpi_write_binary( int radix_X, char *input_X, char *input_A,
478  int output_size, int result )
479 {
480  mpi X;
481  unsigned char str[1000];
482  unsigned char buf[1000];
483  size_t buflen;
484 
485  memset( buf, 0x00, 1000 );
486  memset( str, 0x00, 1000 );
487 
488  mpi_init( &X );
489 
490  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
491 
492  buflen = mpi_size( &X );
493  if( buflen > (size_t) output_size )
494  buflen = (size_t) output_size;
495 
496  TEST_ASSERT( mpi_write_binary( &X, buf, buflen ) == result );
497  if( result == 0)
498  {
499  hexify( str, buf, buflen );
500 
501  TEST_ASSERT( strcasecmp( (char *) str, input_A ) == 0 );
502  }
503 
504  mpi_free( &X );
505 }
506 
507 #ifdef POLARSSL_FS_IO
508 void test_suite_mpi_read_file( int radix_X, char *input_file, char *input_A,
509  int result )
510 {
511  mpi X;
512  unsigned char str[1000];
513  unsigned char buf[1000];
514  size_t buflen;
515  FILE *file;
516 
517  memset( buf, 0x00, 1000 );
518  memset( str, 0x00, 1000 );
519 
520  mpi_init( &X );
521 
522  file = fopen( input_file, "r" );
523  TEST_ASSERT( mpi_read_file( &X, radix_X, file ) == result );
524  fclose(file);
525 
526  if( result == 0 )
527  {
528  buflen = mpi_size( &X );
529  TEST_ASSERT( mpi_write_binary( &X, buf, buflen ) == 0 );
530 
531  hexify( str, buf, buflen );
532 
533  TEST_ASSERT( strcasecmp( (char *) str, input_A ) == 0 );
534  }
535 
536  mpi_free( &X );
537 }
538 #endif /* POLARSSL_FS_IO */
539 
540 #ifdef POLARSSL_FS_IO
541 void test_suite_mpi_write_file( int radix_X, char *input_X, int output_radix,
542  char *output_file )
543 {
544  mpi X, Y;
545  FILE *file_out, *file_in;
546 
547  mpi_init( &X ); mpi_init( &Y );
548 
549  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
550 
551  file_out = fopen( output_file, "w" );
552  TEST_ASSERT( file_out != NULL );
553  TEST_ASSERT( mpi_write_file( NULL, &X, output_radix, file_out ) == 0 );
554  fclose(file_out);
555 
556  file_in = fopen( output_file, "r" );
557  TEST_ASSERT( file_in != NULL );
558  TEST_ASSERT( mpi_read_file( &Y, output_radix, file_in ) == 0 );
559  fclose(file_in);
560 
561  TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == 0 );
562 
563  mpi_free( &X ); mpi_free( &Y );
564 }
565 #endif /* POLARSSL_FS_IO */
566 
567 void test_suite_mpi_get_bit( int radix_X, char *input_X, int pos, int val )
568 {
569  mpi X;
570  mpi_init( &X );
571  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
572  TEST_ASSERT( mpi_get_bit( &X, pos ) == val );
573 
574  mpi_free( &X );
575 }
576 
577 void test_suite_mpi_set_bit( int radix_X, char *input_X, int pos, int val, int radix_Y,
578  char *output_Y )
579 {
580  mpi X, Y;
581  mpi_init( &X ); mpi_init( &Y );
582 
583  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
584  TEST_ASSERT( mpi_read_string( &Y, radix_Y, output_Y ) == 0 );
585  TEST_ASSERT( mpi_set_bit( &X, pos, val ) == 0 );
586  TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == 0 );
587 
588  mpi_free( &X ); mpi_free( &Y );
589 }
590 
591 void test_suite_mpi_lsb( int radix_X, char *input_X, int nr_bits )
592 {
593  mpi X;
594  mpi_init( &X );
595 
596  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
597  TEST_ASSERT( mpi_lsb( &X ) == (size_t) nr_bits );
598 
599  mpi_free( &X );
600 }
601 
602 void test_suite_mpi_msb( int radix_X, char *input_X, int nr_bits )
603 {
604  mpi X;
605  mpi_init( &X );
606 
607  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
608  TEST_ASSERT( mpi_msb( &X ) == (size_t) nr_bits );
609 
610  mpi_free( &X );
611 }
612 
613 void test_suite_mpi_gcd( int radix_X, char *input_X, int radix_Y, char *input_Y,
614  int radix_A, char *input_A )
615 {
616  mpi A, X, Y, Z;
617  mpi_init( &A ); mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z );
618 
619  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
620  TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
621  TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
622  TEST_ASSERT( mpi_gcd( &Z, &X, &Y ) == 0 );
623  TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
624 
625  mpi_free( &A ); mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z );
626 }
627 
628 void test_suite_mpi_cmp_int( int input_X, int input_A, int result_CMP )
629 {
630  mpi X;
631  mpi_init( &X );
632 
633  TEST_ASSERT( mpi_lset( &X, input_X ) == 0);
634  TEST_ASSERT( mpi_cmp_int( &X, input_A ) == result_CMP);
635 
636  mpi_free( &X );
637 }
638 
639 void test_suite_mpi_cmp_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
640  int input_A )
641 {
642  mpi X, Y;
643  mpi_init( &X ); mpi_init( &Y );
644 
645  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
646  TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
647  TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == input_A );
648 
649  mpi_free( &X ); mpi_free( &Y );
650 }
651 
652 void test_suite_mpi_cmp_abs( int radix_X, char *input_X, int radix_Y, char *input_Y,
653  int input_A )
654 {
655  mpi X, Y;
656  mpi_init( &X ); mpi_init( &Y );
657 
658  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
659  TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
660  TEST_ASSERT( mpi_cmp_abs( &X, &Y ) == input_A );
661 
662  mpi_free( &X ); mpi_free( &Y );
663 }
664 
665 void test_suite_mpi_copy( int input_X, int input_A )
666 {
667  mpi X, Y, A;
668  mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
669 
670  TEST_ASSERT( mpi_lset( &X, input_X ) == 0 );
671  TEST_ASSERT( mpi_lset( &Y, input_A ) == 0 );
672  TEST_ASSERT( mpi_lset( &A, input_A ) == 0 );
673  TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 );
674  TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) == 0 );
675  TEST_ASSERT( mpi_copy( &Y, &X ) == 0 );
676  TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == 0 );
677  TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) != 0 );
678 
679  mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
680 }
681 
682 void test_suite_mpi_copy_self( int input_X )
683 {
684  mpi X;
685  mpi_init( &X );
686 
687  TEST_ASSERT( mpi_lset( &X, input_X ) == 0 );
688  TEST_ASSERT( mpi_copy( &X, &X ) == 0 );
689  TEST_ASSERT( mpi_cmp_int( &X, input_X ) == 0 );
690 
691  mpi_free( &X );
692 }
693 
694 void test_suite_mpi_swap( int input_X, int input_Y )
695 {
696  mpi X, Y, A;
697  mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
698 
699  TEST_ASSERT( mpi_lset( &X, input_X ) == 0 );
700  TEST_ASSERT( mpi_lset( &Y, input_Y ) == 0 );
701  TEST_ASSERT( mpi_lset( &A, input_X ) == 0 );
702  TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 );
703  TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
704  mpi_swap( &X, &Y );
705  TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 );
706  TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) == 0 );
707 
708  mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
709 }
710 
711 void test_suite_mpi_add_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
712  int radix_A, char *input_A )
713 {
714  mpi X, Y, Z, A;
715  mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
716 
717  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
718  TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
719  TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
720  TEST_ASSERT( mpi_add_mpi( &Z, &X, &Y ) == 0 );
721  TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
722 
723  mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
724 }
725 
726 void test_suite_mpi_add_abs( int radix_X, char *input_X, int radix_Y, char *input_Y,
727  int radix_A, char *input_A )
728 {
729  mpi X, Y, Z, A;
730  mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
731 
732  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
733  TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
734  TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
735  TEST_ASSERT( mpi_add_abs( &Z, &X, &Y ) == 0 );
736  TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
737 
738  mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
739 }
740 
741 void test_suite_mpi_add_abs_add_first( int radix_X, char *input_X, int radix_Y,
742  char *input_Y, int radix_A, char *input_A )
743 {
744  mpi X, Y, A;
745  mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
746 
747  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
748  TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
749  TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
750  TEST_ASSERT( mpi_add_abs( &X, &X, &Y ) == 0 );
751  TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
752 
753  mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
754 }
755 
756 void test_suite_mpi_add_abs_add_second( int radix_X, char *input_X, int radix_Y,
757  char *input_Y, int radix_A, char *input_A )
758 {
759  mpi X, Y, A;
760  mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
761 
762  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
763  TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
764  TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
765  TEST_ASSERT( mpi_add_abs( &Y, &X, &Y ) == 0 );
766  TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) == 0 );
767 
768  mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
769 }
770 
771 void test_suite_mpi_add_int( int radix_X, char *input_X, int input_Y, int radix_A,
772  char *input_A )
773 {
774  mpi X, Z, A;
775  mpi_init( &X ); mpi_init( &Z ); mpi_init( &A );
776 
777  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
778  TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
779  TEST_ASSERT( mpi_add_int( &Z, &X, input_Y ) == 0 );
780  TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
781 
782  mpi_free( &X ); mpi_free( &Z ); mpi_free( &A );
783 }
784 
785 void test_suite_mpi_sub_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
786  int radix_A, char *input_A )
787 {
788  mpi X, Y, Z, A;
789  mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
790 
791  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
792  TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
793  TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
794  TEST_ASSERT( mpi_sub_mpi( &Z, &X, &Y ) == 0 );
795  TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
796 
797  mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
798 }
799 
800 void test_suite_mpi_sub_abs( int radix_X, char *input_X, int radix_Y, char *input_Y,
801  int radix_A, char *input_A, int sub_result )
802 {
803  mpi X, Y, Z, A;
804  int res;
805  mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
806 
807  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
808  TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
809  TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
810 
811  res = mpi_sub_abs( &Z, &X, &Y );
812  TEST_ASSERT( res == sub_result );
813  if( res == 0 )
814  TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
815 
816  mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
817 }
818 
819 void test_suite_mpi_sub_int( int radix_X, char *input_X, int input_Y, int radix_A,
820  char *input_A )
821 {
822  mpi X, Z, A;
823  mpi_init( &X ); mpi_init( &Z ); mpi_init( &A );
824 
825  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
826  TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
827  TEST_ASSERT( mpi_sub_int( &Z, &X, input_Y ) == 0 );
828  TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
829 
830  mpi_free( &X ); mpi_free( &Z ); mpi_free( &A );
831 }
832 
833 void test_suite_mpi_mul_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
834  int radix_A, char *input_A )
835 {
836  mpi X, Y, Z, A;
837  mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
838 
839  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
840  TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
841  TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
842  TEST_ASSERT( mpi_mul_mpi( &Z, &X, &Y ) == 0 );
843  TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
844 
845  mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
846 }
847 
848 void test_suite_mpi_mul_int( int radix_X, char *input_X, int input_Y, int radix_A,
849  char *input_A, char *result_comparison )
850 {
851  mpi X, Z, A;
852  mpi_init( &X ); mpi_init( &Z ); mpi_init( &A );
853 
854  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
855  TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
856  TEST_ASSERT( mpi_mul_int( &Z, &X, input_Y ) == 0 );
857  if( strcmp( result_comparison, "==" ) == 0 )
858  TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
859  else if( strcmp( result_comparison, "!=" ) == 0 )
860  TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) != 0 );
861  else
862  TEST_ASSERT( "unknown operator" == 0 );
863 
864  mpi_free( &X ); mpi_free( &Z ); mpi_free( &A );
865 }
866 
867 void test_suite_mpi_div_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
868  int radix_A, char *input_A, int radix_B, char *input_B,
869  int div_result )
870 {
871  mpi X, Y, Q, R, A, B;
872  int res;
873  mpi_init( &X ); mpi_init( &Y ); mpi_init( &Q ); mpi_init( &R );
874  mpi_init( &A ); mpi_init( &B );
875 
876  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
877  TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
878  TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
879  TEST_ASSERT( mpi_read_string( &B, radix_B, input_B ) == 0 );
880  res = mpi_div_mpi( &Q, &R, &X, &Y );
881  TEST_ASSERT( res == div_result );
882  if( res == 0 )
883  {
884  TEST_ASSERT( mpi_cmp_mpi( &Q, &A ) == 0 );
885  TEST_ASSERT( mpi_cmp_mpi( &R, &B ) == 0 );
886  }
887 
888  mpi_free( &X ); mpi_free( &Y ); mpi_free( &Q ); mpi_free( &R );
889  mpi_free( &A ); mpi_free( &B );
890 }
891 
892 void test_suite_mpi_div_int( int radix_X, char *input_X, int input_Y, int radix_A,
893  char *input_A, int radix_B, char *input_B, int div_result )
894 {
895  mpi X, Q, R, A, B;
896  int res;
897  mpi_init( &X ); mpi_init( &Q ); mpi_init( &R ); mpi_init( &A );
898  mpi_init( &B );
899 
900  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
901  TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
902  TEST_ASSERT( mpi_read_string( &B, radix_B, input_B ) == 0 );
903  res = mpi_div_int( &Q, &R, &X, input_Y );
904  TEST_ASSERT( res == div_result );
905  if( res == 0 )
906  {
907  TEST_ASSERT( mpi_cmp_mpi( &Q, &A ) == 0 );
908  TEST_ASSERT( mpi_cmp_mpi( &R, &B ) == 0 );
909  }
910 
911  mpi_free( &X ); mpi_free( &Q ); mpi_free( &R ); mpi_free( &A );
912  mpi_free( &B );
913 }
914 
915 void test_suite_mpi_mod_mpi( int radix_X, char *input_X, int radix_Y, char *input_Y,
916  int radix_A, char *input_A, int div_result )
917 {
918  mpi X, Y, A;
919  int res;
920  mpi_init( &X ); mpi_init( &Y ); mpi_init( &A );
921 
922  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
923  TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
924  TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
925  res = mpi_mod_mpi( &X, &X, &Y );
926  TEST_ASSERT( res == div_result );
927  if( res == 0 )
928  {
929  TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
930  }
931 
932  mpi_free( &X ); mpi_free( &Y ); mpi_free( &A );
933 }
934 
935 void test_suite_mpi_mod_int( int radix_X, char *input_X, int input_Y, int input_A,
936  int div_result )
937 {
938  mpi X;
939  int res;
940  t_uint r;
941  mpi_init( &X );
942 
943  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
944  res = mpi_mod_int( &r, &X, input_Y );
945  TEST_ASSERT( res == div_result );
946  if( res == 0 )
947  {
948  TEST_ASSERT( r == (t_uint) input_A );
949  }
950 
951  mpi_free( &X );
952 }
953 
954 void test_suite_mpi_exp_mod( int radix_A, char *input_A, int radix_E, char *input_E,
955  int radix_N, char *input_N, int radix_RR, char *input_RR,
956  int radix_X, char *input_X, int div_result )
957 {
958  mpi A, E, N, RR, Z, X;
959  int res;
960  mpi_init( &A ); mpi_init( &E ); mpi_init( &N );
961  mpi_init( &RR ); mpi_init( &Z ); mpi_init( &X );
962 
963  TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
964  TEST_ASSERT( mpi_read_string( &E, radix_E, input_E ) == 0 );
965  TEST_ASSERT( mpi_read_string( &N, radix_N, input_N ) == 0 );
966  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
967 
968  if( strlen( input_RR ) )
969  TEST_ASSERT( mpi_read_string( &RR, radix_RR, input_RR ) == 0 );
970 
971  res = mpi_exp_mod( &Z, &A, &E, &N, &RR );
972  TEST_ASSERT( res == div_result );
973  if( res == 0 )
974  {
975  TEST_ASSERT( mpi_cmp_mpi( &Z, &X ) == 0 );
976  }
977 
978  mpi_free( &A ); mpi_free( &E ); mpi_free( &N );
979  mpi_free( &RR ); mpi_free( &Z ); mpi_free( &X );
980 }
981 
982 void test_suite_mpi_inv_mod( int radix_X, char *input_X, int radix_Y, char *input_Y,
983  int radix_A, char *input_A, int div_result )
984 {
985  mpi X, Y, Z, A;
986  int res;
987  mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z ); mpi_init( &A );
988 
989  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
990  TEST_ASSERT( mpi_read_string( &Y, radix_Y, input_Y ) == 0 );
991  TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
992  res = mpi_inv_mod( &Z, &X, &Y );
993  TEST_ASSERT( res == div_result );
994  if( res == 0 )
995  {
996  TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 );
997  }
998 
999  mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z ); mpi_free( &A );
1000 }
1001 
1002 #ifdef POLARSSL_GENPRIME
1003 void test_suite_mpi_is_prime( int radix_X, char *input_X, int div_result )
1004 {
1005  mpi X;
1006  int res;
1007  mpi_init( &X );
1008 
1009  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
1010  res = mpi_is_prime( &X, rnd_std_rand, NULL );
1011  TEST_ASSERT( res == div_result );
1012 
1013  mpi_free( &X );
1014 }
1015 #endif /* POLARSSL_GENPRIME */
1016 
1017 void test_suite_mpi_shift_l( int radix_X, char *input_X, int shift_X, int radix_A,
1018  char *input_A)
1019 {
1020  mpi X, A;
1021  mpi_init( &X ); mpi_init( &A );
1022 
1023  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
1024  TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
1025  TEST_ASSERT( mpi_shift_l( &X, shift_X ) == 0 );
1026  TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
1027 
1028  mpi_free( &X ); mpi_free( &A );
1029 }
1030 
1031 void test_suite_mpi_shift_r( int radix_X, char *input_X, int shift_X, int radix_A,
1032  char *input_A )
1033 {
1034  mpi X, A;
1035  mpi_init( &X ); mpi_init( &A );
1036 
1037  TEST_ASSERT( mpi_read_string( &X, radix_X, input_X ) == 0 );
1038  TEST_ASSERT( mpi_read_string( &A, radix_A, input_A ) == 0 );
1039  TEST_ASSERT( mpi_shift_r( &X, shift_X ) == 0 );
1040  TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 );
1041 
1042  mpi_free( &X ); mpi_free( &A );
1043 }
1044 
1045 #ifdef POLARSSL_SELF_TEST
1046 void test_suite_mpi_selftest()
1047 {
1048  TEST_ASSERT( mpi_self_test( 0 ) == 0 );
1049 }
1050 #endif /* POLARSSL_SELF_TEST */
1051 
1052 
1053 #endif /* POLARSSL_BIGNUM_C */
1054 
1055 
1056 int dep_check( char *str )
1057 {
1058  if( str == NULL )
1059  return( 1 );
1060 
1061  if( strcmp( str, "POLARSSL_SELF_TEST" ) == 0 )
1062  {
1063 #if defined(POLARSSL_SELF_TEST)
1064  return( 0 );
1065 #else
1066  return( 1 );
1067 #endif
1068  }
1069  if( strcmp( str, "POLARSSL_GENPRIME" ) == 0 )
1070  {
1071 #if defined(POLARSSL_GENPRIME)
1072  return( 0 );
1073 #else
1074  return( 1 );
1075 #endif
1076  }
1077 
1078 
1079  return( 1 );
1080 }
1081 
1082 int dispatch_test(int cnt, char *params[50])
1083 {
1084  int ret;
1085  ((void) cnt);
1086  ((void) params);
1087 
1088 #if defined(TEST_SUITE_ACTIVE)
1089  if( strcmp( params[0], "mpi_read_write_string" ) == 0 )
1090  {
1091 
1092  int param1;
1093  char *param2 = params[2];
1094  int param3;
1095  char *param4 = params[4];
1096  int param5;
1097  int param6;
1098  int param7;
1099 
1100  if( cnt != 8 )
1101  {
1102  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 8 );
1103  return( 2 );
1104  }
1105 
1106  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1107  if( verify_string( &param2 ) != 0 ) return( 2 );
1108  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1109  if( verify_string( &param4 ) != 0 ) return( 2 );
1110  if( verify_int( params[5], &param5 ) != 0 ) return( 2 );
1111  if( verify_int( params[6], &param6 ) != 0 ) return( 2 );
1112  if( verify_int( params[7], &param7 ) != 0 ) return( 2 );
1113 
1114  test_suite_mpi_read_write_string( param1, param2, param3, param4, param5, param6, param7 );
1115  return ( 0 );
1116 
1117  return ( 3 );
1118  }
1119  else
1120  if( strcmp( params[0], "mpi_read_binary" ) == 0 )
1121  {
1122 
1123  char *param1 = params[1];
1124  int param2;
1125  char *param3 = params[3];
1126 
1127  if( cnt != 4 )
1128  {
1129  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
1130  return( 2 );
1131  }
1132 
1133  if( verify_string( &param1 ) != 0 ) return( 2 );
1134  if( verify_int( params[2], &param2 ) != 0 ) return( 2 );
1135  if( verify_string( &param3 ) != 0 ) return( 2 );
1136 
1137  test_suite_mpi_read_binary( param1, param2, param3 );
1138  return ( 0 );
1139 
1140  return ( 3 );
1141  }
1142  else
1143  if( strcmp( params[0], "mpi_write_binary" ) == 0 )
1144  {
1145 
1146  int param1;
1147  char *param2 = params[2];
1148  char *param3 = params[3];
1149  int param4;
1150  int param5;
1151 
1152  if( cnt != 6 )
1153  {
1154  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 6 );
1155  return( 2 );
1156  }
1157 
1158  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1159  if( verify_string( &param2 ) != 0 ) return( 2 );
1160  if( verify_string( &param3 ) != 0 ) return( 2 );
1161  if( verify_int( params[4], &param4 ) != 0 ) return( 2 );
1162  if( verify_int( params[5], &param5 ) != 0 ) return( 2 );
1163 
1164  test_suite_mpi_write_binary( param1, param2, param3, param4, param5 );
1165  return ( 0 );
1166 
1167  return ( 3 );
1168  }
1169  else
1170  if( strcmp( params[0], "mpi_read_file" ) == 0 )
1171  {
1172  #ifdef POLARSSL_FS_IO
1173 
1174  int param1;
1175  char *param2 = params[2];
1176  char *param3 = params[3];
1177  int param4;
1178 
1179  if( cnt != 5 )
1180  {
1181  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 5 );
1182  return( 2 );
1183  }
1184 
1185  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1186  if( verify_string( &param2 ) != 0 ) return( 2 );
1187  if( verify_string( &param3 ) != 0 ) return( 2 );
1188  if( verify_int( params[4], &param4 ) != 0 ) return( 2 );
1189 
1190  test_suite_mpi_read_file( param1, param2, param3, param4 );
1191  return ( 0 );
1192  #endif /* POLARSSL_FS_IO */
1193 
1194  return ( 3 );
1195  }
1196  else
1197  if( strcmp( params[0], "mpi_write_file" ) == 0 )
1198  {
1199  #ifdef POLARSSL_FS_IO
1200 
1201  int param1;
1202  char *param2 = params[2];
1203  int param3;
1204  char *param4 = params[4];
1205 
1206  if( cnt != 5 )
1207  {
1208  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 5 );
1209  return( 2 );
1210  }
1211 
1212  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1213  if( verify_string( &param2 ) != 0 ) return( 2 );
1214  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1215  if( verify_string( &param4 ) != 0 ) return( 2 );
1216 
1217  test_suite_mpi_write_file( param1, param2, param3, param4 );
1218  return ( 0 );
1219  #endif /* POLARSSL_FS_IO */
1220 
1221  return ( 3 );
1222  }
1223  else
1224  if( strcmp( params[0], "mpi_get_bit" ) == 0 )
1225  {
1226 
1227  int param1;
1228  char *param2 = params[2];
1229  int param3;
1230  int param4;
1231 
1232  if( cnt != 5 )
1233  {
1234  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 5 );
1235  return( 2 );
1236  }
1237 
1238  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1239  if( verify_string( &param2 ) != 0 ) return( 2 );
1240  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1241  if( verify_int( params[4], &param4 ) != 0 ) return( 2 );
1242 
1243  test_suite_mpi_get_bit( param1, param2, param3, param4 );
1244  return ( 0 );
1245 
1246  return ( 3 );
1247  }
1248  else
1249  if( strcmp( params[0], "mpi_set_bit" ) == 0 )
1250  {
1251 
1252  int param1;
1253  char *param2 = params[2];
1254  int param3;
1255  int param4;
1256  int param5;
1257  char *param6 = params[6];
1258 
1259  if( cnt != 7 )
1260  {
1261  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 7 );
1262  return( 2 );
1263  }
1264 
1265  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1266  if( verify_string( &param2 ) != 0 ) return( 2 );
1267  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1268  if( verify_int( params[4], &param4 ) != 0 ) return( 2 );
1269  if( verify_int( params[5], &param5 ) != 0 ) return( 2 );
1270  if( verify_string( &param6 ) != 0 ) return( 2 );
1271 
1272  test_suite_mpi_set_bit( param1, param2, param3, param4, param5, param6 );
1273  return ( 0 );
1274 
1275  return ( 3 );
1276  }
1277  else
1278  if( strcmp( params[0], "mpi_lsb" ) == 0 )
1279  {
1280 
1281  int param1;
1282  char *param2 = params[2];
1283  int param3;
1284 
1285  if( cnt != 4 )
1286  {
1287  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
1288  return( 2 );
1289  }
1290 
1291  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1292  if( verify_string( &param2 ) != 0 ) return( 2 );
1293  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1294 
1295  test_suite_mpi_lsb( param1, param2, param3 );
1296  return ( 0 );
1297 
1298  return ( 3 );
1299  }
1300  else
1301  if( strcmp( params[0], "mpi_msb" ) == 0 )
1302  {
1303 
1304  int param1;
1305  char *param2 = params[2];
1306  int param3;
1307 
1308  if( cnt != 4 )
1309  {
1310  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
1311  return( 2 );
1312  }
1313 
1314  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1315  if( verify_string( &param2 ) != 0 ) return( 2 );
1316  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1317 
1318  test_suite_mpi_msb( param1, param2, param3 );
1319  return ( 0 );
1320 
1321  return ( 3 );
1322  }
1323  else
1324  if( strcmp( params[0], "mpi_gcd" ) == 0 )
1325  {
1326 
1327  int param1;
1328  char *param2 = params[2];
1329  int param3;
1330  char *param4 = params[4];
1331  int param5;
1332  char *param6 = params[6];
1333 
1334  if( cnt != 7 )
1335  {
1336  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 7 );
1337  return( 2 );
1338  }
1339 
1340  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1341  if( verify_string( &param2 ) != 0 ) return( 2 );
1342  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1343  if( verify_string( &param4 ) != 0 ) return( 2 );
1344  if( verify_int( params[5], &param5 ) != 0 ) return( 2 );
1345  if( verify_string( &param6 ) != 0 ) return( 2 );
1346 
1347  test_suite_mpi_gcd( param1, param2, param3, param4, param5, param6 );
1348  return ( 0 );
1349 
1350  return ( 3 );
1351  }
1352  else
1353  if( strcmp( params[0], "mpi_cmp_int" ) == 0 )
1354  {
1355 
1356  int param1;
1357  int param2;
1358  int param3;
1359 
1360  if( cnt != 4 )
1361  {
1362  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
1363  return( 2 );
1364  }
1365 
1366  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1367  if( verify_int( params[2], &param2 ) != 0 ) return( 2 );
1368  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1369 
1370  test_suite_mpi_cmp_int( param1, param2, param3 );
1371  return ( 0 );
1372 
1373  return ( 3 );
1374  }
1375  else
1376  if( strcmp( params[0], "mpi_cmp_mpi" ) == 0 )
1377  {
1378 
1379  int param1;
1380  char *param2 = params[2];
1381  int param3;
1382  char *param4 = params[4];
1383  int param5;
1384 
1385  if( cnt != 6 )
1386  {
1387  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 6 );
1388  return( 2 );
1389  }
1390 
1391  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1392  if( verify_string( &param2 ) != 0 ) return( 2 );
1393  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1394  if( verify_string( &param4 ) != 0 ) return( 2 );
1395  if( verify_int( params[5], &param5 ) != 0 ) return( 2 );
1396 
1397  test_suite_mpi_cmp_mpi( param1, param2, param3, param4, param5 );
1398  return ( 0 );
1399 
1400  return ( 3 );
1401  }
1402  else
1403  if( strcmp( params[0], "mpi_cmp_abs" ) == 0 )
1404  {
1405 
1406  int param1;
1407  char *param2 = params[2];
1408  int param3;
1409  char *param4 = params[4];
1410  int param5;
1411 
1412  if( cnt != 6 )
1413  {
1414  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 6 );
1415  return( 2 );
1416  }
1417 
1418  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1419  if( verify_string( &param2 ) != 0 ) return( 2 );
1420  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1421  if( verify_string( &param4 ) != 0 ) return( 2 );
1422  if( verify_int( params[5], &param5 ) != 0 ) return( 2 );
1423 
1424  test_suite_mpi_cmp_abs( param1, param2, param3, param4, param5 );
1425  return ( 0 );
1426 
1427  return ( 3 );
1428  }
1429  else
1430  if( strcmp( params[0], "mpi_copy" ) == 0 )
1431  {
1432 
1433  int param1;
1434  int param2;
1435 
1436  if( cnt != 3 )
1437  {
1438  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 3 );
1439  return( 2 );
1440  }
1441 
1442  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1443  if( verify_int( params[2], &param2 ) != 0 ) return( 2 );
1444 
1445  test_suite_mpi_copy( param1, param2 );
1446  return ( 0 );
1447 
1448  return ( 3 );
1449  }
1450  else
1451  if( strcmp( params[0], "mpi_copy_self" ) == 0 )
1452  {
1453 
1454  int param1;
1455 
1456  if( cnt != 2 )
1457  {
1458  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 2 );
1459  return( 2 );
1460  }
1461 
1462  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1463 
1464  test_suite_mpi_copy_self( param1 );
1465  return ( 0 );
1466 
1467  return ( 3 );
1468  }
1469  else
1470  if( strcmp( params[0], "mpi_swap" ) == 0 )
1471  {
1472 
1473  int param1;
1474  int param2;
1475 
1476  if( cnt != 3 )
1477  {
1478  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 3 );
1479  return( 2 );
1480  }
1481 
1482  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1483  if( verify_int( params[2], &param2 ) != 0 ) return( 2 );
1484 
1485  test_suite_mpi_swap( param1, param2 );
1486  return ( 0 );
1487 
1488  return ( 3 );
1489  }
1490  else
1491  if( strcmp( params[0], "mpi_add_mpi" ) == 0 )
1492  {
1493 
1494  int param1;
1495  char *param2 = params[2];
1496  int param3;
1497  char *param4 = params[4];
1498  int param5;
1499  char *param6 = params[6];
1500 
1501  if( cnt != 7 )
1502  {
1503  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 7 );
1504  return( 2 );
1505  }
1506 
1507  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1508  if( verify_string( &param2 ) != 0 ) return( 2 );
1509  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1510  if( verify_string( &param4 ) != 0 ) return( 2 );
1511  if( verify_int( params[5], &param5 ) != 0 ) return( 2 );
1512  if( verify_string( &param6 ) != 0 ) return( 2 );
1513 
1514  test_suite_mpi_add_mpi( param1, param2, param3, param4, param5, param6 );
1515  return ( 0 );
1516 
1517  return ( 3 );
1518  }
1519  else
1520  if( strcmp( params[0], "mpi_add_abs" ) == 0 )
1521  {
1522 
1523  int param1;
1524  char *param2 = params[2];
1525  int param3;
1526  char *param4 = params[4];
1527  int param5;
1528  char *param6 = params[6];
1529 
1530  if( cnt != 7 )
1531  {
1532  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 7 );
1533  return( 2 );
1534  }
1535 
1536  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1537  if( verify_string( &param2 ) != 0 ) return( 2 );
1538  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1539  if( verify_string( &param4 ) != 0 ) return( 2 );
1540  if( verify_int( params[5], &param5 ) != 0 ) return( 2 );
1541  if( verify_string( &param6 ) != 0 ) return( 2 );
1542 
1543  test_suite_mpi_add_abs( param1, param2, param3, param4, param5, param6 );
1544  return ( 0 );
1545 
1546  return ( 3 );
1547  }
1548  else
1549  if( strcmp( params[0], "mpi_add_abs_add_first" ) == 0 )
1550  {
1551 
1552  int param1;
1553  char *param2 = params[2];
1554  int param3;
1555  char *param4 = params[4];
1556  int param5;
1557  char *param6 = params[6];
1558 
1559  if( cnt != 7 )
1560  {
1561  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 7 );
1562  return( 2 );
1563  }
1564 
1565  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1566  if( verify_string( &param2 ) != 0 ) return( 2 );
1567  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1568  if( verify_string( &param4 ) != 0 ) return( 2 );
1569  if( verify_int( params[5], &param5 ) != 0 ) return( 2 );
1570  if( verify_string( &param6 ) != 0 ) return( 2 );
1571 
1572  test_suite_mpi_add_abs_add_first( param1, param2, param3, param4, param5, param6 );
1573  return ( 0 );
1574 
1575  return ( 3 );
1576  }
1577  else
1578  if( strcmp( params[0], "mpi_add_abs_add_second" ) == 0 )
1579  {
1580 
1581  int param1;
1582  char *param2 = params[2];
1583  int param3;
1584  char *param4 = params[4];
1585  int param5;
1586  char *param6 = params[6];
1587 
1588  if( cnt != 7 )
1589  {
1590  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 7 );
1591  return( 2 );
1592  }
1593 
1594  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1595  if( verify_string( &param2 ) != 0 ) return( 2 );
1596  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1597  if( verify_string( &param4 ) != 0 ) return( 2 );
1598  if( verify_int( params[5], &param5 ) != 0 ) return( 2 );
1599  if( verify_string( &param6 ) != 0 ) return( 2 );
1600 
1601  test_suite_mpi_add_abs_add_second( param1, param2, param3, param4, param5, param6 );
1602  return ( 0 );
1603 
1604  return ( 3 );
1605  }
1606  else
1607  if( strcmp( params[0], "mpi_add_int" ) == 0 )
1608  {
1609 
1610  int param1;
1611  char *param2 = params[2];
1612  int param3;
1613  int param4;
1614  char *param5 = params[5];
1615 
1616  if( cnt != 6 )
1617  {
1618  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 6 );
1619  return( 2 );
1620  }
1621 
1622  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1623  if( verify_string( &param2 ) != 0 ) return( 2 );
1624  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1625  if( verify_int( params[4], &param4 ) != 0 ) return( 2 );
1626  if( verify_string( &param5 ) != 0 ) return( 2 );
1627 
1628  test_suite_mpi_add_int( param1, param2, param3, param4, param5 );
1629  return ( 0 );
1630 
1631  return ( 3 );
1632  }
1633  else
1634  if( strcmp( params[0], "mpi_sub_mpi" ) == 0 )
1635  {
1636 
1637  int param1;
1638  char *param2 = params[2];
1639  int param3;
1640  char *param4 = params[4];
1641  int param5;
1642  char *param6 = params[6];
1643 
1644  if( cnt != 7 )
1645  {
1646  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 7 );
1647  return( 2 );
1648  }
1649 
1650  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1651  if( verify_string( &param2 ) != 0 ) return( 2 );
1652  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1653  if( verify_string( &param4 ) != 0 ) return( 2 );
1654  if( verify_int( params[5], &param5 ) != 0 ) return( 2 );
1655  if( verify_string( &param6 ) != 0 ) return( 2 );
1656 
1657  test_suite_mpi_sub_mpi( param1, param2, param3, param4, param5, param6 );
1658  return ( 0 );
1659 
1660  return ( 3 );
1661  }
1662  else
1663  if( strcmp( params[0], "mpi_sub_abs" ) == 0 )
1664  {
1665 
1666  int param1;
1667  char *param2 = params[2];
1668  int param3;
1669  char *param4 = params[4];
1670  int param5;
1671  char *param6 = params[6];
1672  int param7;
1673 
1674  if( cnt != 8 )
1675  {
1676  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 8 );
1677  return( 2 );
1678  }
1679 
1680  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1681  if( verify_string( &param2 ) != 0 ) return( 2 );
1682  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1683  if( verify_string( &param4 ) != 0 ) return( 2 );
1684  if( verify_int( params[5], &param5 ) != 0 ) return( 2 );
1685  if( verify_string( &param6 ) != 0 ) return( 2 );
1686  if( verify_int( params[7], &param7 ) != 0 ) return( 2 );
1687 
1688  test_suite_mpi_sub_abs( param1, param2, param3, param4, param5, param6, param7 );
1689  return ( 0 );
1690 
1691  return ( 3 );
1692  }
1693  else
1694  if( strcmp( params[0], "mpi_sub_int" ) == 0 )
1695  {
1696 
1697  int param1;
1698  char *param2 = params[2];
1699  int param3;
1700  int param4;
1701  char *param5 = params[5];
1702 
1703  if( cnt != 6 )
1704  {
1705  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 6 );
1706  return( 2 );
1707  }
1708 
1709  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1710  if( verify_string( &param2 ) != 0 ) return( 2 );
1711  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1712  if( verify_int( params[4], &param4 ) != 0 ) return( 2 );
1713  if( verify_string( &param5 ) != 0 ) return( 2 );
1714 
1715  test_suite_mpi_sub_int( param1, param2, param3, param4, param5 );
1716  return ( 0 );
1717 
1718  return ( 3 );
1719  }
1720  else
1721  if( strcmp( params[0], "mpi_mul_mpi" ) == 0 )
1722  {
1723 
1724  int param1;
1725  char *param2 = params[2];
1726  int param3;
1727  char *param4 = params[4];
1728  int param5;
1729  char *param6 = params[6];
1730 
1731  if( cnt != 7 )
1732  {
1733  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 7 );
1734  return( 2 );
1735  }
1736 
1737  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1738  if( verify_string( &param2 ) != 0 ) return( 2 );
1739  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1740  if( verify_string( &param4 ) != 0 ) return( 2 );
1741  if( verify_int( params[5], &param5 ) != 0 ) return( 2 );
1742  if( verify_string( &param6 ) != 0 ) return( 2 );
1743 
1744  test_suite_mpi_mul_mpi( param1, param2, param3, param4, param5, param6 );
1745  return ( 0 );
1746 
1747  return ( 3 );
1748  }
1749  else
1750  if( strcmp( params[0], "mpi_mul_int" ) == 0 )
1751  {
1752 
1753  int param1;
1754  char *param2 = params[2];
1755  int param3;
1756  int param4;
1757  char *param5 = params[5];
1758  char *param6 = params[6];
1759 
1760  if( cnt != 7 )
1761  {
1762  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 7 );
1763  return( 2 );
1764  }
1765 
1766  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1767  if( verify_string( &param2 ) != 0 ) return( 2 );
1768  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1769  if( verify_int( params[4], &param4 ) != 0 ) return( 2 );
1770  if( verify_string( &param5 ) != 0 ) return( 2 );
1771  if( verify_string( &param6 ) != 0 ) return( 2 );
1772 
1773  test_suite_mpi_mul_int( param1, param2, param3, param4, param5, param6 );
1774  return ( 0 );
1775 
1776  return ( 3 );
1777  }
1778  else
1779  if( strcmp( params[0], "mpi_div_mpi" ) == 0 )
1780  {
1781 
1782  int param1;
1783  char *param2 = params[2];
1784  int param3;
1785  char *param4 = params[4];
1786  int param5;
1787  char *param6 = params[6];
1788  int param7;
1789  char *param8 = params[8];
1790  int param9;
1791 
1792  if( cnt != 10 )
1793  {
1794  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 10 );
1795  return( 2 );
1796  }
1797 
1798  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1799  if( verify_string( &param2 ) != 0 ) return( 2 );
1800  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1801  if( verify_string( &param4 ) != 0 ) return( 2 );
1802  if( verify_int( params[5], &param5 ) != 0 ) return( 2 );
1803  if( verify_string( &param6 ) != 0 ) return( 2 );
1804  if( verify_int( params[7], &param7 ) != 0 ) return( 2 );
1805  if( verify_string( &param8 ) != 0 ) return( 2 );
1806  if( verify_int( params[9], &param9 ) != 0 ) return( 2 );
1807 
1808  test_suite_mpi_div_mpi( param1, param2, param3, param4, param5, param6, param7, param8, param9 );
1809  return ( 0 );
1810 
1811  return ( 3 );
1812  }
1813  else
1814  if( strcmp( params[0], "mpi_div_int" ) == 0 )
1815  {
1816 
1817  int param1;
1818  char *param2 = params[2];
1819  int param3;
1820  int param4;
1821  char *param5 = params[5];
1822  int param6;
1823  char *param7 = params[7];
1824  int param8;
1825 
1826  if( cnt != 9 )
1827  {
1828  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 9 );
1829  return( 2 );
1830  }
1831 
1832  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1833  if( verify_string( &param2 ) != 0 ) return( 2 );
1834  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1835  if( verify_int( params[4], &param4 ) != 0 ) return( 2 );
1836  if( verify_string( &param5 ) != 0 ) return( 2 );
1837  if( verify_int( params[6], &param6 ) != 0 ) return( 2 );
1838  if( verify_string( &param7 ) != 0 ) return( 2 );
1839  if( verify_int( params[8], &param8 ) != 0 ) return( 2 );
1840 
1841  test_suite_mpi_div_int( param1, param2, param3, param4, param5, param6, param7, param8 );
1842  return ( 0 );
1843 
1844  return ( 3 );
1845  }
1846  else
1847  if( strcmp( params[0], "mpi_mod_mpi" ) == 0 )
1848  {
1849 
1850  int param1;
1851  char *param2 = params[2];
1852  int param3;
1853  char *param4 = params[4];
1854  int param5;
1855  char *param6 = params[6];
1856  int param7;
1857 
1858  if( cnt != 8 )
1859  {
1860  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 8 );
1861  return( 2 );
1862  }
1863 
1864  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1865  if( verify_string( &param2 ) != 0 ) return( 2 );
1866  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1867  if( verify_string( &param4 ) != 0 ) return( 2 );
1868  if( verify_int( params[5], &param5 ) != 0 ) return( 2 );
1869  if( verify_string( &param6 ) != 0 ) return( 2 );
1870  if( verify_int( params[7], &param7 ) != 0 ) return( 2 );
1871 
1872  test_suite_mpi_mod_mpi( param1, param2, param3, param4, param5, param6, param7 );
1873  return ( 0 );
1874 
1875  return ( 3 );
1876  }
1877  else
1878  if( strcmp( params[0], "mpi_mod_int" ) == 0 )
1879  {
1880 
1881  int param1;
1882  char *param2 = params[2];
1883  int param3;
1884  int param4;
1885  int param5;
1886 
1887  if( cnt != 6 )
1888  {
1889  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 6 );
1890  return( 2 );
1891  }
1892 
1893  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1894  if( verify_string( &param2 ) != 0 ) return( 2 );
1895  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1896  if( verify_int( params[4], &param4 ) != 0 ) return( 2 );
1897  if( verify_int( params[5], &param5 ) != 0 ) return( 2 );
1898 
1899  test_suite_mpi_mod_int( param1, param2, param3, param4, param5 );
1900  return ( 0 );
1901 
1902  return ( 3 );
1903  }
1904  else
1905  if( strcmp( params[0], "mpi_exp_mod" ) == 0 )
1906  {
1907 
1908  int param1;
1909  char *param2 = params[2];
1910  int param3;
1911  char *param4 = params[4];
1912  int param5;
1913  char *param6 = params[6];
1914  int param7;
1915  char *param8 = params[8];
1916  int param9;
1917  char *param10 = params[10];
1918  int param11;
1919 
1920  if( cnt != 12 )
1921  {
1922  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 12 );
1923  return( 2 );
1924  }
1925 
1926  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1927  if( verify_string( &param2 ) != 0 ) return( 2 );
1928  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1929  if( verify_string( &param4 ) != 0 ) return( 2 );
1930  if( verify_int( params[5], &param5 ) != 0 ) return( 2 );
1931  if( verify_string( &param6 ) != 0 ) return( 2 );
1932  if( verify_int( params[7], &param7 ) != 0 ) return( 2 );
1933  if( verify_string( &param8 ) != 0 ) return( 2 );
1934  if( verify_int( params[9], &param9 ) != 0 ) return( 2 );
1935  if( verify_string( &param10 ) != 0 ) return( 2 );
1936  if( verify_int( params[11], &param11 ) != 0 ) return( 2 );
1937 
1938  test_suite_mpi_exp_mod( param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11 );
1939  return ( 0 );
1940 
1941  return ( 3 );
1942  }
1943  else
1944  if( strcmp( params[0], "mpi_inv_mod" ) == 0 )
1945  {
1946 
1947  int param1;
1948  char *param2 = params[2];
1949  int param3;
1950  char *param4 = params[4];
1951  int param5;
1952  char *param6 = params[6];
1953  int param7;
1954 
1955  if( cnt != 8 )
1956  {
1957  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 8 );
1958  return( 2 );
1959  }
1960 
1961  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1962  if( verify_string( &param2 ) != 0 ) return( 2 );
1963  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1964  if( verify_string( &param4 ) != 0 ) return( 2 );
1965  if( verify_int( params[5], &param5 ) != 0 ) return( 2 );
1966  if( verify_string( &param6 ) != 0 ) return( 2 );
1967  if( verify_int( params[7], &param7 ) != 0 ) return( 2 );
1968 
1969  test_suite_mpi_inv_mod( param1, param2, param3, param4, param5, param6, param7 );
1970  return ( 0 );
1971 
1972  return ( 3 );
1973  }
1974  else
1975  if( strcmp( params[0], "mpi_is_prime" ) == 0 )
1976  {
1977  #ifdef POLARSSL_GENPRIME
1978 
1979  int param1;
1980  char *param2 = params[2];
1981  int param3;
1982 
1983  if( cnt != 4 )
1984  {
1985  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
1986  return( 2 );
1987  }
1988 
1989  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
1990  if( verify_string( &param2 ) != 0 ) return( 2 );
1991  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
1992 
1993  test_suite_mpi_is_prime( param1, param2, param3 );
1994  return ( 0 );
1995  #endif /* POLARSSL_GENPRIME */
1996 
1997  return ( 3 );
1998  }
1999  else
2000  if( strcmp( params[0], "mpi_shift_l" ) == 0 )
2001  {
2002 
2003  int param1;
2004  char *param2 = params[2];
2005  int param3;
2006  int param4;
2007  char *param5 = params[5];
2008 
2009  if( cnt != 6 )
2010  {
2011  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 6 );
2012  return( 2 );
2013  }
2014 
2015  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
2016  if( verify_string( &param2 ) != 0 ) return( 2 );
2017  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
2018  if( verify_int( params[4], &param4 ) != 0 ) return( 2 );
2019  if( verify_string( &param5 ) != 0 ) return( 2 );
2020 
2021  test_suite_mpi_shift_l( param1, param2, param3, param4, param5 );
2022  return ( 0 );
2023 
2024  return ( 3 );
2025  }
2026  else
2027  if( strcmp( params[0], "mpi_shift_r" ) == 0 )
2028  {
2029 
2030  int param1;
2031  char *param2 = params[2];
2032  int param3;
2033  int param4;
2034  char *param5 = params[5];
2035 
2036  if( cnt != 6 )
2037  {
2038  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 6 );
2039  return( 2 );
2040  }
2041 
2042  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
2043  if( verify_string( &param2 ) != 0 ) return( 2 );
2044  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
2045  if( verify_int( params[4], &param4 ) != 0 ) return( 2 );
2046  if( verify_string( &param5 ) != 0 ) return( 2 );
2047 
2048  test_suite_mpi_shift_r( param1, param2, param3, param4, param5 );
2049  return ( 0 );
2050 
2051  return ( 3 );
2052  }
2053  else
2054  if( strcmp( params[0], "mpi_selftest" ) == 0 )
2055  {
2056  #ifdef POLARSSL_SELF_TEST
2057 
2058 
2059  if( cnt != 1 )
2060  {
2061  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 1 );
2062  return( 2 );
2063  }
2064 
2065 
2066  test_suite_mpi_selftest( );
2067  return ( 0 );
2068  #endif /* POLARSSL_SELF_TEST */
2069 
2070  return ( 3 );
2071  }
2072  else
2073 
2074  {
2075  fprintf( stdout, "FAILED\nSkipping unknown test function '%s'\n", params[0] );
2076  fflush( stdout );
2077  return( 1 );
2078  }
2079 #else
2080  return( 3 );
2081 #endif
2082  return( ret );
2083 }
2084 
2085 int get_line( FILE *f, char *buf, size_t len )
2086 {
2087  char *ret;
2088 
2089  ret = fgets( buf, len, f );
2090  if( ret == NULL )
2091  return( -1 );
2092 
2093  if( strlen( buf ) && buf[strlen(buf) - 1] == '\n' )
2094  buf[strlen(buf) - 1] = '\0';
2095  if( strlen( buf ) && buf[strlen(buf) - 1] == '\r' )
2096  buf[strlen(buf) - 1] = '\0';
2097 
2098  return( 0 );
2099 }
2100 
2101 int parse_arguments( char *buf, size_t len, char *params[50] )
2102 {
2103  int cnt = 0, i;
2104  char *cur = buf;
2105  char *p = buf, *q;
2106 
2107  params[cnt++] = cur;
2108 
2109  while( *p != '\0' && p < buf + len )
2110  {
2111  if( *p == '\\' )
2112  {
2113  *p++;
2114  *p++;
2115  continue;
2116  }
2117  if( *p == ':' )
2118  {
2119  if( p + 1 < buf + len )
2120  {
2121  cur = p + 1;
2122  params[cnt++] = cur;
2123  }
2124  *p = '\0';
2125  }
2126 
2127  *p++;
2128  }
2129 
2130  // Replace newlines, question marks and colons in strings
2131  for( i = 0; i < cnt; i++ )
2132  {
2133  p = params[i];
2134  q = params[i];
2135 
2136  while( *p != '\0' )
2137  {
2138  if( *p == '\\' && *(p + 1) == 'n' )
2139  {
2140  p += 2;
2141  *(q++) = '\n';
2142  }
2143  else if( *p == '\\' && *(p + 1) == ':' )
2144  {
2145  p += 2;
2146  *(q++) = ':';
2147  }
2148  else if( *p == '\\' && *(p + 1) == '?' )
2149  {
2150  p += 2;
2151  *(q++) = '?';
2152  }
2153  else
2154  *(q++) = *(p++);
2155  }
2156  *q = '\0';
2157  }
2158 
2159  return( cnt );
2160 }
2161 
2162 int main()
2163 {
2164  int ret, i, cnt, total_errors = 0, total_tests = 0, total_skipped = 0;
2165  const char *filename = "/home/iurt/rpmbuild/BUILD/polarssl-1.3.1/tests/suites/test_suite_mpi.data";
2166  FILE *file;
2167  char buf[5000];
2168  char *params[50];
2169 
2170 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
2171  unsigned char alloc_buf[1000000];
2172  memory_buffer_alloc_init( alloc_buf, sizeof(alloc_buf) );
2173 #endif
2174 
2175  file = fopen( filename, "r" );
2176  if( file == NULL )
2177  {
2178  fprintf( stderr, "Failed to open\n" );
2179  return( 1 );
2180  }
2181 
2182  while( !feof( file ) )
2183  {
2184  int skip = 0;
2185 
2186  if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
2187  break;
2188  fprintf( stdout, "%s%.66s", test_errors ? "\n" : "", buf );
2189  fprintf( stdout, " " );
2190  for( i = strlen( buf ) + 1; i < 67; i++ )
2191  fprintf( stdout, "." );
2192  fprintf( stdout, " " );
2193  fflush( stdout );
2194 
2195  total_tests++;
2196 
2197  if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
2198  break;
2199  cnt = parse_arguments( buf, strlen(buf), params );
2200 
2201  if( strcmp( params[0], "depends_on" ) == 0 )
2202  {
2203  for( i = 1; i < cnt; i++ )
2204  if( dep_check( params[i] ) != 0 )
2205  skip = 1;
2206 
2207  if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
2208  break;
2209  cnt = parse_arguments( buf, strlen(buf), params );
2210  }
2211 
2212  if( skip == 0 )
2213  {
2214  test_errors = 0;
2215  ret = dispatch_test( cnt, params );
2216  }
2217 
2218  if( skip == 1 || ret == 3 )
2219  {
2220  total_skipped++;
2221  fprintf( stdout, "----\n" );
2222  fflush( stdout );
2223  }
2224  else if( ret == 0 && test_errors == 0 )
2225  {
2226  fprintf( stdout, "PASS\n" );
2227  fflush( stdout );
2228  }
2229  else if( ret == 2 )
2230  {
2231  fprintf( stderr, "FAILED: FATAL PARSE ERROR\n" );
2232  fclose(file);
2233  exit( 2 );
2234  }
2235  else
2236  total_errors++;
2237 
2238  if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
2239  break;
2240  if( strlen(buf) != 0 )
2241  {
2242  fprintf( stderr, "Should be empty %d\n", (int) strlen(buf) );
2243  return( 1 );
2244  }
2245  }
2246  fclose(file);
2247 
2248  fprintf( stdout, "\n----------------------------------------------------------------------------\n\n");
2249  if( total_errors == 0 )
2250  fprintf( stdout, "PASSED" );
2251  else
2252  fprintf( stdout, "FAILED" );
2253 
2254  fprintf( stdout, " (%d / %d tests (%d skipped))\n",
2255  total_tests - total_errors, total_tests, total_skipped );
2256 
2257 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
2258 #if defined(POLARSSL_MEMORY_DEBUG)
2259  memory_buffer_alloc_status();
2260 #endif
2261  memory_buffer_alloc_free();
2262 #endif
2263 
2264  return( total_errors != 0 );
2265 }
2266 
2267 
int mpi_cmp_int(const mpi *X, t_sint z)
Compare signed values.
#define POLARSSL_ERR_MPI_INVALID_CHARACTER
There is an invalid character in the digit string.
Definition: bignum.h:54
void mpi_swap(mpi *X, mpi *Y)
Swap the contents of X and Y.
Memory allocation layer.
static int test_errors
uint32_t t_uint
Definition: bignum.h:146
int mpi_div_int(mpi *Q, mpi *R, const mpi *A, t_sint b)
Division by int: A = Q * b + R.
#define POLARSSL_ERR_MPI_NEGATIVE_VALUE
The input arguments are negative or result in illegal output.
Definition: bignum.h:56
static void hexify(unsigned char *obuf, const unsigned char *ibuf, int len)
int mpi_gcd(mpi *G, const mpi *A, const mpi *B)
Greatest common divisor: G = gcd(A, B)
Info structure for the pseudo random function.
int mpi_sub_abs(mpi *X, const mpi *A, const mpi *B)
Unsigned substraction: X = |A| - |B|.
static int rnd_std_rand(void *rng_state, unsigned char *output, size_t len)
This function just returns data from rand().
int mpi_cmp_abs(const mpi *X, const mpi *Y)
Compare unsigned values.
Configuration options (set of defines)
int mpi_add_int(mpi *X, const mpi *A, t_sint b)
Signed addition: X = A + b.
int mpi_read_file(mpi *X, int radix, FILE *fin)
Read X from an opened file.
int mpi_div_mpi(mpi *Q, mpi *R, const mpi *A, const mpi *B)
Division by mpi: A = Q * B + R.
int mpi_lset(mpi *X, t_sint z)
Set value from integer.
int mpi_is_prime(mpi *X, int(*f_rng)(void *, unsigned char *, size_t), void *p_rng)
Miller-Rabin primality test.
MPI structure.
Definition: bignum.h:168
#define POLARSSL_ERR_MPI_BAD_INPUT_DATA
Bad input parameters to function.
Definition: bignum.h:53
static int not_rnd(void *in, unsigned char *out, size_t len)
This function returns a buffer given as a hex string.
static int test_assert(int correct, char *test)
static int unhexify(unsigned char *obuf, const char *ibuf)
int mpi_write_file(const char *p, const mpi *X, int radix, FILE *fout)
Write X into an opened file, or stdout if fout is NULL.
void mpi_init(mpi *X)
Initialize one MPI.
int main(int argc, char *argv[])
int mpi_cmp_mpi(const mpi *X, const mpi *Y)
Compare signed values.
Multi-precision integer library.
int mpi_shift_r(mpi *X, size_t count)
Right-shift: X &gt;&gt;= count.
static int rnd_pseudo_rand(void *rng_state, unsigned char *output, size_t len)
This function returns random based on a pseudo random function.
int dep_check(char *str)
int mpi_add_mpi(mpi *X, const mpi *A, const mpi *B)
Signed addition: X = A + B.
#define TEST_ASSERT(TEST)
#define POLARSSL_ERR_MPI_DIVISION_BY_ZERO
The input argument for division is zero, which is not allowed.
Definition: bignum.h:57
int mpi_write_string(const mpi *X, int radix, char *s, size_t *slen)
Export into an ASCII string.
size_t mpi_lsb(const mpi *X)
Return the number of zero-bits before the least significant &#39;1&#39; bit.
#define POLARSSL_ERR_MPI_BUFFER_TOO_SMALL
The buffer is too small to write to.
Definition: bignum.h:55
int mpi_inv_mod(mpi *X, const mpi *A, const mpi *N)
Modular inverse: X = A^-1 mod N.
void mpi_free(mpi *X)
Unallocate one MPI.
int mpi_mul_int(mpi *X, const mpi *A, t_sint b)
Baseline multiplication: X = A * b Note: b is an unsigned integer type, thus Negative values of b are...
#define PUT_UINT32_BE(n, b, i)
int mpi_mod_int(t_uint *r, const mpi *A, t_sint b)
Modulo: r = A mod b.
int mpi_exp_mod(mpi *X, const mpi *A, const mpi *E, const mpi *N, mpi *_RR)
Sliding-window exponentiation: X = A^E mod N.
int parse_arguments(char *buf, size_t len, char *params[50])
size_t mpi_msb(const mpi *X)
Return the number of bits up to and including the most significant &#39;1&#39; bit&#39;.
int mpi_add_abs(mpi *X, const mpi *A, const mpi *B)
Unsigned addition: X = |A| + |B|.
int mpi_read_string(mpi *X, int radix, const char *s)
Import from an ASCII string.
static int rnd_zero_rand(void *rng_state, unsigned char *output, size_t len)
This function only returns zeros.
int mpi_read_binary(mpi *X, const unsigned char *buf, size_t buflen)
Import X from unsigned binary data, big endian.
int mpi_self_test(int verbose)
Checkup routine.
int verify_string(char **str)
size_t mpi_size(const mpi *X)
Return the total size in bytes.
int mpi_copy(mpi *X, const mpi *Y)
Copy the contents of Y into X.
int dispatch_test(int cnt, char *params[50])
int mpi_mod_mpi(mpi *R, const mpi *A, const mpi *B)
Modulo: R = A mod B.
int mpi_get_bit(const mpi *X, size_t pos)
Get a specific bit from X.
int mpi_write_binary(const mpi *X, unsigned char *buf, size_t buflen)
Export X into unsigned binary data, big endian.
unsigned char * buf
#define POLARSSL_ERR_MPI_FILE_IO_ERROR
An error occurred while reading from or writing to a file.
Definition: bignum.h:52
int mpi_shift_l(mpi *X, size_t count)
Left-shift: X &lt;&lt;= count.
static int rnd_buffer_rand(void *rng_state, unsigned char *output, size_t len)
This function returns random based on a buffer it receives.
int mpi_mul_mpi(mpi *X, const mpi *A, const mpi *B)
Baseline multiplication: X = A * B.
int verify_int(char *str, int *value)
int mpi_sub_mpi(mpi *X, const mpi *A, const mpi *B)
Signed substraction: X = A - B.
int mpi_set_bit(mpi *X, size_t pos, unsigned char val)
Set a bit of X to a specific value of 0 or 1.
int mpi_sub_int(mpi *X, const mpi *A, t_sint b)
Signed substraction: X = A - b.
#define POLARSSL_ERR_MPI_NOT_ACCEPTABLE
The input arguments are not acceptable.
Definition: bignum.h:58
int get_line(FILE *f, char *buf, size_t len)