00001 #include <polarssl/config.h>
00002
00003 #ifdef POLARSSL_MD_C
00004
00005 #include <polarssl/md.h>
00006 #include <polarssl/md2.h>
00007 #include <polarssl/md4.h>
00008 #include <polarssl/md5.h>
00009 #include <polarssl/sha1.h>
00010 #include <polarssl/sha256.h>
00011 #include <polarssl/sha512.h>
00012 #endif
00013
00014
00015 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
00016 #include "polarssl/memory.h"
00017 #endif
00018
00019 #if defined(WANT_NOT_RND_MPI)
00020 #if defined(POLARSSL_BIGNUM_C)
00021 #include "polarssl/bignum.h"
00022 #else
00023 #error "not_rnd_mpi() need bignum.c"
00024 #endif
00025 #endif
00026
00027 #ifdef _MSC_VER
00028 #include <basetsd.h>
00029 typedef UINT32 uint32_t;
00030 #else
00031 #include <inttypes.h>
00032 #endif
00033
00034 #include <assert.h>
00035 #include <stdlib.h>
00036 #include <string.h>
00037
00038
00039
00040
00041 #ifndef GET_UINT32_BE
00042 #define GET_UINT32_BE(n,b,i) \
00043 { \
00044 (n) = ( (uint32_t) (b)[(i) ] << 24 ) \
00045 | ( (uint32_t) (b)[(i) + 1] << 16 ) \
00046 | ( (uint32_t) (b)[(i) + 2] << 8 ) \
00047 | ( (uint32_t) (b)[(i) + 3] ); \
00048 }
00049 #endif
00050
00051 #ifndef PUT_UINT32_BE
00052 #define PUT_UINT32_BE(n,b,i) \
00053 { \
00054 (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
00055 (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
00056 (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
00057 (b)[(i) + 3] = (unsigned char) ( (n) ); \
00058 }
00059 #endif
00060
00061 static int unhexify(unsigned char *obuf, const char *ibuf)
00062 {
00063 unsigned char c, c2;
00064 int len = strlen(ibuf) / 2;
00065 assert(!(strlen(ibuf) %1));
00066
00067 while (*ibuf != 0)
00068 {
00069 c = *ibuf++;
00070 if( c >= '0' && c <= '9' )
00071 c -= '0';
00072 else if( c >= 'a' && c <= 'f' )
00073 c -= 'a' - 10;
00074 else if( c >= 'A' && c <= 'F' )
00075 c -= 'A' - 10;
00076 else
00077 assert( 0 );
00078
00079 c2 = *ibuf++;
00080 if( c2 >= '0' && c2 <= '9' )
00081 c2 -= '0';
00082 else if( c2 >= 'a' && c2 <= 'f' )
00083 c2 -= 'a' - 10;
00084 else if( c2 >= 'A' && c2 <= 'F' )
00085 c2 -= 'A' - 10;
00086 else
00087 assert( 0 );
00088
00089 *obuf++ = ( c << 4 ) | c2;
00090 }
00091
00092 return len;
00093 }
00094
00095 static void hexify(unsigned char *obuf, const unsigned char *ibuf, int len)
00096 {
00097 unsigned char l, h;
00098
00099 while (len != 0)
00100 {
00101 h = (*ibuf) / 16;
00102 l = (*ibuf) % 16;
00103
00104 if( h < 10 )
00105 *obuf++ = '0' + h;
00106 else
00107 *obuf++ = 'a' + h - 10;
00108
00109 if( l < 10 )
00110 *obuf++ = '0' + l;
00111 else
00112 *obuf++ = 'a' + l - 10;
00113
00114 ++ibuf;
00115 len--;
00116 }
00117 }
00118
00128 static int rnd_std_rand( void *rng_state, unsigned char *output, size_t len )
00129 {
00130 size_t i;
00131
00132 if( rng_state != NULL )
00133 rng_state = NULL;
00134
00135 for( i = 0; i < len; ++i )
00136 output[i] = rand();
00137
00138 return( 0 );
00139 }
00140
00146 static int rnd_zero_rand( void *rng_state, unsigned char *output, size_t len )
00147 {
00148 if( rng_state != NULL )
00149 rng_state = NULL;
00150
00151 memset( output, 0, len );
00152
00153 return( 0 );
00154 }
00155
00156 typedef struct
00157 {
00158 unsigned char *buf;
00159 size_t length;
00160 } rnd_buf_info;
00161
00173 static int rnd_buffer_rand( void *rng_state, unsigned char *output, size_t len )
00174 {
00175 rnd_buf_info *info = (rnd_buf_info *) rng_state;
00176 size_t use_len;
00177
00178 if( rng_state == NULL )
00179 return( rnd_std_rand( NULL, output, len ) );
00180
00181 use_len = len;
00182 if( len > info->length )
00183 use_len = info->length;
00184
00185 if( use_len )
00186 {
00187 memcpy( output, info->buf, use_len );
00188 info->buf += use_len;
00189 info->length -= use_len;
00190 }
00191
00192 if( len - use_len > 0 )
00193 return( rnd_std_rand( NULL, output + use_len, len - use_len ) );
00194
00195 return( 0 );
00196 }
00197
00205 typedef struct
00206 {
00207 uint32_t key[16];
00208 uint32_t v0, v1;
00209 } rnd_pseudo_info;
00210
00219 static int rnd_pseudo_rand( void *rng_state, unsigned char *output, size_t len )
00220 {
00221 rnd_pseudo_info *info = (rnd_pseudo_info *) rng_state;
00222 uint32_t i, *k, sum, delta=0x9E3779B9;
00223 unsigned char result[4];
00224
00225 if( rng_state == NULL )
00226 return( rnd_std_rand( NULL, output, len ) );
00227
00228 k = info->key;
00229
00230 while( len > 0 )
00231 {
00232 size_t use_len = ( len > 4 ) ? 4 : len;
00233 sum = 0;
00234
00235 for( i = 0; i < 32; i++ )
00236 {
00237 info->v0 += (((info->v1 << 4) ^ (info->v1 >> 5)) + info->v1) ^ (sum + k[sum & 3]);
00238 sum += delta;
00239 info->v1 += (((info->v0 << 4) ^ (info->v0 >> 5)) + info->v0) ^ (sum + k[(sum>>11) & 3]);
00240 }
00241
00242 PUT_UINT32_BE( info->v0, result, 0 );
00243 memcpy( output, result, use_len );
00244 len -= use_len;
00245 }
00246
00247 return( 0 );
00248 }
00249
00250 #if defined(WANT_NOT_RND_MPI)
00251
00259 #define ciL (sizeof(t_uint))
00260 #define CHARS_TO_LIMBS(i) (((i) + ciL - 1) / ciL)
00261 static int not_rnd_mpi( void *in, unsigned char *out, size_t len )
00262 {
00263 char *str = (char *) in;
00264 mpi X;
00265
00266
00267
00268
00269
00270 X.s = 1;
00271 X.p = (t_uint *) out;
00272 X.n = CHARS_TO_LIMBS( len );
00273
00274
00275
00276
00277
00278 assert( strlen( str ) / 2 == len );
00279
00280 return( mpi_read_string( &X, 16, str ) );
00281 }
00282 #endif
00283
00284
00285 #include <stdio.h>
00286 #include <string.h>
00287
00288 static int test_errors = 0;
00289
00290 #ifdef POLARSSL_MD_C
00291
00292 #define TEST_SUITE_ACTIVE
00293
00294 static int test_assert( int correct, char *test )
00295 {
00296 if( correct )
00297 return( 0 );
00298
00299 test_errors++;
00300 if( test_errors == 1 )
00301 printf( "FAILED\n" );
00302 printf( " %s\n", test );
00303
00304 return( 1 );
00305 }
00306
00307 #define TEST_ASSERT( TEST ) \
00308 do { test_assert( (TEST) ? 1 : 0, #TEST ); \
00309 if( test_errors) return; \
00310 } while (0)
00311
00312 int verify_string( char **str )
00313 {
00314 if( (*str)[0] != '"' ||
00315 (*str)[strlen( *str ) - 1] != '"' )
00316 {
00317 printf( "Expected string (with \"\") for parameter and got: %s\n", *str );
00318 return( -1 );
00319 }
00320
00321 (*str)++;
00322 (*str)[strlen( *str ) - 1] = '\0';
00323
00324 return( 0 );
00325 }
00326
00327 int verify_int( char *str, int *value )
00328 {
00329 size_t i;
00330 int minus = 0;
00331 int digits = 1;
00332 int hex = 0;
00333
00334 for( i = 0; i < strlen( str ); i++ )
00335 {
00336 if( i == 0 && str[i] == '-' )
00337 {
00338 minus = 1;
00339 continue;
00340 }
00341
00342 if( ( ( minus && i == 2 ) || ( !minus && i == 1 ) ) &&
00343 str[i - 1] == '0' && str[i] == 'x' )
00344 {
00345 hex = 1;
00346 continue;
00347 }
00348
00349 if( str[i] < '0' || str[i] > '9' )
00350 {
00351 digits = 0;
00352 break;
00353 }
00354 }
00355
00356 if( digits )
00357 {
00358 if( hex )
00359 *value = strtol( str, NULL, 16 );
00360 else
00361 *value = strtol( str, NULL, 10 );
00362
00363 return( 0 );
00364 }
00365
00366
00367
00368 printf( "Expected integer for parameter and got: %s\n", str );
00369 return( -1 );
00370 }
00371
00372 void test_suite_md_text( char *text_md_name, char *text_src_string, char *hex_hash_string )
00373 {
00374 char md_name[100];
00375 unsigned char src_str[1000];
00376 unsigned char hash_str[1000];
00377 unsigned char output[100];
00378 const md_info_t *md_info = NULL;
00379
00380 memset(md_name, 0x00, 100);
00381 memset(src_str, 0x00, 1000);
00382 memset(hash_str, 0x00, 1000);
00383 memset(output, 0x00, 100);
00384
00385 strcpy( (char *) src_str, text_src_string );
00386
00387 strncpy( (char *) md_name, text_md_name, 100 );
00388 md_info = md_info_from_string(md_name);
00389 TEST_ASSERT( md_info != NULL );
00390
00391 TEST_ASSERT ( 0 == md( md_info, src_str, strlen( (char *) src_str ), output ) );
00392 hexify( hash_str, output, md_get_size(md_info) );
00393
00394 TEST_ASSERT( strcmp( (char *) hash_str, hex_hash_string ) == 0 );
00395 }
00396
00397 void test_suite_md_hex( char *text_md_name, char *hex_src_string, char *hex_hash_string )
00398 {
00399 char md_name[100];
00400 unsigned char src_str[10000];
00401 unsigned char hash_str[10000];
00402 unsigned char output[100];
00403 int src_len;
00404 const md_info_t *md_info = NULL;
00405
00406 memset(md_name, 0x00, 100);
00407 memset(src_str, 0x00, 10000);
00408 memset(hash_str, 0x00, 10000);
00409 memset(output, 0x00, 100);
00410
00411 strncpy( (char *) md_name, text_md_name, 100 );
00412 md_info = md_info_from_string(md_name);
00413 TEST_ASSERT( md_info != NULL );
00414
00415 src_len = unhexify( src_str, hex_src_string );
00416 TEST_ASSERT ( 0 == md( md_info, src_str, src_len, output ) );
00417
00418 hexify( hash_str, output, md_get_size(md_info) );
00419
00420 TEST_ASSERT( strcmp( (char *) hash_str, hex_hash_string ) == 0 );
00421 }
00422
00423 void test_suite_md_text_multi( char *text_md_name, char *text_src_string,
00424 char *hex_hash_string )
00425 {
00426 char md_name[100];
00427 unsigned char src_str[1000];
00428 unsigned char hash_str[1000];
00429 unsigned char output[100];
00430
00431 const md_info_t *md_info = NULL;
00432 md_context_t ctx = MD_CONTEXT_T_INIT;
00433
00434 memset(md_name, 0x00, 100);
00435 memset(src_str, 0x00, 1000);
00436 memset(hash_str, 0x00, 1000);
00437 memset(output, 0x00, 100);
00438
00439 strcpy( (char *) src_str, text_src_string );
00440
00441 strncpy( (char *) md_name, text_md_name, 100 );
00442 md_info = md_info_from_string(md_name);
00443 TEST_ASSERT( md_info != NULL );
00444 TEST_ASSERT ( 0 == md_init_ctx( &ctx, md_info ) );
00445
00446 TEST_ASSERT ( 0 == md_starts( &ctx ) );
00447 TEST_ASSERT ( ctx.md_ctx != NULL );
00448 TEST_ASSERT ( 0 == md_update( &ctx, src_str, strlen( (char *) src_str ) ) );
00449 TEST_ASSERT ( 0 == md_finish( &ctx, output ) );
00450 TEST_ASSERT ( 0 == md_free_ctx( &ctx ) );
00451
00452 hexify( hash_str, output, md_get_size(md_info) );
00453
00454 TEST_ASSERT( strcmp( (char *) hash_str, hex_hash_string ) == 0 );
00455 }
00456
00457 void test_suite_md_hex_multi( char *text_md_name, char *hex_src_string,
00458 char *hex_hash_string )
00459 {
00460 char md_name[100];
00461 unsigned char src_str[10000];
00462 unsigned char hash_str[10000];
00463 unsigned char output[100];
00464 int src_len;
00465 const md_info_t *md_info = NULL;
00466 md_context_t ctx = MD_CONTEXT_T_INIT;
00467
00468 memset(md_name, 0x00, 100);
00469 memset(src_str, 0x00, 10000);
00470 memset(hash_str, 0x00, 10000);
00471 memset(output, 0x00, 100);
00472
00473 strncpy( (char *) md_name, text_md_name, 100 );
00474 md_info = md_info_from_string(md_name);
00475 TEST_ASSERT( md_info != NULL );
00476 TEST_ASSERT ( 0 == md_init_ctx( &ctx, md_info ) );
00477
00478 src_len = unhexify( src_str, hex_src_string );
00479
00480 TEST_ASSERT ( 0 == md_starts( &ctx ) );
00481 TEST_ASSERT ( ctx.md_ctx != NULL );
00482 TEST_ASSERT ( 0 == md_update( &ctx, src_str, src_len ) );
00483 TEST_ASSERT ( 0 == md_finish( &ctx, output ) );
00484 TEST_ASSERT ( 0 == md_free_ctx( &ctx ) );
00485
00486 hexify( hash_str, output, md_get_size(md_info) );
00487
00488 TEST_ASSERT( strcmp( (char *) hash_str, hex_hash_string ) == 0 );
00489 }
00490
00491 void test_suite_md_hmac( char *text_md_name, int trunc_size, char *hex_key_string,
00492 char *hex_src_string, char *hex_hash_string )
00493 {
00494 char md_name[100];
00495 unsigned char src_str[10000];
00496 unsigned char key_str[10000];
00497 unsigned char hash_str[10000];
00498 unsigned char output[100];
00499 int key_len, src_len;
00500 const md_info_t *md_info = NULL;
00501
00502 memset(md_name, 0x00, 100);
00503 memset(src_str, 0x00, 10000);
00504 memset(key_str, 0x00, 10000);
00505 memset(hash_str, 0x00, 10000);
00506 memset(output, 0x00, 100);
00507
00508 strncpy( (char *) md_name, text_md_name, 100 );
00509 md_info = md_info_from_string( md_name );
00510 TEST_ASSERT( md_info != NULL );
00511
00512 key_len = unhexify( key_str, hex_key_string );
00513 src_len = unhexify( src_str, hex_src_string );
00514
00515 TEST_ASSERT ( md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
00516 hexify( hash_str, output, md_get_size(md_info) );
00517
00518 TEST_ASSERT( strncmp( (char *) hash_str, hex_hash_string, trunc_size * 2 ) == 0 );
00519 }
00520
00521 void test_suite_md_hmac_multi( char *text_md_name, int trunc_size, char *hex_key_string,
00522 char *hex_src_string, char *hex_hash_string )
00523 {
00524 char md_name[100];
00525 unsigned char src_str[10000];
00526 unsigned char key_str[10000];
00527 unsigned char hash_str[10000];
00528 unsigned char output[100];
00529 int key_len, src_len;
00530 const md_info_t *md_info = NULL;
00531 md_context_t ctx = MD_CONTEXT_T_INIT;
00532
00533 memset(md_name, 0x00, 100);
00534 memset(src_str, 0x00, 10000);
00535 memset(key_str, 0x00, 10000);
00536 memset(hash_str, 0x00, 10000);
00537 memset(output, 0x00, 100);
00538
00539 strncpy( (char *) md_name, text_md_name, 100 );
00540 md_info = md_info_from_string( md_name );
00541 TEST_ASSERT( md_info != NULL );
00542 TEST_ASSERT ( 0 == md_init_ctx( &ctx, md_info ) );
00543
00544 key_len = unhexify( key_str, hex_key_string );
00545 src_len = unhexify( src_str, hex_src_string );
00546
00547 TEST_ASSERT ( 0 == md_hmac_starts( &ctx, key_str, key_len ) );
00548 TEST_ASSERT ( ctx.md_ctx != NULL );
00549 TEST_ASSERT ( 0 == md_hmac_update( &ctx, src_str, src_len ) );
00550 TEST_ASSERT ( 0 == md_hmac_finish( &ctx, output ) );
00551 TEST_ASSERT ( 0 == md_free_ctx( &ctx ) );
00552
00553 hexify( hash_str, output, md_get_size(md_info) );
00554
00555 TEST_ASSERT( strncmp( (char *) hash_str, hex_hash_string, trunc_size * 2 ) == 0 );
00556 }
00557
00558 #ifdef POLARSSL_FS_IO
00559 void test_suite_md_file( char *text_md_name, char *filename, char *hex_hash_string )
00560 {
00561 char md_name[100];
00562 unsigned char hash_str[1000];
00563 unsigned char output[100];
00564 const md_info_t *md_info = NULL;
00565
00566 memset(md_name, 0x00, 100);
00567 memset(hash_str, 0x00, 1000);
00568 memset(output, 0x00, 100);
00569
00570 strncpy( (char *) md_name, text_md_name, 100 );
00571 md_info = md_info_from_string( md_name );
00572 TEST_ASSERT( md_info != NULL );
00573
00574 md_file( md_info, filename, output);
00575 hexify( hash_str, output, md_get_size(md_info) );
00576
00577 TEST_ASSERT( strcmp( (char *) hash_str, hex_hash_string ) == 0 );
00578 }
00579 #endif
00580
00581
00582 #endif
00583
00584
00585 int dep_check( char *str )
00586 {
00587 if( str == NULL )
00588 return( 1 );
00589
00590 if( strcmp( str, "POLARSSL_MD5_C" ) == 0 )
00591 {
00592 #if defined(POLARSSL_MD5_C)
00593 return( 0 );
00594 #else
00595 return( 1 );
00596 #endif
00597 }
00598 if( strcmp( str, "POLARSSL_SHA256_C" ) == 0 )
00599 {
00600 #if defined(POLARSSL_SHA256_C)
00601 return( 0 );
00602 #else
00603 return( 1 );
00604 #endif
00605 }
00606 if( strcmp( str, "POLARSSL_SHA1_C" ) == 0 )
00607 {
00608 #if defined(POLARSSL_SHA1_C)
00609 return( 0 );
00610 #else
00611 return( 1 );
00612 #endif
00613 }
00614 if( strcmp( str, "POLARSSL_MD4_C" ) == 0 )
00615 {
00616 #if defined(POLARSSL_MD4_C)
00617 return( 0 );
00618 #else
00619 return( 1 );
00620 #endif
00621 }
00622 if( strcmp( str, "POLARSSL_MD_C" ) == 0 )
00623 {
00624 #if defined(POLARSSL_MD_C)
00625 return( 0 );
00626 #else
00627 return( 1 );
00628 #endif
00629 }
00630 if( strcmp( str, "POLARSSL_MD2_C" ) == 0 )
00631 {
00632 #if defined(POLARSSL_MD2_C)
00633 return( 0 );
00634 #else
00635 return( 1 );
00636 #endif
00637 }
00638 if( strcmp( str, "POLARSSL_SHA512_C" ) == 0 )
00639 {
00640 #if defined(POLARSSL_SHA512_C)
00641 return( 0 );
00642 #else
00643 return( 1 );
00644 #endif
00645 }
00646
00647
00648 return( 1 );
00649 }
00650
00651 int dispatch_test(int cnt, char *params[50])
00652 {
00653 int ret;
00654 ((void) cnt);
00655 ((void) params);
00656
00657 #if defined(TEST_SUITE_ACTIVE)
00658 if( strcmp( params[0], "md_text" ) == 0 )
00659 {
00660
00661 char *param1 = params[1];
00662 char *param2 = params[2];
00663 char *param3 = params[3];
00664
00665 if( cnt != 4 )
00666 {
00667 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
00668 return( 2 );
00669 }
00670
00671 if( verify_string( ¶m1 ) != 0 ) return( 2 );
00672 if( verify_string( ¶m2 ) != 0 ) return( 2 );
00673 if( verify_string( ¶m3 ) != 0 ) return( 2 );
00674
00675 test_suite_md_text( param1, param2, param3 );
00676 return ( 0 );
00677
00678 return ( 3 );
00679 }
00680 else
00681 if( strcmp( params[0], "md_hex" ) == 0 )
00682 {
00683
00684 char *param1 = params[1];
00685 char *param2 = params[2];
00686 char *param3 = params[3];
00687
00688 if( cnt != 4 )
00689 {
00690 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
00691 return( 2 );
00692 }
00693
00694 if( verify_string( ¶m1 ) != 0 ) return( 2 );
00695 if( verify_string( ¶m2 ) != 0 ) return( 2 );
00696 if( verify_string( ¶m3 ) != 0 ) return( 2 );
00697
00698 test_suite_md_hex( param1, param2, param3 );
00699 return ( 0 );
00700
00701 return ( 3 );
00702 }
00703 else
00704 if( strcmp( params[0], "md_text_multi" ) == 0 )
00705 {
00706
00707 char *param1 = params[1];
00708 char *param2 = params[2];
00709 char *param3 = params[3];
00710
00711 if( cnt != 4 )
00712 {
00713 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
00714 return( 2 );
00715 }
00716
00717 if( verify_string( ¶m1 ) != 0 ) return( 2 );
00718 if( verify_string( ¶m2 ) != 0 ) return( 2 );
00719 if( verify_string( ¶m3 ) != 0 ) return( 2 );
00720
00721 test_suite_md_text_multi( param1, param2, param3 );
00722 return ( 0 );
00723
00724 return ( 3 );
00725 }
00726 else
00727 if( strcmp( params[0], "md_hex_multi" ) == 0 )
00728 {
00729
00730 char *param1 = params[1];
00731 char *param2 = params[2];
00732 char *param3 = params[3];
00733
00734 if( cnt != 4 )
00735 {
00736 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
00737 return( 2 );
00738 }
00739
00740 if( verify_string( ¶m1 ) != 0 ) return( 2 );
00741 if( verify_string( ¶m2 ) != 0 ) return( 2 );
00742 if( verify_string( ¶m3 ) != 0 ) return( 2 );
00743
00744 test_suite_md_hex_multi( param1, param2, param3 );
00745 return ( 0 );
00746
00747 return ( 3 );
00748 }
00749 else
00750 if( strcmp( params[0], "md_hmac" ) == 0 )
00751 {
00752
00753 char *param1 = params[1];
00754 int param2;
00755 char *param3 = params[3];
00756 char *param4 = params[4];
00757 char *param5 = params[5];
00758
00759 if( cnt != 6 )
00760 {
00761 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 6 );
00762 return( 2 );
00763 }
00764
00765 if( verify_string( ¶m1 ) != 0 ) return( 2 );
00766 if( verify_int( params[2], ¶m2 ) != 0 ) return( 2 );
00767 if( verify_string( ¶m3 ) != 0 ) return( 2 );
00768 if( verify_string( ¶m4 ) != 0 ) return( 2 );
00769 if( verify_string( ¶m5 ) != 0 ) return( 2 );
00770
00771 test_suite_md_hmac( param1, param2, param3, param4, param5 );
00772 return ( 0 );
00773
00774 return ( 3 );
00775 }
00776 else
00777 if( strcmp( params[0], "md_hmac_multi" ) == 0 )
00778 {
00779
00780 char *param1 = params[1];
00781 int param2;
00782 char *param3 = params[3];
00783 char *param4 = params[4];
00784 char *param5 = params[5];
00785
00786 if( cnt != 6 )
00787 {
00788 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 6 );
00789 return( 2 );
00790 }
00791
00792 if( verify_string( ¶m1 ) != 0 ) return( 2 );
00793 if( verify_int( params[2], ¶m2 ) != 0 ) return( 2 );
00794 if( verify_string( ¶m3 ) != 0 ) return( 2 );
00795 if( verify_string( ¶m4 ) != 0 ) return( 2 );
00796 if( verify_string( ¶m5 ) != 0 ) return( 2 );
00797
00798 test_suite_md_hmac_multi( param1, param2, param3, param4, param5 );
00799 return ( 0 );
00800
00801 return ( 3 );
00802 }
00803 else
00804 if( strcmp( params[0], "md_file" ) == 0 )
00805 {
00806 #ifdef POLARSSL_FS_IO
00807
00808 char *param1 = params[1];
00809 char *param2 = params[2];
00810 char *param3 = params[3];
00811
00812 if( cnt != 4 )
00813 {
00814 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
00815 return( 2 );
00816 }
00817
00818 if( verify_string( ¶m1 ) != 0 ) return( 2 );
00819 if( verify_string( ¶m2 ) != 0 ) return( 2 );
00820 if( verify_string( ¶m3 ) != 0 ) return( 2 );
00821
00822 test_suite_md_file( param1, param2, param3 );
00823 return ( 0 );
00824 #endif
00825
00826 return ( 3 );
00827 }
00828 else
00829
00830 {
00831 fprintf( stdout, "FAILED\nSkipping unknown test function '%s'\n", params[0] );
00832 fflush( stdout );
00833 return( 1 );
00834 }
00835 #else
00836 return( 3 );
00837 #endif
00838 return( ret );
00839 }
00840
00841 int get_line( FILE *f, char *buf, size_t len )
00842 {
00843 char *ret;
00844
00845 ret = fgets( buf, len, f );
00846 if( ret == NULL )
00847 return( -1 );
00848
00849 if( strlen( buf ) && buf[strlen(buf) - 1] == '\n' )
00850 buf[strlen(buf) - 1] = '\0';
00851 if( strlen( buf ) && buf[strlen(buf) - 1] == '\r' )
00852 buf[strlen(buf) - 1] = '\0';
00853
00854 return( 0 );
00855 }
00856
00857 int parse_arguments( char *buf, size_t len, char *params[50] )
00858 {
00859 int cnt = 0, i;
00860 char *cur = buf;
00861 char *p = buf, *q;
00862
00863 params[cnt++] = cur;
00864
00865 while( *p != '\0' && p < buf + len )
00866 {
00867 if( *p == '\\' )
00868 {
00869 *p++;
00870 *p++;
00871 continue;
00872 }
00873 if( *p == ':' )
00874 {
00875 if( p + 1 < buf + len )
00876 {
00877 cur = p + 1;
00878 params[cnt++] = cur;
00879 }
00880 *p = '\0';
00881 }
00882
00883 *p++;
00884 }
00885
00886
00887 for( i = 0; i < cnt; i++ )
00888 {
00889 p = params[i];
00890 q = params[i];
00891
00892 while( *p != '\0' )
00893 {
00894 if( *p == '\\' && *(p + 1) == 'n' )
00895 {
00896 p += 2;
00897 *(q++) = '\n';
00898 }
00899 else if( *p == '\\' && *(p + 1) == ':' )
00900 {
00901 p += 2;
00902 *(q++) = ':';
00903 }
00904 else if( *p == '\\' && *(p + 1) == '?' )
00905 {
00906 p += 2;
00907 *(q++) = '?';
00908 }
00909 else
00910 *(q++) = *(p++);
00911 }
00912 *q = '\0';
00913 }
00914
00915 return( cnt );
00916 }
00917
00918 int main()
00919 {
00920 int ret, i, cnt, total_errors = 0, total_tests = 0, total_skipped = 0;
00921 const char *filename = "/home/abuild/rpmbuild/BUILD/polarssl-1.3.2/tests/suites/test_suite_md.data";
00922 FILE *file;
00923 char buf[5000];
00924 char *params[50];
00925
00926 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
00927 unsigned char alloc_buf[1000000];
00928 memory_buffer_alloc_init( alloc_buf, sizeof(alloc_buf) );
00929 #endif
00930
00931 file = fopen( filename, "r" );
00932 if( file == NULL )
00933 {
00934 fprintf( stderr, "Failed to open\n" );
00935 return( 1 );
00936 }
00937
00938 while( !feof( file ) )
00939 {
00940 int skip = 0;
00941
00942 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
00943 break;
00944 fprintf( stdout, "%s%.66s", test_errors ? "\n" : "", buf );
00945 fprintf( stdout, " " );
00946 for( i = strlen( buf ) + 1; i < 67; i++ )
00947 fprintf( stdout, "." );
00948 fprintf( stdout, " " );
00949 fflush( stdout );
00950
00951 total_tests++;
00952
00953 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
00954 break;
00955 cnt = parse_arguments( buf, strlen(buf), params );
00956
00957 if( strcmp( params[0], "depends_on" ) == 0 )
00958 {
00959 for( i = 1; i < cnt; i++ )
00960 if( dep_check( params[i] ) != 0 )
00961 skip = 1;
00962
00963 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
00964 break;
00965 cnt = parse_arguments( buf, strlen(buf), params );
00966 }
00967
00968 if( skip == 0 )
00969 {
00970 test_errors = 0;
00971 ret = dispatch_test( cnt, params );
00972 }
00973
00974 if( skip == 1 || ret == 3 )
00975 {
00976 total_skipped++;
00977 fprintf( stdout, "----\n" );
00978 fflush( stdout );
00979 }
00980 else if( ret == 0 && test_errors == 0 )
00981 {
00982 fprintf( stdout, "PASS\n" );
00983 fflush( stdout );
00984 }
00985 else if( ret == 2 )
00986 {
00987 fprintf( stderr, "FAILED: FATAL PARSE ERROR\n" );
00988 fclose(file);
00989 exit( 2 );
00990 }
00991 else
00992 total_errors++;
00993
00994 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
00995 break;
00996 if( strlen(buf) != 0 )
00997 {
00998 fprintf( stderr, "Should be empty %d\n", (int) strlen(buf) );
00999 return( 1 );
01000 }
01001 }
01002 fclose(file);
01003
01004 fprintf( stdout, "\n----------------------------------------------------------------------------\n\n");
01005 if( total_errors == 0 )
01006 fprintf( stdout, "PASSED" );
01007 else
01008 fprintf( stdout, "FAILED" );
01009
01010 fprintf( stdout, " (%d / %d tests (%d skipped))\n",
01011 total_tests - total_errors, total_tests, total_skipped );
01012
01013 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
01014 #if defined(POLARSSL_MEMORY_DEBUG)
01015 memory_buffer_alloc_status();
01016 #endif
01017 memory_buffer_alloc_free();
01018 #endif
01019
01020 return( total_errors != 0 );
01021 }
01022
01023