00001 #include <polarssl/config.h>
00002
00003 #ifdef POLARSSL_ECDSA_C
00004
00005 #include <polarssl/ecdsa.h>
00006 #define WANT_NOT_RND_MPI
00007 #endif
00008
00009
00010 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
00011 #include "polarssl/memory.h"
00012 #endif
00013
00014 #if defined(WANT_NOT_RND_MPI)
00015 #if defined(POLARSSL_BIGNUM_C)
00016 #include "polarssl/bignum.h"
00017 #else
00018 #error "not_rnd_mpi() need bignum.c"
00019 #endif
00020 #endif
00021
00022 #ifdef _MSC_VER
00023 #include <basetsd.h>
00024 typedef UINT32 uint32_t;
00025 #else
00026 #include <inttypes.h>
00027 #endif
00028
00029 #include <assert.h>
00030 #include <stdlib.h>
00031 #include <string.h>
00032
00033
00034
00035
00036 #ifndef GET_UINT32_BE
00037 #define GET_UINT32_BE(n,b,i) \
00038 { \
00039 (n) = ( (uint32_t) (b)[(i) ] << 24 ) \
00040 | ( (uint32_t) (b)[(i) + 1] << 16 ) \
00041 | ( (uint32_t) (b)[(i) + 2] << 8 ) \
00042 | ( (uint32_t) (b)[(i) + 3] ); \
00043 }
00044 #endif
00045
00046 #ifndef PUT_UINT32_BE
00047 #define PUT_UINT32_BE(n,b,i) \
00048 { \
00049 (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
00050 (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
00051 (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
00052 (b)[(i) + 3] = (unsigned char) ( (n) ); \
00053 }
00054 #endif
00055
00056 static int unhexify(unsigned char *obuf, const char *ibuf)
00057 {
00058 unsigned char c, c2;
00059 int len = strlen(ibuf) / 2;
00060 assert(!(strlen(ibuf) %1));
00061
00062 while (*ibuf != 0)
00063 {
00064 c = *ibuf++;
00065 if( c >= '0' && c <= '9' )
00066 c -= '0';
00067 else if( c >= 'a' && c <= 'f' )
00068 c -= 'a' - 10;
00069 else if( c >= 'A' && c <= 'F' )
00070 c -= 'A' - 10;
00071 else
00072 assert( 0 );
00073
00074 c2 = *ibuf++;
00075 if( c2 >= '0' && c2 <= '9' )
00076 c2 -= '0';
00077 else if( c2 >= 'a' && c2 <= 'f' )
00078 c2 -= 'a' - 10;
00079 else if( c2 >= 'A' && c2 <= 'F' )
00080 c2 -= 'A' - 10;
00081 else
00082 assert( 0 );
00083
00084 *obuf++ = ( c << 4 ) | c2;
00085 }
00086
00087 return len;
00088 }
00089
00090 static void hexify(unsigned char *obuf, const unsigned char *ibuf, int len)
00091 {
00092 unsigned char l, h;
00093
00094 while (len != 0)
00095 {
00096 h = (*ibuf) / 16;
00097 l = (*ibuf) % 16;
00098
00099 if( h < 10 )
00100 *obuf++ = '0' + h;
00101 else
00102 *obuf++ = 'a' + h - 10;
00103
00104 if( l < 10 )
00105 *obuf++ = '0' + l;
00106 else
00107 *obuf++ = 'a' + l - 10;
00108
00109 ++ibuf;
00110 len--;
00111 }
00112 }
00113
00123 static int rnd_std_rand( void *rng_state, unsigned char *output, size_t len )
00124 {
00125 size_t i;
00126
00127 if( rng_state != NULL )
00128 rng_state = NULL;
00129
00130 for( i = 0; i < len; ++i )
00131 output[i] = rand();
00132
00133 return( 0 );
00134 }
00135
00141 static int rnd_zero_rand( void *rng_state, unsigned char *output, size_t len )
00142 {
00143 if( rng_state != NULL )
00144 rng_state = NULL;
00145
00146 memset( output, 0, len );
00147
00148 return( 0 );
00149 }
00150
00151 typedef struct
00152 {
00153 unsigned char *buf;
00154 size_t length;
00155 } rnd_buf_info;
00156
00168 static int rnd_buffer_rand( void *rng_state, unsigned char *output, size_t len )
00169 {
00170 rnd_buf_info *info = (rnd_buf_info *) rng_state;
00171 size_t use_len;
00172
00173 if( rng_state == NULL )
00174 return( rnd_std_rand( NULL, output, len ) );
00175
00176 use_len = len;
00177 if( len > info->length )
00178 use_len = info->length;
00179
00180 if( use_len )
00181 {
00182 memcpy( output, info->buf, use_len );
00183 info->buf += use_len;
00184 info->length -= use_len;
00185 }
00186
00187 if( len - use_len > 0 )
00188 return( rnd_std_rand( NULL, output + use_len, len - use_len ) );
00189
00190 return( 0 );
00191 }
00192
00200 typedef struct
00201 {
00202 uint32_t key[16];
00203 uint32_t v0, v1;
00204 } rnd_pseudo_info;
00205
00214 static int rnd_pseudo_rand( void *rng_state, unsigned char *output, size_t len )
00215 {
00216 rnd_pseudo_info *info = (rnd_pseudo_info *) rng_state;
00217 uint32_t i, *k, sum, delta=0x9E3779B9;
00218 unsigned char result[4];
00219
00220 if( rng_state == NULL )
00221 return( rnd_std_rand( NULL, output, len ) );
00222
00223 k = info->key;
00224
00225 while( len > 0 )
00226 {
00227 size_t use_len = ( len > 4 ) ? 4 : len;
00228 sum = 0;
00229
00230 for( i = 0; i < 32; i++ )
00231 {
00232 info->v0 += (((info->v1 << 4) ^ (info->v1 >> 5)) + info->v1) ^ (sum + k[sum & 3]);
00233 sum += delta;
00234 info->v1 += (((info->v0 << 4) ^ (info->v0 >> 5)) + info->v0) ^ (sum + k[(sum>>11) & 3]);
00235 }
00236
00237 PUT_UINT32_BE( info->v0, result, 0 );
00238 memcpy( output, result, use_len );
00239 len -= use_len;
00240 }
00241
00242 return( 0 );
00243 }
00244
00245 #if defined(WANT_NOT_RND_MPI)
00246
00254 #define ciL (sizeof(t_uint))
00255 #define CHARS_TO_LIMBS(i) (((i) + ciL - 1) / ciL)
00256 static int not_rnd_mpi( void *in, unsigned char *out, size_t len )
00257 {
00258 char *str = (char *) in;
00259 mpi X;
00260
00261
00262
00263
00264
00265 X.s = 1;
00266 X.p = (t_uint *) out;
00267 X.n = CHARS_TO_LIMBS( len );
00268
00269
00270
00271
00272
00273 assert( strlen( str ) / 2 == len );
00274
00275 return( mpi_read_string( &X, 16, str ) );
00276 }
00277 #endif
00278
00279
00280 #include <stdio.h>
00281 #include <string.h>
00282
00283 static int test_errors = 0;
00284
00285 #ifdef POLARSSL_ECDSA_C
00286
00287 #define TEST_SUITE_ACTIVE
00288
00289 static int test_assert( int correct, char *test )
00290 {
00291 if( correct )
00292 return( 0 );
00293
00294 test_errors++;
00295 if( test_errors == 1 )
00296 printf( "FAILED\n" );
00297 printf( " %s\n", test );
00298
00299 return( 1 );
00300 }
00301
00302 #define TEST_ASSERT( TEST ) \
00303 do { test_assert( (TEST) ? 1 : 0, #TEST ); \
00304 if( test_errors) return; \
00305 } while (0)
00306
00307 int verify_string( char **str )
00308 {
00309 if( (*str)[0] != '"' ||
00310 (*str)[strlen( *str ) - 1] != '"' )
00311 {
00312 printf( "Expected string (with \"\") for parameter and got: %s\n", *str );
00313 return( -1 );
00314 }
00315
00316 (*str)++;
00317 (*str)[strlen( *str ) - 1] = '\0';
00318
00319 return( 0 );
00320 }
00321
00322 int verify_int( char *str, int *value )
00323 {
00324 size_t i;
00325 int minus = 0;
00326 int digits = 1;
00327 int hex = 0;
00328
00329 for( i = 0; i < strlen( str ); i++ )
00330 {
00331 if( i == 0 && str[i] == '-' )
00332 {
00333 minus = 1;
00334 continue;
00335 }
00336
00337 if( ( ( minus && i == 2 ) || ( !minus && i == 1 ) ) &&
00338 str[i - 1] == '0' && str[i] == 'x' )
00339 {
00340 hex = 1;
00341 continue;
00342 }
00343
00344 if( str[i] < '0' || str[i] > '9' )
00345 {
00346 digits = 0;
00347 break;
00348 }
00349 }
00350
00351 if( digits )
00352 {
00353 if( hex )
00354 *value = strtol( str, NULL, 16 );
00355 else
00356 *value = strtol( str, NULL, 10 );
00357
00358 return( 0 );
00359 }
00360
00361 if( strcmp( str, "POLARSSL_ECP_DP_SECP521R1" ) == 0 )
00362 {
00363 *value = ( POLARSSL_ECP_DP_SECP521R1 );
00364 return( 0 );
00365 }
00366 if( strcmp( str, "POLARSSL_ECP_DP_SECP384R1" ) == 0 )
00367 {
00368 *value = ( POLARSSL_ECP_DP_SECP384R1 );
00369 return( 0 );
00370 }
00371 if( strcmp( str, "POLARSSL_ECP_DP_SECP192R1" ) == 0 )
00372 {
00373 *value = ( POLARSSL_ECP_DP_SECP192R1 );
00374 return( 0 );
00375 }
00376 if( strcmp( str, "POLARSSL_ECP_DP_SECP224R1" ) == 0 )
00377 {
00378 *value = ( POLARSSL_ECP_DP_SECP224R1 );
00379 return( 0 );
00380 }
00381 if( strcmp( str, "POLARSSL_ECP_DP_SECP256R1" ) == 0 )
00382 {
00383 *value = ( POLARSSL_ECP_DP_SECP256R1 );
00384 return( 0 );
00385 }
00386
00387
00388 printf( "Expected integer for parameter and got: %s\n", str );
00389 return( -1 );
00390 }
00391
00392 void test_suite_ecdsa_prim_random( int id )
00393 {
00394 ecp_group grp;
00395 ecp_point Q;
00396 mpi d, r, s;
00397 rnd_pseudo_info rnd_info;
00398 unsigned char buf[66];
00399
00400 ecp_group_init( &grp );
00401 ecp_point_init( &Q );
00402 mpi_init( &d ); mpi_init( &r ); mpi_init( &s );
00403 memset( &rnd_info, 0x00, sizeof( rnd_pseudo_info ) );
00404 memset( buf, 0, sizeof( buf ) );
00405
00406
00407 TEST_ASSERT( rnd_pseudo_rand( &rnd_info, buf, sizeof( buf ) ) == 0 );
00408 TEST_ASSERT( ecp_use_known_dp( &grp, id ) == 0 );
00409 TEST_ASSERT( ecp_gen_keypair( &grp, &d, &Q, &rnd_pseudo_rand, &rnd_info )
00410 == 0 );
00411
00412 TEST_ASSERT( ecdsa_sign( &grp, &r, &s, &d, buf, sizeof( buf ),
00413 &rnd_pseudo_rand, &rnd_info ) == 0 );
00414 TEST_ASSERT( ecdsa_verify( &grp, buf, sizeof( buf ), &Q, &r, &s ) == 0 );
00415
00416 ecp_group_free( &grp );
00417 ecp_point_free( &Q );
00418 mpi_free( &d ); mpi_free( &r ); mpi_free( &s );
00419 }
00420
00421 void test_suite_ecdsa_prim_test_vectors( int id, char *d_str, char *xQ_str, char *yQ_str,
00422 char *k_str, char *hash_str, char *r_str,
00423 char *s_str )
00424 {
00425 ecp_group grp;
00426 ecp_point Q;
00427 mpi d, r, s, r_check, s_check;
00428 unsigned char buf[66];
00429 size_t len;
00430
00431 ecp_group_init( &grp );
00432 ecp_point_init( &Q );
00433 mpi_init( &d ); mpi_init( &r ); mpi_init( &s );
00434 mpi_init( &r_check ); mpi_init( &s_check );
00435 memset( buf, 0, sizeof( buf ) );
00436
00437 TEST_ASSERT( ecp_use_known_dp( &grp, id ) == 0 );
00438 TEST_ASSERT( ecp_point_read_string( &Q, 16, xQ_str, yQ_str ) == 0 );
00439 TEST_ASSERT( mpi_read_string( &d, 16, d_str ) == 0 );
00440 TEST_ASSERT( mpi_read_string( &r_check, 16, r_str ) == 0 );
00441 TEST_ASSERT( mpi_read_string( &s_check, 16, s_str ) == 0 );
00442 len = unhexify(buf, hash_str);
00443
00444 TEST_ASSERT( ecdsa_sign( &grp, &r, &s, &d, buf, len,
00445 ¬_rnd_mpi, k_str ) == 0 );
00446
00447 TEST_ASSERT( mpi_cmp_mpi( &r, &r_check ) == 0 );
00448 TEST_ASSERT( mpi_cmp_mpi( &s, &s_check ) == 0 );
00449
00450 TEST_ASSERT( ecdsa_verify( &grp, buf, len, &Q, &r_check, &s_check ) == 0 );
00451
00452 ecp_group_free( &grp );
00453 ecp_point_free( &Q );
00454 mpi_free( &d ); mpi_free( &r ); mpi_free( &s );
00455 mpi_free( &r_check ); mpi_free( &s_check );
00456 }
00457
00458 void test_suite_ecdsa_write_read_random( int id )
00459 {
00460 ecdsa_context ctx;
00461 rnd_pseudo_info rnd_info;
00462 unsigned char hash[66];
00463 unsigned char sig[200];
00464 size_t sig_len, i;
00465
00466 ecdsa_init( &ctx );
00467 memset( &rnd_info, 0x00, sizeof( rnd_pseudo_info ) );
00468 memset( hash, 0, sizeof( hash ) );
00469 memset( sig, 0x2a, sizeof( sig ) );
00470
00471
00472 TEST_ASSERT( rnd_pseudo_rand( &rnd_info, hash, sizeof( hash ) ) == 0 );
00473
00474
00475 TEST_ASSERT( ecdsa_genkey( &ctx, id, &rnd_pseudo_rand, &rnd_info ) == 0 );
00476
00477
00478 TEST_ASSERT( ecdsa_write_signature( &ctx, hash, sizeof( hash ),
00479 sig, &sig_len, &rnd_pseudo_rand, &rnd_info ) == 0 );
00480 TEST_ASSERT( ecdsa_read_signature( &ctx, hash, sizeof( hash ),
00481 sig, sig_len ) == 0 );
00482
00483
00484 for( i = sig_len; i < sizeof( sig ); i++ )
00485 TEST_ASSERT( sig[i] == 0x2a );
00486
00487
00488 TEST_ASSERT( ecdsa_read_signature( &ctx, hash, sizeof( hash ),
00489 sig, sig_len - 1 ) != 0 );
00490 TEST_ASSERT( ecdsa_read_signature( &ctx, hash, sizeof( hash ),
00491 sig, sig_len + 1 ) != 0 );
00492
00493
00494 sig[0]++;
00495 TEST_ASSERT( ecdsa_read_signature( &ctx, hash, sizeof( hash ),
00496 sig, sig_len ) != 0 );
00497 sig[0]--;
00498
00499
00500 sig[10]++;
00501 TEST_ASSERT( ecdsa_read_signature( &ctx, hash, sizeof( hash ),
00502 sig, sig_len ) != 0 );
00503 sig[10]--;
00504
00505
00506 sig[sig_len - 1]++;
00507 TEST_ASSERT( ecdsa_read_signature( &ctx, hash, sizeof( hash ),
00508 sig, sig_len ) != 0 );
00509 sig[sig_len - 1]--;
00510
00511 ecdsa_free( &ctx );
00512 }
00513
00514
00515 #endif
00516
00517
00518 int dep_check( char *str )
00519 {
00520 if( str == NULL )
00521 return( 1 );
00522
00523 if( strcmp( str, "POLARSSL_ECP_DP_SECP384R1_ENABLED" ) == 0 )
00524 {
00525 #if defined(POLARSSL_ECP_DP_SECP384R1_ENABLED)
00526 return( 0 );
00527 #else
00528 return( 1 );
00529 #endif
00530 }
00531 if( strcmp( str, "POLARSSL_ECP_DP_SECP192R1_ENABLED" ) == 0 )
00532 {
00533 #if defined(POLARSSL_ECP_DP_SECP192R1_ENABLED)
00534 return( 0 );
00535 #else
00536 return( 1 );
00537 #endif
00538 }
00539 if( strcmp( str, "POLARSSL_ECP_DP_SECP521R1_ENABLED" ) == 0 )
00540 {
00541 #if defined(POLARSSL_ECP_DP_SECP521R1_ENABLED)
00542 return( 0 );
00543 #else
00544 return( 1 );
00545 #endif
00546 }
00547 if( strcmp( str, "POLARSSL_ECP_DP_SECP224R1_ENABLED" ) == 0 )
00548 {
00549 #if defined(POLARSSL_ECP_DP_SECP224R1_ENABLED)
00550 return( 0 );
00551 #else
00552 return( 1 );
00553 #endif
00554 }
00555 if( strcmp( str, "POLARSSL_ECP_DP_SECP256R1_ENABLED" ) == 0 )
00556 {
00557 #if defined(POLARSSL_ECP_DP_SECP256R1_ENABLED)
00558 return( 0 );
00559 #else
00560 return( 1 );
00561 #endif
00562 }
00563
00564
00565 return( 1 );
00566 }
00567
00568 int dispatch_test(int cnt, char *params[50])
00569 {
00570 int ret;
00571 ((void) cnt);
00572 ((void) params);
00573
00574 #if defined(TEST_SUITE_ACTIVE)
00575 if( strcmp( params[0], "ecdsa_prim_random" ) == 0 )
00576 {
00577
00578 int param1;
00579
00580 if( cnt != 2 )
00581 {
00582 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 2 );
00583 return( 2 );
00584 }
00585
00586 if( verify_int( params[1], ¶m1 ) != 0 ) return( 2 );
00587
00588 test_suite_ecdsa_prim_random( param1 );
00589 return ( 0 );
00590
00591 return ( 3 );
00592 }
00593 else
00594 if( strcmp( params[0], "ecdsa_prim_test_vectors" ) == 0 )
00595 {
00596
00597 int param1;
00598 char *param2 = params[2];
00599 char *param3 = params[3];
00600 char *param4 = params[4];
00601 char *param5 = params[5];
00602 char *param6 = params[6];
00603 char *param7 = params[7];
00604 char *param8 = params[8];
00605
00606 if( cnt != 9 )
00607 {
00608 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 9 );
00609 return( 2 );
00610 }
00611
00612 if( verify_int( params[1], ¶m1 ) != 0 ) return( 2 );
00613 if( verify_string( ¶m2 ) != 0 ) return( 2 );
00614 if( verify_string( ¶m3 ) != 0 ) return( 2 );
00615 if( verify_string( ¶m4 ) != 0 ) return( 2 );
00616 if( verify_string( ¶m5 ) != 0 ) return( 2 );
00617 if( verify_string( ¶m6 ) != 0 ) return( 2 );
00618 if( verify_string( ¶m7 ) != 0 ) return( 2 );
00619 if( verify_string( ¶m8 ) != 0 ) return( 2 );
00620
00621 test_suite_ecdsa_prim_test_vectors( param1, param2, param3, param4, param5, param6, param7, param8 );
00622 return ( 0 );
00623
00624 return ( 3 );
00625 }
00626 else
00627 if( strcmp( params[0], "ecdsa_write_read_random" ) == 0 )
00628 {
00629
00630 int param1;
00631
00632 if( cnt != 2 )
00633 {
00634 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 2 );
00635 return( 2 );
00636 }
00637
00638 if( verify_int( params[1], ¶m1 ) != 0 ) return( 2 );
00639
00640 test_suite_ecdsa_write_read_random( param1 );
00641 return ( 0 );
00642
00643 return ( 3 );
00644 }
00645 else
00646
00647 {
00648 fprintf( stdout, "FAILED\nSkipping unknown test function '%s'\n", params[0] );
00649 fflush( stdout );
00650 return( 1 );
00651 }
00652 #else
00653 return( 3 );
00654 #endif
00655 return( ret );
00656 }
00657
00658 int get_line( FILE *f, char *buf, size_t len )
00659 {
00660 char *ret;
00661
00662 ret = fgets( buf, len, f );
00663 if( ret == NULL )
00664 return( -1 );
00665
00666 if( strlen( buf ) && buf[strlen(buf) - 1] == '\n' )
00667 buf[strlen(buf) - 1] = '\0';
00668 if( strlen( buf ) && buf[strlen(buf) - 1] == '\r' )
00669 buf[strlen(buf) - 1] = '\0';
00670
00671 return( 0 );
00672 }
00673
00674 int parse_arguments( char *buf, size_t len, char *params[50] )
00675 {
00676 int cnt = 0, i;
00677 char *cur = buf;
00678 char *p = buf, *q;
00679
00680 params[cnt++] = cur;
00681
00682 while( *p != '\0' && p < buf + len )
00683 {
00684 if( *p == '\\' )
00685 {
00686 *p++;
00687 *p++;
00688 continue;
00689 }
00690 if( *p == ':' )
00691 {
00692 if( p + 1 < buf + len )
00693 {
00694 cur = p + 1;
00695 params[cnt++] = cur;
00696 }
00697 *p = '\0';
00698 }
00699
00700 *p++;
00701 }
00702
00703
00704 for( i = 0; i < cnt; i++ )
00705 {
00706 p = params[i];
00707 q = params[i];
00708
00709 while( *p != '\0' )
00710 {
00711 if( *p == '\\' && *(p + 1) == 'n' )
00712 {
00713 p += 2;
00714 *(q++) = '\n';
00715 }
00716 else if( *p == '\\' && *(p + 1) == ':' )
00717 {
00718 p += 2;
00719 *(q++) = ':';
00720 }
00721 else if( *p == '\\' && *(p + 1) == '?' )
00722 {
00723 p += 2;
00724 *(q++) = '?';
00725 }
00726 else
00727 *(q++) = *(p++);
00728 }
00729 *q = '\0';
00730 }
00731
00732 return( cnt );
00733 }
00734
00735 int main()
00736 {
00737 int ret, i, cnt, total_errors = 0, total_tests = 0, total_skipped = 0;
00738 const char *filename = "/home/abuild/rpmbuild/BUILD/polarssl-1.3.2/tests/suites/test_suite_ecdsa.data";
00739 FILE *file;
00740 char buf[5000];
00741 char *params[50];
00742
00743 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
00744 unsigned char alloc_buf[1000000];
00745 memory_buffer_alloc_init( alloc_buf, sizeof(alloc_buf) );
00746 #endif
00747
00748 file = fopen( filename, "r" );
00749 if( file == NULL )
00750 {
00751 fprintf( stderr, "Failed to open\n" );
00752 return( 1 );
00753 }
00754
00755 while( !feof( file ) )
00756 {
00757 int skip = 0;
00758
00759 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
00760 break;
00761 fprintf( stdout, "%s%.66s", test_errors ? "\n" : "", buf );
00762 fprintf( stdout, " " );
00763 for( i = strlen( buf ) + 1; i < 67; i++ )
00764 fprintf( stdout, "." );
00765 fprintf( stdout, " " );
00766 fflush( stdout );
00767
00768 total_tests++;
00769
00770 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
00771 break;
00772 cnt = parse_arguments( buf, strlen(buf), params );
00773
00774 if( strcmp( params[0], "depends_on" ) == 0 )
00775 {
00776 for( i = 1; i < cnt; i++ )
00777 if( dep_check( params[i] ) != 0 )
00778 skip = 1;
00779
00780 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
00781 break;
00782 cnt = parse_arguments( buf, strlen(buf), params );
00783 }
00784
00785 if( skip == 0 )
00786 {
00787 test_errors = 0;
00788 ret = dispatch_test( cnt, params );
00789 }
00790
00791 if( skip == 1 || ret == 3 )
00792 {
00793 total_skipped++;
00794 fprintf( stdout, "----\n" );
00795 fflush( stdout );
00796 }
00797 else if( ret == 0 && test_errors == 0 )
00798 {
00799 fprintf( stdout, "PASS\n" );
00800 fflush( stdout );
00801 }
00802 else if( ret == 2 )
00803 {
00804 fprintf( stderr, "FAILED: FATAL PARSE ERROR\n" );
00805 fclose(file);
00806 exit( 2 );
00807 }
00808 else
00809 total_errors++;
00810
00811 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
00812 break;
00813 if( strlen(buf) != 0 )
00814 {
00815 fprintf( stderr, "Should be empty %d\n", (int) strlen(buf) );
00816 return( 1 );
00817 }
00818 }
00819 fclose(file);
00820
00821 fprintf( stdout, "\n----------------------------------------------------------------------------\n\n");
00822 if( total_errors == 0 )
00823 fprintf( stdout, "PASSED" );
00824 else
00825 fprintf( stdout, "FAILED" );
00826
00827 fprintf( stdout, " (%d / %d tests (%d skipped))\n",
00828 total_tests - total_errors, total_tests, total_skipped );
00829
00830 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
00831 #if defined(POLARSSL_MEMORY_DEBUG)
00832 memory_buffer_alloc_status();
00833 #endif
00834 memory_buffer_alloc_free();
00835 #endif
00836
00837 return( total_errors != 0 );
00838 }
00839
00840