PolarSSL v1.3.1
test_suite_md.c
Go to the documentation of this file.
1 #include <polarssl/config.h>
2 
3 #ifdef POLARSSL_MD_C
4 
5 #include <polarssl/md.h>
6 #include <polarssl/md2.h>
7 #include <polarssl/md4.h>
8 #include <polarssl/md5.h>
9 #include <polarssl/sha1.h>
10 #include <polarssl/sha256.h>
11 #include <polarssl/sha512.h>
12 #endif /* POLARSSL_MD_C */
13 
14 
15 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
16 #include "polarssl/memory.h"
17 #endif
18 
19 #ifdef _MSC_VER
20 #include <basetsd.h>
21 typedef UINT32 uint32_t;
22 #else
23 #include <inttypes.h>
24 #endif
25 
26 #include <assert.h>
27 #include <stdlib.h>
28 #include <string.h>
29 
30 /*
31  * 32-bit integer manipulation macros (big endian)
32  */
33 #ifndef GET_UINT32_BE
34 #define GET_UINT32_BE(n,b,i) \
35 { \
36  (n) = ( (uint32_t) (b)[(i) ] << 24 ) \
37  | ( (uint32_t) (b)[(i) + 1] << 16 ) \
38  | ( (uint32_t) (b)[(i) + 2] << 8 ) \
39  | ( (uint32_t) (b)[(i) + 3] ); \
40 }
41 #endif
42 
43 #ifndef PUT_UINT32_BE
44 #define PUT_UINT32_BE(n,b,i) \
45 { \
46  (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
47  (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
48  (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
49  (b)[(i) + 3] = (unsigned char) ( (n) ); \
50 }
51 #endif
52 
53 static int unhexify(unsigned char *obuf, const char *ibuf)
54 {
55  unsigned char c, c2;
56  int len = strlen(ibuf) / 2;
57  assert(!(strlen(ibuf) %1)); // must be even number of bytes
58 
59  while (*ibuf != 0)
60  {
61  c = *ibuf++;
62  if( c >= '0' && c <= '9' )
63  c -= '0';
64  else if( c >= 'a' && c <= 'f' )
65  c -= 'a' - 10;
66  else if( c >= 'A' && c <= 'F' )
67  c -= 'A' - 10;
68  else
69  assert( 0 );
70 
71  c2 = *ibuf++;
72  if( c2 >= '0' && c2 <= '9' )
73  c2 -= '0';
74  else if( c2 >= 'a' && c2 <= 'f' )
75  c2 -= 'a' - 10;
76  else if( c2 >= 'A' && c2 <= 'F' )
77  c2 -= 'A' - 10;
78  else
79  assert( 0 );
80 
81  *obuf++ = ( c << 4 ) | c2;
82  }
83 
84  return len;
85 }
86 
87 static void hexify(unsigned char *obuf, const unsigned char *ibuf, int len)
88 {
89  unsigned char l, h;
90 
91  while (len != 0)
92  {
93  h = (*ibuf) / 16;
94  l = (*ibuf) % 16;
95 
96  if( h < 10 )
97  *obuf++ = '0' + h;
98  else
99  *obuf++ = 'a' + h - 10;
100 
101  if( l < 10 )
102  *obuf++ = '0' + l;
103  else
104  *obuf++ = 'a' + l - 10;
105 
106  ++ibuf;
107  len--;
108  }
109 }
110 
120 static int rnd_std_rand( void *rng_state, unsigned char *output, size_t len )
121 {
122  size_t i;
123 
124  if( rng_state != NULL )
125  rng_state = NULL;
126 
127  for( i = 0; i < len; ++i )
128  output[i] = rand();
129 
130  return( 0 );
131 }
132 
138 static int rnd_zero_rand( void *rng_state, unsigned char *output, size_t len )
139 {
140  if( rng_state != NULL )
141  rng_state = NULL;
142 
143  memset( output, 0, len );
144 
145  return( 0 );
146 }
147 
148 typedef struct
149 {
150  unsigned char *buf;
151  size_t length;
152 } rnd_buf_info;
153 
165 static int rnd_buffer_rand( void *rng_state, unsigned char *output, size_t len )
166 {
167  rnd_buf_info *info = (rnd_buf_info *) rng_state;
168  size_t use_len;
169 
170  if( rng_state == NULL )
171  return( rnd_std_rand( NULL, output, len ) );
172 
173  use_len = len;
174  if( len > info->length )
175  use_len = info->length;
176 
177  if( use_len )
178  {
179  memcpy( output, info->buf, use_len );
180  info->buf += use_len;
181  info->length -= use_len;
182  }
183 
184  if( len - use_len > 0 )
185  return( rnd_std_rand( NULL, output + use_len, len - use_len ) );
186 
187  return( 0 );
188 }
189 
197 typedef struct
198 {
199  uint32_t key[16];
200  uint32_t v0, v1;
202 
211 static int rnd_pseudo_rand( void *rng_state, unsigned char *output, size_t len )
212 {
213  rnd_pseudo_info *info = (rnd_pseudo_info *) rng_state;
214  uint32_t i, *k, sum, delta=0x9E3779B9;
215  unsigned char result[4];
216 
217  if( rng_state == NULL )
218  return( rnd_std_rand( NULL, output, len ) );
219 
220  k = info->key;
221 
222  while( len > 0 )
223  {
224  size_t use_len = ( len > 4 ) ? 4 : len;
225  sum = 0;
226 
227  for( i = 0; i < 32; i++ )
228  {
229  info->v0 += (((info->v1 << 4) ^ (info->v1 >> 5)) + info->v1) ^ (sum + k[sum & 3]);
230  sum += delta;
231  info->v1 += (((info->v0 << 4) ^ (info->v0 >> 5)) + info->v0) ^ (sum + k[(sum>>11) & 3]);
232  }
233 
234  PUT_UINT32_BE( info->v0, result, 0 );
235  memcpy( output, result, use_len );
236  len -= use_len;
237  }
238 
239  return( 0 );
240 }
241 
251 static int not_rnd( void *in, unsigned char *out, size_t len )
252 {
253  unsigned char *obuf;
254  const char *ibuf = in;
255  unsigned char c, c2;
256  assert( len == strlen(ibuf) / 2 );
257  assert(!(strlen(ibuf) %1)); // must be even number of bytes
258 
259  obuf = out + (len - 1); // sic
260  while (*ibuf != 0)
261  {
262  c = *ibuf++;
263  if( c >= '0' && c <= '9' )
264  c -= '0';
265  else if( c >= 'a' && c <= 'f' )
266  c -= 'a' - 10;
267  else if( c >= 'A' && c <= 'F' )
268  c -= 'A' - 10;
269  else
270  assert( 0 );
271 
272  c2 = *ibuf++;
273  if( c2 >= '0' && c2 <= '9' )
274  c2 -= '0';
275  else if( c2 >= 'a' && c2 <= 'f' )
276  c2 -= 'a' - 10;
277  else if( c2 >= 'A' && c2 <= 'F' )
278  c2 -= 'A' - 10;
279  else
280  assert( 0 );
281 
282  *obuf-- = ( c << 4 ) | c2; // sic
283  }
284 
285  return( 0 );
286 }
287 
288 
289 #include <stdio.h>
290 #include <string.h>
291 
292 static int test_errors = 0;
293 
294 #ifdef POLARSSL_MD_C
295 
296 #define TEST_SUITE_ACTIVE
297 
298 static int test_assert( int correct, char *test )
299 {
300  if( correct )
301  return( 0 );
302 
303  test_errors++;
304  if( test_errors == 1 )
305  printf( "FAILED\n" );
306  printf( " %s\n", test );
307 
308  return( 1 );
309 }
310 
311 #define TEST_ASSERT( TEST ) \
312  do { test_assert( (TEST) ? 1 : 0, #TEST ); \
313  if( test_errors) return; \
314  } while (0)
315 
316 int verify_string( char **str )
317 {
318  if( (*str)[0] != '"' ||
319  (*str)[strlen( *str ) - 1] != '"' )
320  {
321  printf( "Expected string (with \"\") for parameter and got: %s\n", *str );
322  return( -1 );
323  }
324 
325  (*str)++;
326  (*str)[strlen( *str ) - 1] = '\0';
327 
328  return( 0 );
329 }
330 
331 int verify_int( char *str, int *value )
332 {
333  size_t i;
334  int minus = 0;
335  int digits = 1;
336  int hex = 0;
337 
338  for( i = 0; i < strlen( str ); i++ )
339  {
340  if( i == 0 && str[i] == '-' )
341  {
342  minus = 1;
343  continue;
344  }
345 
346  if( ( ( minus && i == 2 ) || ( !minus && i == 1 ) ) &&
347  str[i - 1] == '0' && str[i] == 'x' )
348  {
349  hex = 1;
350  continue;
351  }
352 
353  if( str[i] < '0' || str[i] > '9' )
354  {
355  digits = 0;
356  break;
357  }
358  }
359 
360  if( digits )
361  {
362  if( hex )
363  *value = strtol( str, NULL, 16 );
364  else
365  *value = strtol( str, NULL, 10 );
366 
367  return( 0 );
368  }
369 
370 
371 
372  printf( "Expected integer for parameter and got: %s\n", str );
373  return( -1 );
374 }
375 
376 void test_suite_md_text( char *text_md_name, char *text_src_string, char *hex_hash_string )
377 {
378  char md_name[100];
379  unsigned char src_str[1000];
380  unsigned char hash_str[1000];
381  unsigned char output[100];
382  const md_info_t *md_info = NULL;
383 
384  memset(md_name, 0x00, 100);
385  memset(src_str, 0x00, 1000);
386  memset(hash_str, 0x00, 1000);
387  memset(output, 0x00, 100);
388 
389  strcpy( (char *) src_str, text_src_string );
390 
391  strncpy( (char *) md_name, text_md_name, 100 );
392  md_info = md_info_from_string(md_name);
393  TEST_ASSERT( md_info != NULL );
394 
395  TEST_ASSERT ( 0 == md( md_info, src_str, strlen( (char *) src_str ), output ) );
396  hexify( hash_str, output, md_get_size(md_info) );
397 
398  TEST_ASSERT( strcmp( (char *) hash_str, hex_hash_string ) == 0 );
399 }
400 
401 void test_suite_md_hex( char *text_md_name, char *hex_src_string, char *hex_hash_string )
402 {
403  char md_name[100];
404  unsigned char src_str[10000];
405  unsigned char hash_str[10000];
406  unsigned char output[100];
407  int src_len;
408  const md_info_t *md_info = NULL;
409 
410  memset(md_name, 0x00, 100);
411  memset(src_str, 0x00, 10000);
412  memset(hash_str, 0x00, 10000);
413  memset(output, 0x00, 100);
414 
415  strncpy( (char *) md_name, text_md_name, 100 );
416  md_info = md_info_from_string(md_name);
417  TEST_ASSERT( md_info != NULL );
418 
419  src_len = unhexify( src_str, hex_src_string );
420  TEST_ASSERT ( 0 == md( md_info, src_str, src_len, output ) );
421 
422  hexify( hash_str, output, md_get_size(md_info) );
423 
424  TEST_ASSERT( strcmp( (char *) hash_str, hex_hash_string ) == 0 );
425 }
426 
427 void test_suite_md_text_multi( char *text_md_name, char *text_src_string,
428  char *hex_hash_string )
429 {
430  char md_name[100];
431  unsigned char src_str[1000];
432  unsigned char hash_str[1000];
433  unsigned char output[100];
434 
435  const md_info_t *md_info = NULL;
437 
438  memset(md_name, 0x00, 100);
439  memset(src_str, 0x00, 1000);
440  memset(hash_str, 0x00, 1000);
441  memset(output, 0x00, 100);
442 
443  strcpy( (char *) src_str, text_src_string );
444 
445  strncpy( (char *) md_name, text_md_name, 100 );
446  md_info = md_info_from_string(md_name);
447  TEST_ASSERT( md_info != NULL );
448  TEST_ASSERT ( 0 == md_init_ctx( &ctx, md_info ) );
449 
450  TEST_ASSERT ( 0 == md_starts( &ctx ) );
451  TEST_ASSERT ( ctx.md_ctx != NULL );
452  TEST_ASSERT ( 0 == md_update( &ctx, src_str, strlen( (char *) src_str ) ) );
453  TEST_ASSERT ( 0 == md_finish( &ctx, output ) );
454  TEST_ASSERT ( 0 == md_free_ctx( &ctx ) );
455 
456  hexify( hash_str, output, md_get_size(md_info) );
457 
458  TEST_ASSERT( strcmp( (char *) hash_str, hex_hash_string ) == 0 );
459 }
460 
461 void test_suite_md_hex_multi( char *text_md_name, char *hex_src_string,
462  char *hex_hash_string )
463 {
464  char md_name[100];
465  unsigned char src_str[10000];
466  unsigned char hash_str[10000];
467  unsigned char output[100];
468  int src_len;
469  const md_info_t *md_info = NULL;
471 
472  memset(md_name, 0x00, 100);
473  memset(src_str, 0x00, 10000);
474  memset(hash_str, 0x00, 10000);
475  memset(output, 0x00, 100);
476 
477  strncpy( (char *) md_name, text_md_name, 100 );
478  md_info = md_info_from_string(md_name);
479  TEST_ASSERT( md_info != NULL );
480  TEST_ASSERT ( 0 == md_init_ctx( &ctx, md_info ) );
481 
482  src_len = unhexify( src_str, hex_src_string );
483 
484  TEST_ASSERT ( 0 == md_starts( &ctx ) );
485  TEST_ASSERT ( ctx.md_ctx != NULL );
486  TEST_ASSERT ( 0 == md_update( &ctx, src_str, src_len ) );
487  TEST_ASSERT ( 0 == md_finish( &ctx, output ) );
488  TEST_ASSERT ( 0 == md_free_ctx( &ctx ) );
489 
490  hexify( hash_str, output, md_get_size(md_info) );
491 
492  TEST_ASSERT( strcmp( (char *) hash_str, hex_hash_string ) == 0 );
493 }
494 
495 void test_suite_md_hmac( char *text_md_name, int trunc_size, char *hex_key_string,
496  char *hex_src_string, char *hex_hash_string )
497 {
498  char md_name[100];
499  unsigned char src_str[10000];
500  unsigned char key_str[10000];
501  unsigned char hash_str[10000];
502  unsigned char output[100];
503  int key_len, src_len;
504  const md_info_t *md_info = NULL;
505 
506  memset(md_name, 0x00, 100);
507  memset(src_str, 0x00, 10000);
508  memset(key_str, 0x00, 10000);
509  memset(hash_str, 0x00, 10000);
510  memset(output, 0x00, 100);
511 
512  strncpy( (char *) md_name, text_md_name, 100 );
513  md_info = md_info_from_string( md_name );
514  TEST_ASSERT( md_info != NULL );
515 
516  key_len = unhexify( key_str, hex_key_string );
517  src_len = unhexify( src_str, hex_src_string );
518 
519  TEST_ASSERT ( md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
520  hexify( hash_str, output, md_get_size(md_info) );
521 
522  TEST_ASSERT( strncmp( (char *) hash_str, hex_hash_string, trunc_size * 2 ) == 0 );
523 }
524 
525 void test_suite_md_hmac_multi( char *text_md_name, int trunc_size, char *hex_key_string,
526  char *hex_src_string, char *hex_hash_string )
527 {
528  char md_name[100];
529  unsigned char src_str[10000];
530  unsigned char key_str[10000];
531  unsigned char hash_str[10000];
532  unsigned char output[100];
533  int key_len, src_len;
534  const md_info_t *md_info = NULL;
536 
537  memset(md_name, 0x00, 100);
538  memset(src_str, 0x00, 10000);
539  memset(key_str, 0x00, 10000);
540  memset(hash_str, 0x00, 10000);
541  memset(output, 0x00, 100);
542 
543  strncpy( (char *) md_name, text_md_name, 100 );
544  md_info = md_info_from_string( md_name );
545  TEST_ASSERT( md_info != NULL );
546  TEST_ASSERT ( 0 == md_init_ctx( &ctx, md_info ) );
547 
548  key_len = unhexify( key_str, hex_key_string );
549  src_len = unhexify( src_str, hex_src_string );
550 
551  TEST_ASSERT ( 0 == md_hmac_starts( &ctx, key_str, key_len ) );
552  TEST_ASSERT ( ctx.md_ctx != NULL );
553  TEST_ASSERT ( 0 == md_hmac_update( &ctx, src_str, src_len ) );
554  TEST_ASSERT ( 0 == md_hmac_finish( &ctx, output ) );
555  TEST_ASSERT ( 0 == md_free_ctx( &ctx ) );
556 
557  hexify( hash_str, output, md_get_size(md_info) );
558 
559  TEST_ASSERT( strncmp( (char *) hash_str, hex_hash_string, trunc_size * 2 ) == 0 );
560 }
561 
562 #ifdef POLARSSL_FS_IO
563 void test_suite_md_file( char *text_md_name, char *filename, char *hex_hash_string )
564 {
565  char md_name[100];
566  unsigned char hash_str[1000];
567  unsigned char output[100];
568  const md_info_t *md_info = NULL;
569 
570  memset(md_name, 0x00, 100);
571  memset(hash_str, 0x00, 1000);
572  memset(output, 0x00, 100);
573 
574  strncpy( (char *) md_name, text_md_name, 100 );
575  md_info = md_info_from_string( md_name );
576  TEST_ASSERT( md_info != NULL );
577 
578  md_file( md_info, filename, output);
579  hexify( hash_str, output, md_get_size(md_info) );
580 
581  TEST_ASSERT( strcmp( (char *) hash_str, hex_hash_string ) == 0 );
582 }
583 #endif /* POLARSSL_FS_IO */
584 
585 
586 #endif /* POLARSSL_MD_C */
587 
588 
589 int dep_check( char *str )
590 {
591  if( str == NULL )
592  return( 1 );
593 
594  if( strcmp( str, "POLARSSL_MD5_C" ) == 0 )
595  {
596 #if defined(POLARSSL_MD5_C)
597  return( 0 );
598 #else
599  return( 1 );
600 #endif
601  }
602  if( strcmp( str, "POLARSSL_SHA256_C" ) == 0 )
603  {
604 #if defined(POLARSSL_SHA256_C)
605  return( 0 );
606 #else
607  return( 1 );
608 #endif
609  }
610  if( strcmp( str, "POLARSSL_SHA1_C" ) == 0 )
611  {
612 #if defined(POLARSSL_SHA1_C)
613  return( 0 );
614 #else
615  return( 1 );
616 #endif
617  }
618  if( strcmp( str, "POLARSSL_MD4_C" ) == 0 )
619  {
620 #if defined(POLARSSL_MD4_C)
621  return( 0 );
622 #else
623  return( 1 );
624 #endif
625  }
626  if( strcmp( str, "POLARSSL_MD_C" ) == 0 )
627  {
628 #if defined(POLARSSL_MD_C)
629  return( 0 );
630 #else
631  return( 1 );
632 #endif
633  }
634  if( strcmp( str, "POLARSSL_MD2_C" ) == 0 )
635  {
636 #if defined(POLARSSL_MD2_C)
637  return( 0 );
638 #else
639  return( 1 );
640 #endif
641  }
642  if( strcmp( str, "POLARSSL_SHA512_C" ) == 0 )
643  {
644 #if defined(POLARSSL_SHA512_C)
645  return( 0 );
646 #else
647  return( 1 );
648 #endif
649  }
650 
651 
652  return( 1 );
653 }
654 
655 int dispatch_test(int cnt, char *params[50])
656 {
657  int ret;
658  ((void) cnt);
659  ((void) params);
660 
661 #if defined(TEST_SUITE_ACTIVE)
662  if( strcmp( params[0], "md_text" ) == 0 )
663  {
664 
665  char *param1 = params[1];
666  char *param2 = params[2];
667  char *param3 = params[3];
668 
669  if( cnt != 4 )
670  {
671  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
672  return( 2 );
673  }
674 
675  if( verify_string( &param1 ) != 0 ) return( 2 );
676  if( verify_string( &param2 ) != 0 ) return( 2 );
677  if( verify_string( &param3 ) != 0 ) return( 2 );
678 
679  test_suite_md_text( param1, param2, param3 );
680  return ( 0 );
681 
682  return ( 3 );
683  }
684  else
685  if( strcmp( params[0], "md_hex" ) == 0 )
686  {
687 
688  char *param1 = params[1];
689  char *param2 = params[2];
690  char *param3 = params[3];
691 
692  if( cnt != 4 )
693  {
694  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
695  return( 2 );
696  }
697 
698  if( verify_string( &param1 ) != 0 ) return( 2 );
699  if( verify_string( &param2 ) != 0 ) return( 2 );
700  if( verify_string( &param3 ) != 0 ) return( 2 );
701 
702  test_suite_md_hex( param1, param2, param3 );
703  return ( 0 );
704 
705  return ( 3 );
706  }
707  else
708  if( strcmp( params[0], "md_text_multi" ) == 0 )
709  {
710 
711  char *param1 = params[1];
712  char *param2 = params[2];
713  char *param3 = params[3];
714 
715  if( cnt != 4 )
716  {
717  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
718  return( 2 );
719  }
720 
721  if( verify_string( &param1 ) != 0 ) return( 2 );
722  if( verify_string( &param2 ) != 0 ) return( 2 );
723  if( verify_string( &param3 ) != 0 ) return( 2 );
724 
725  test_suite_md_text_multi( param1, param2, param3 );
726  return ( 0 );
727 
728  return ( 3 );
729  }
730  else
731  if( strcmp( params[0], "md_hex_multi" ) == 0 )
732  {
733 
734  char *param1 = params[1];
735  char *param2 = params[2];
736  char *param3 = params[3];
737 
738  if( cnt != 4 )
739  {
740  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
741  return( 2 );
742  }
743 
744  if( verify_string( &param1 ) != 0 ) return( 2 );
745  if( verify_string( &param2 ) != 0 ) return( 2 );
746  if( verify_string( &param3 ) != 0 ) return( 2 );
747 
748  test_suite_md_hex_multi( param1, param2, param3 );
749  return ( 0 );
750 
751  return ( 3 );
752  }
753  else
754  if( strcmp( params[0], "md_hmac" ) == 0 )
755  {
756 
757  char *param1 = params[1];
758  int param2;
759  char *param3 = params[3];
760  char *param4 = params[4];
761  char *param5 = params[5];
762 
763  if( cnt != 6 )
764  {
765  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 6 );
766  return( 2 );
767  }
768 
769  if( verify_string( &param1 ) != 0 ) return( 2 );
770  if( verify_int( params[2], &param2 ) != 0 ) return( 2 );
771  if( verify_string( &param3 ) != 0 ) return( 2 );
772  if( verify_string( &param4 ) != 0 ) return( 2 );
773  if( verify_string( &param5 ) != 0 ) return( 2 );
774 
775  test_suite_md_hmac( param1, param2, param3, param4, param5 );
776  return ( 0 );
777 
778  return ( 3 );
779  }
780  else
781  if( strcmp( params[0], "md_hmac_multi" ) == 0 )
782  {
783 
784  char *param1 = params[1];
785  int param2;
786  char *param3 = params[3];
787  char *param4 = params[4];
788  char *param5 = params[5];
789 
790  if( cnt != 6 )
791  {
792  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 6 );
793  return( 2 );
794  }
795 
796  if( verify_string( &param1 ) != 0 ) return( 2 );
797  if( verify_int( params[2], &param2 ) != 0 ) return( 2 );
798  if( verify_string( &param3 ) != 0 ) return( 2 );
799  if( verify_string( &param4 ) != 0 ) return( 2 );
800  if( verify_string( &param5 ) != 0 ) return( 2 );
801 
802  test_suite_md_hmac_multi( param1, param2, param3, param4, param5 );
803  return ( 0 );
804 
805  return ( 3 );
806  }
807  else
808  if( strcmp( params[0], "md_file" ) == 0 )
809  {
810  #ifdef POLARSSL_FS_IO
811 
812  char *param1 = params[1];
813  char *param2 = params[2];
814  char *param3 = params[3];
815 
816  if( cnt != 4 )
817  {
818  fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
819  return( 2 );
820  }
821 
822  if( verify_string( &param1 ) != 0 ) return( 2 );
823  if( verify_string( &param2 ) != 0 ) return( 2 );
824  if( verify_string( &param3 ) != 0 ) return( 2 );
825 
826  test_suite_md_file( param1, param2, param3 );
827  return ( 0 );
828  #endif /* POLARSSL_FS_IO */
829 
830  return ( 3 );
831  }
832  else
833 
834  {
835  fprintf( stdout, "FAILED\nSkipping unknown test function '%s'\n", params[0] );
836  fflush( stdout );
837  return( 1 );
838  }
839 #else
840  return( 3 );
841 #endif
842  return( ret );
843 }
844 
845 int get_line( FILE *f, char *buf, size_t len )
846 {
847  char *ret;
848 
849  ret = fgets( buf, len, f );
850  if( ret == NULL )
851  return( -1 );
852 
853  if( strlen( buf ) && buf[strlen(buf) - 1] == '\n' )
854  buf[strlen(buf) - 1] = '\0';
855  if( strlen( buf ) && buf[strlen(buf) - 1] == '\r' )
856  buf[strlen(buf) - 1] = '\0';
857 
858  return( 0 );
859 }
860 
861 int parse_arguments( char *buf, size_t len, char *params[50] )
862 {
863  int cnt = 0, i;
864  char *cur = buf;
865  char *p = buf, *q;
866 
867  params[cnt++] = cur;
868 
869  while( *p != '\0' && p < buf + len )
870  {
871  if( *p == '\\' )
872  {
873  *p++;
874  *p++;
875  continue;
876  }
877  if( *p == ':' )
878  {
879  if( p + 1 < buf + len )
880  {
881  cur = p + 1;
882  params[cnt++] = cur;
883  }
884  *p = '\0';
885  }
886 
887  *p++;
888  }
889 
890  // Replace newlines, question marks and colons in strings
891  for( i = 0; i < cnt; i++ )
892  {
893  p = params[i];
894  q = params[i];
895 
896  while( *p != '\0' )
897  {
898  if( *p == '\\' && *(p + 1) == 'n' )
899  {
900  p += 2;
901  *(q++) = '\n';
902  }
903  else if( *p == '\\' && *(p + 1) == ':' )
904  {
905  p += 2;
906  *(q++) = ':';
907  }
908  else if( *p == '\\' && *(p + 1) == '?' )
909  {
910  p += 2;
911  *(q++) = '?';
912  }
913  else
914  *(q++) = *(p++);
915  }
916  *q = '\0';
917  }
918 
919  return( cnt );
920 }
921 
922 int main()
923 {
924  int ret, i, cnt, total_errors = 0, total_tests = 0, total_skipped = 0;
925  const char *filename = "/home/iurt/rpmbuild/BUILD/polarssl-1.3.1/tests/suites/test_suite_md.data";
926  FILE *file;
927  char buf[5000];
928  char *params[50];
929 
930 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
931  unsigned char alloc_buf[1000000];
932  memory_buffer_alloc_init( alloc_buf, sizeof(alloc_buf) );
933 #endif
934 
935  file = fopen( filename, "r" );
936  if( file == NULL )
937  {
938  fprintf( stderr, "Failed to open\n" );
939  return( 1 );
940  }
941 
942  while( !feof( file ) )
943  {
944  int skip = 0;
945 
946  if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
947  break;
948  fprintf( stdout, "%s%.66s", test_errors ? "\n" : "", buf );
949  fprintf( stdout, " " );
950  for( i = strlen( buf ) + 1; i < 67; i++ )
951  fprintf( stdout, "." );
952  fprintf( stdout, " " );
953  fflush( stdout );
954 
955  total_tests++;
956 
957  if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
958  break;
959  cnt = parse_arguments( buf, strlen(buf), params );
960 
961  if( strcmp( params[0], "depends_on" ) == 0 )
962  {
963  for( i = 1; i < cnt; i++ )
964  if( dep_check( params[i] ) != 0 )
965  skip = 1;
966 
967  if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
968  break;
969  cnt = parse_arguments( buf, strlen(buf), params );
970  }
971 
972  if( skip == 0 )
973  {
974  test_errors = 0;
975  ret = dispatch_test( cnt, params );
976  }
977 
978  if( skip == 1 || ret == 3 )
979  {
980  total_skipped++;
981  fprintf( stdout, "----\n" );
982  fflush( stdout );
983  }
984  else if( ret == 0 && test_errors == 0 )
985  {
986  fprintf( stdout, "PASS\n" );
987  fflush( stdout );
988  }
989  else if( ret == 2 )
990  {
991  fprintf( stderr, "FAILED: FATAL PARSE ERROR\n" );
992  fclose(file);
993  exit( 2 );
994  }
995  else
996  total_errors++;
997 
998  if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
999  break;
1000  if( strlen(buf) != 0 )
1001  {
1002  fprintf( stderr, "Should be empty %d\n", (int) strlen(buf) );
1003  return( 1 );
1004  }
1005  }
1006  fclose(file);
1007 
1008  fprintf( stdout, "\n----------------------------------------------------------------------------\n\n");
1009  if( total_errors == 0 )
1010  fprintf( stdout, "PASSED" );
1011  else
1012  fprintf( stdout, "FAILED" );
1013 
1014  fprintf( stdout, " (%d / %d tests (%d skipped))\n",
1015  total_tests - total_errors, total_tests, total_skipped );
1016 
1017 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
1018 #if defined(POLARSSL_MEMORY_DEBUG)
1019  memory_buffer_alloc_status();
1020 #endif
1021  memory_buffer_alloc_free();
1022 #endif
1023 
1024  return( total_errors != 0 );
1025 }
1026 
1027