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