PolarSSL v1.3.1
test_suite_dhm.c
Go to the documentation of this file.
1 #include <polarssl/config.h>
2 
3 #ifdef POLARSSL_DHM_C
4 #ifdef POLARSSL_BIGNUM_C
5 
6 #include <polarssl/dhm.h>
7 #endif /* POLARSSL_DHM_C */
8 #endif /* POLARSSL_BIGNUM_C */
9 
10 
11 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
12 #include "polarssl/memory.h"
13 #endif
14 
15 #ifdef _MSC_VER
16 #include <basetsd.h>
17 typedef UINT32 uint32_t;
18 #else
19 #include <inttypes.h>
20 #endif
21 
22 #include <assert.h>
23 #include <stdlib.h>
24 #include <string.h>
25 
26 /*
27  * 32-bit integer manipulation macros (big endian)
28  */
29 #ifndef GET_UINT32_BE
30 #define GET_UINT32_BE(n,b,i) \
31 { \
32  (n) = ( (uint32_t) (b)[(i) ] << 24 ) \
33  | ( (uint32_t) (b)[(i) + 1] << 16 ) \
34  | ( (uint32_t) (b)[(i) + 2] << 8 ) \
35  | ( (uint32_t) (b)[(i) + 3] ); \
36 }
37 #endif
38 
39 #ifndef PUT_UINT32_BE
40 #define PUT_UINT32_BE(n,b,i) \
41 { \
42  (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
43  (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
44  (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
45  (b)[(i) + 3] = (unsigned char) ( (n) ); \
46 }
47 #endif
48 
49 static int unhexify(unsigned char *obuf, const char *ibuf)
50 {
51  unsigned char c, c2;
52  int len = strlen(ibuf) / 2;
53  assert(!(strlen(ibuf) %1)); // must be even number of bytes
54 
55  while (*ibuf != 0)
56  {
57  c = *ibuf++;
58  if( c >= '0' && c <= '9' )
59  c -= '0';
60  else if( c >= 'a' && c <= 'f' )
61  c -= 'a' - 10;
62  else if( c >= 'A' && c <= 'F' )
63  c -= 'A' - 10;
64  else
65  assert( 0 );
66 
67  c2 = *ibuf++;
68  if( c2 >= '0' && c2 <= '9' )
69  c2 -= '0';
70  else if( c2 >= 'a' && c2 <= 'f' )
71  c2 -= 'a' - 10;
72  else if( c2 >= 'A' && c2 <= 'F' )
73  c2 -= 'A' - 10;
74  else
75  assert( 0 );
76 
77  *obuf++ = ( c << 4 ) | c2;
78  }
79 
80  return len;
81 }
82 
83 static void hexify(unsigned char *obuf, const unsigned char *ibuf, int len)
84 {
85  unsigned char l, h;
86 
87  while (len != 0)
88  {
89  h = (*ibuf) / 16;
90  l = (*ibuf) % 16;
91 
92  if( h < 10 )
93  *obuf++ = '0' + h;
94  else
95  *obuf++ = 'a' + h - 10;
96 
97  if( l < 10 )
98  *obuf++ = '0' + l;
99  else
100  *obuf++ = 'a' + l - 10;
101 
102  ++ibuf;
103  len--;
104  }
105 }
106 
116 static int rnd_std_rand( void *rng_state, unsigned char *output, size_t len )
117 {
118  size_t i;
119 
120  if( rng_state != NULL )
121  rng_state = NULL;
122 
123  for( i = 0; i < len; ++i )
124  output[i] = rand();
125 
126  return( 0 );
127 }
128 
134 static int rnd_zero_rand( void *rng_state, unsigned char *output, size_t len )
135 {
136  if( rng_state != NULL )
137  rng_state = NULL;
138 
139  memset( output, 0, len );
140 
141  return( 0 );
142 }
143 
144 typedef struct
145 {
146  unsigned char *buf;
147  size_t length;
148 } rnd_buf_info;
149 
161 static int rnd_buffer_rand( void *rng_state, unsigned char *output, size_t len )
162 {
163  rnd_buf_info *info = (rnd_buf_info *) rng_state;
164  size_t use_len;
165 
166  if( rng_state == NULL )
167  return( rnd_std_rand( NULL, output, len ) );
168 
169  use_len = len;
170  if( len > info->length )
171  use_len = info->length;
172 
173  if( use_len )
174  {
175  memcpy( output, info->buf, use_len );
176  info->buf += use_len;
177  info->length -= use_len;
178  }
179 
180  if( len - use_len > 0 )
181  return( rnd_std_rand( NULL, output + use_len, len - use_len ) );
182 
183  return( 0 );
184 }
185 
193 typedef struct
194 {
195  uint32_t key[16];
196  uint32_t v0, v1;
198 
207 static int rnd_pseudo_rand( void *rng_state, unsigned char *output, size_t len )
208 {
209  rnd_pseudo_info *info = (rnd_pseudo_info *) rng_state;
210  uint32_t i, *k, sum, delta=0x9E3779B9;
211  unsigned char result[4];
212 
213  if( rng_state == NULL )
214  return( rnd_std_rand( NULL, output, len ) );
215 
216  k = info->key;
217 
218  while( len > 0 )
219  {
220  size_t use_len = ( len > 4 ) ? 4 : len;
221  sum = 0;
222 
223  for( i = 0; i < 32; i++ )
224  {
225  info->v0 += (((info->v1 << 4) ^ (info->v1 >> 5)) + info->v1) ^ (sum + k[sum & 3]);
226  sum += delta;
227  info->v1 += (((info->v0 << 4) ^ (info->v0 >> 5)) + info->v0) ^ (sum + k[(sum>>11) & 3]);
228  }
229 
230  PUT_UINT32_BE( info->v0, result, 0 );
231  memcpy( output, result, use_len );
232  len -= use_len;
233  }
234 
235  return( 0 );
236 }
237 
247 static int not_rnd( void *in, unsigned char *out, size_t len )
248 {
249  unsigned char *obuf;
250  const char *ibuf = in;
251  unsigned char c, c2;
252  assert( len == strlen(ibuf) / 2 );
253  assert(!(strlen(ibuf) %1)); // must be even number of bytes
254 
255  obuf = out + (len - 1); // sic
256  while (*ibuf != 0)
257  {
258  c = *ibuf++;
259  if( c >= '0' && c <= '9' )
260  c -= '0';
261  else if( c >= 'a' && c <= 'f' )
262  c -= 'a' - 10;
263  else if( c >= 'A' && c <= 'F' )
264  c -= 'A' - 10;
265  else
266  assert( 0 );
267 
268  c2 = *ibuf++;
269  if( c2 >= '0' && c2 <= '9' )
270  c2 -= '0';
271  else if( c2 >= 'a' && c2 <= 'f' )
272  c2 -= 'a' - 10;
273  else if( c2 >= 'A' && c2 <= 'F' )
274  c2 -= 'A' - 10;
275  else
276  assert( 0 );
277 
278  *obuf-- = ( c << 4 ) | c2; // sic
279  }
280 
281  return( 0 );
282 }
283 
284 
285 #include <stdio.h>
286 #include <string.h>
287 
288 static int test_errors = 0;
289 
290 #ifdef POLARSSL_DHM_C
291 #ifdef POLARSSL_BIGNUM_C
292 
293 #define TEST_SUITE_ACTIVE
294 
295 static int test_assert( int correct, char *test )
296 {
297  if( correct )
298  return( 0 );
299 
300  test_errors++;
301  if( test_errors == 1 )
302  printf( "FAILED\n" );
303  printf( " %s\n", test );
304 
305  return( 1 );
306 }
307 
308 #define TEST_ASSERT( TEST ) \
309  do { test_assert( (TEST) ? 1 : 0, #TEST ); \
310  if( test_errors) return; \
311  } while (0)
312 
313 int verify_string( char **str )
314 {
315  if( (*str)[0] != '"' ||
316  (*str)[strlen( *str ) - 1] != '"' )
317  {
318  printf( "Expected string (with \"\") for parameter and got: %s\n", *str );
319  return( -1 );
320  }
321 
322  (*str)++;
323  (*str)[strlen( *str ) - 1] = '\0';
324 
325  return( 0 );
326 }
327 
328 int verify_int( char *str, int *value )
329 {
330  size_t i;
331  int minus = 0;
332  int digits = 1;
333  int hex = 0;
334 
335  for( i = 0; i < strlen( str ); i++ )
336  {
337  if( i == 0 && str[i] == '-' )
338  {
339  minus = 1;
340  continue;
341  }
342 
343  if( ( ( minus && i == 2 ) || ( !minus && i == 1 ) ) &&
344  str[i - 1] == '0' && str[i] == 'x' )
345  {
346  hex = 1;
347  continue;
348  }
349 
350  if( str[i] < '0' || str[i] > '9' )
351  {
352  digits = 0;
353  break;
354  }
355  }
356 
357  if( digits )
358  {
359  if( hex )
360  *value = strtol( str, NULL, 16 );
361  else
362  *value = strtol( str, NULL, 10 );
363 
364  return( 0 );
365  }
366 
367 
368 
369  printf( "Expected integer for parameter and got: %s\n", str );
370  return( -1 );
371 }
372 
373 void test_suite_dhm_do_dhm( int radix_P, char *input_P,
374  int radix_G, char *input_G )
375 {
376  dhm_context ctx_srv;
377  dhm_context ctx_cli;
378  unsigned char ske[1000];
379  unsigned char *p = ske;
380  unsigned char pub_cli[1000];
381  unsigned char sec_srv[1000];
382  unsigned char sec_cli[1000];
383  size_t ske_len = 0;
384  size_t pub_cli_len = 0;
385  size_t sec_srv_len = 1000;
386  size_t sec_cli_len = 1000;
387  int x_size, i;
388  rnd_pseudo_info rnd_info;
389 
390  memset( &ctx_srv, 0x00, sizeof( dhm_context ) );
391  memset( &ctx_cli, 0x00, sizeof( dhm_context ) );
392  memset( ske, 0x00, 1000 );
393  memset( pub_cli, 0x00, 1000 );
394  memset( sec_srv, 0x00, 1000 );
395  memset( sec_cli, 0x00, 1000 );
396  memset( &rnd_info, 0x00, sizeof( rnd_pseudo_info ) );
397 
398  /*
399  * Set params
400  */
401  TEST_ASSERT( mpi_read_string( &ctx_srv.P, radix_P, input_P ) == 0 );
402  TEST_ASSERT( mpi_read_string( &ctx_srv.G, radix_G, input_G ) == 0 );
403  x_size = mpi_size( &ctx_srv.P );
404  pub_cli_len = x_size;
405 
406  /*
407  * First key exchange
408  */
409  TEST_ASSERT( dhm_make_params( &ctx_srv, x_size, ske, &ske_len, &rnd_pseudo_rand, &rnd_info ) == 0 );
410  ske[ske_len++] = 0;
411  ske[ske_len++] = 0;
412  TEST_ASSERT( dhm_read_params( &ctx_cli, &p, ske + ske_len ) == 0 );
413 
414  TEST_ASSERT( dhm_make_public( &ctx_cli, x_size, pub_cli, pub_cli_len, &rnd_pseudo_rand, &rnd_info ) == 0 );
415  TEST_ASSERT( dhm_read_public( &ctx_srv, pub_cli, pub_cli_len ) == 0 );
416 
417  TEST_ASSERT( dhm_calc_secret( &ctx_srv, sec_srv, &sec_srv_len, &rnd_pseudo_rand, &rnd_info ) == 0 );
418  TEST_ASSERT( dhm_calc_secret( &ctx_cli, sec_cli, &sec_cli_len, NULL, NULL ) == 0 );
419 
420  TEST_ASSERT( sec_srv_len == sec_cli_len );
421  TEST_ASSERT( sec_srv_len != 0 );
422  TEST_ASSERT( memcmp( sec_srv, sec_cli, sec_srv_len ) == 0 );
423 
424  /* Re-do calc_secret on server a few times to test update of blinding values */
425  for( i = 0; i < 3; i++ )
426  {
427  sec_srv_len = 1000;
428  TEST_ASSERT( dhm_calc_secret( &ctx_srv, sec_srv, &sec_srv_len, &rnd_pseudo_rand, &rnd_info ) == 0 );
429 
430  TEST_ASSERT( sec_srv_len == sec_cli_len );
431  TEST_ASSERT( sec_srv_len != 0 );
432  TEST_ASSERT( memcmp( sec_srv, sec_cli, sec_srv_len ) == 0 );
433  }
434 
435  /*
436  * Second key exchange to test change of blinding values on server
437  */
438  sec_cli_len = 1000;
439  sec_srv_len = 1000;
440  p = ske;
441 
442  TEST_ASSERT( dhm_make_params( &ctx_srv, x_size, ske, &ske_len, &rnd_pseudo_rand, &rnd_info ) == 0 );
443  ske[ske_len++] = 0;
444  ske[ske_len++] = 0;
445  TEST_ASSERT( dhm_read_params( &ctx_cli, &p, ske + ske_len ) == 0 );
446 
447  TEST_ASSERT( dhm_make_public( &ctx_cli, x_size, pub_cli, pub_cli_len, &rnd_pseudo_rand, &rnd_info ) == 0 );
448  TEST_ASSERT( dhm_read_public( &ctx_srv, pub_cli, pub_cli_len ) == 0 );
449 
450  TEST_ASSERT( dhm_calc_secret( &ctx_srv, sec_srv, &sec_srv_len, &rnd_pseudo_rand, &rnd_info ) == 0 );
451  TEST_ASSERT( dhm_calc_secret( &ctx_cli, sec_cli, &sec_cli_len, NULL, NULL ) == 0 );
452 
453  TEST_ASSERT( sec_srv_len == sec_cli_len );
454  TEST_ASSERT( sec_srv_len != 0 );
455  TEST_ASSERT( memcmp( sec_srv, sec_cli, sec_srv_len ) == 0 );
456 
457  dhm_free( &ctx_srv );
458  dhm_free( &ctx_cli );
459 }
460 
461 #ifdef POLARSSL_SELF_TEST
462 void test_suite_dhm_selftest()
463 {
464  TEST_ASSERT( dhm_self_test( 0 ) == 0 );
465 }
466 #endif /* POLARSSL_SELF_TEST */
467 
468 
469 #endif /* POLARSSL_DHM_C */
470 #endif /* POLARSSL_BIGNUM_C */
471 
472 
473 int dep_check( char *str )
474 {
475  if( str == NULL )
476  return( 1 );
477 
478 
479 
480  return( 1 );
481 }
482 
483 int dispatch_test(int cnt, char *params[50])
484 {
485  int ret;
486  ((void) cnt);
487  ((void) params);
488 
489 #if defined(TEST_SUITE_ACTIVE)
490  if( strcmp( params[0], "dhm_do_dhm" ) == 0 )
491  {
492 
493  int param1;
494  char *param2 = params[2];
495  int param3;
496  char *param4 = params[4];
497 
498  if( cnt != 5 )
499  {
500  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 5 );
501  return( 2 );
502  }
503 
504  if( verify_int( params[1], &param1 ) != 0 ) return( 2 );
505  if( verify_string( &param2 ) != 0 ) return( 2 );
506  if( verify_int( params[3], &param3 ) != 0 ) return( 2 );
507  if( verify_string( &param4 ) != 0 ) return( 2 );
508 
509  test_suite_dhm_do_dhm( param1, param2, param3, param4 );
510  return ( 0 );
511 
512  return ( 3 );
513  }
514  else
515  if( strcmp( params[0], "dhm_selftest" ) == 0 )
516  {
517  #ifdef POLARSSL_SELF_TEST
518 
519 
520  if( cnt != 1 )
521  {
522  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 1 );
523  return( 2 );
524  }
525 
526 
527  test_suite_dhm_selftest( );
528  return ( 0 );
529  #endif /* POLARSSL_SELF_TEST */
530 
531  return ( 3 );
532  }
533  else
534 
535  {
536  fprintf( stdout, "FAILED\nSkipping unknown test function '%s'\n", params[0] );
537  fflush( stdout );
538  return( 1 );
539  }
540 #else
541  return( 3 );
542 #endif
543  return( ret );
544 }
545 
546 int get_line( FILE *f, char *buf, size_t len )
547 {
548  char *ret;
549 
550  ret = fgets( buf, len, f );
551  if( ret == NULL )
552  return( -1 );
553 
554  if( strlen( buf ) && buf[strlen(buf) - 1] == '\n' )
555  buf[strlen(buf) - 1] = '\0';
556  if( strlen( buf ) && buf[strlen(buf) - 1] == '\r' )
557  buf[strlen(buf) - 1] = '\0';
558 
559  return( 0 );
560 }
561 
562 int parse_arguments( char *buf, size_t len, char *params[50] )
563 {
564  int cnt = 0, i;
565  char *cur = buf;
566  char *p = buf, *q;
567 
568  params[cnt++] = cur;
569 
570  while( *p != '\0' && p < buf + len )
571  {
572  if( *p == '\\' )
573  {
574  *p++;
575  *p++;
576  continue;
577  }
578  if( *p == ':' )
579  {
580  if( p + 1 < buf + len )
581  {
582  cur = p + 1;
583  params[cnt++] = cur;
584  }
585  *p = '\0';
586  }
587 
588  *p++;
589  }
590 
591  // Replace newlines, question marks and colons in strings
592  for( i = 0; i < cnt; i++ )
593  {
594  p = params[i];
595  q = params[i];
596 
597  while( *p != '\0' )
598  {
599  if( *p == '\\' && *(p + 1) == 'n' )
600  {
601  p += 2;
602  *(q++) = '\n';
603  }
604  else if( *p == '\\' && *(p + 1) == ':' )
605  {
606  p += 2;
607  *(q++) = ':';
608  }
609  else if( *p == '\\' && *(p + 1) == '?' )
610  {
611  p += 2;
612  *(q++) = '?';
613  }
614  else
615  *(q++) = *(p++);
616  }
617  *q = '\0';
618  }
619 
620  return( cnt );
621 }
622 
623 int main()
624 {
625  int ret, i, cnt, total_errors = 0, total_tests = 0, total_skipped = 0;
626  const char *filename = "/home/iurt/rpmbuild/BUILD/polarssl-1.3.1/tests/suites/test_suite_dhm.data";
627  FILE *file;
628  char buf[5000];
629  char *params[50];
630 
631 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
632  unsigned char alloc_buf[1000000];
633  memory_buffer_alloc_init( alloc_buf, sizeof(alloc_buf) );
634 #endif
635 
636  file = fopen( filename, "r" );
637  if( file == NULL )
638  {
639  fprintf( stderr, "Failed to open\n" );
640  return( 1 );
641  }
642 
643  while( !feof( file ) )
644  {
645  int skip = 0;
646 
647  if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
648  break;
649  fprintf( stdout, "%s%.66s", test_errors ? "\n" : "", buf );
650  fprintf( stdout, " " );
651  for( i = strlen( buf ) + 1; i < 67; i++ )
652  fprintf( stdout, "." );
653  fprintf( stdout, " " );
654  fflush( stdout );
655 
656  total_tests++;
657 
658  if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
659  break;
660  cnt = parse_arguments( buf, strlen(buf), params );
661 
662  if( strcmp( params[0], "depends_on" ) == 0 )
663  {
664  for( i = 1; i < cnt; i++ )
665  if( dep_check( params[i] ) != 0 )
666  skip = 1;
667 
668  if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
669  break;
670  cnt = parse_arguments( buf, strlen(buf), params );
671  }
672 
673  if( skip == 0 )
674  {
675  test_errors = 0;
676  ret = dispatch_test( cnt, params );
677  }
678 
679  if( skip == 1 || ret == 3 )
680  {
681  total_skipped++;
682  fprintf( stdout, "----\n" );
683  fflush( stdout );
684  }
685  else if( ret == 0 && test_errors == 0 )
686  {
687  fprintf( stdout, "PASS\n" );
688  fflush( stdout );
689  }
690  else if( ret == 2 )
691  {
692  fprintf( stderr, "FAILED: FATAL PARSE ERROR\n" );
693  fclose(file);
694  exit( 2 );
695  }
696  else
697  total_errors++;
698 
699  if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
700  break;
701  if( strlen(buf) != 0 )
702  {
703  fprintf( stderr, "Should be empty %d\n", (int) strlen(buf) );
704  return( 1 );
705  }
706  }
707  fclose(file);
708 
709  fprintf( stdout, "\n----------------------------------------------------------------------------\n\n");
710  if( total_errors == 0 )
711  fprintf( stdout, "PASSED" );
712  else
713  fprintf( stdout, "FAILED" );
714 
715  fprintf( stdout, " (%d / %d tests (%d skipped))\n",
716  total_tests - total_errors, total_tests, total_skipped );
717 
718 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
719 #if defined(POLARSSL_MEMORY_DEBUG)
720  memory_buffer_alloc_status();
721 #endif
722  memory_buffer_alloc_free();
723 #endif
724 
725  return( total_errors != 0 );
726 }
727 
728