00001 #include <polarssl/config.h>
00002
00003 #ifdef POLARSSL_PK_C
00004
00005 #include <polarssl/pk.h>
00006
00007 static int rnd_std_rand( void *rng_state, unsigned char *output, size_t len );
00008
00009 static int pk_genkey( pk_context *pk )
00010 {
00011 #if defined(POLARSSL_RSA_C)
00012 if( pk_get_type( pk ) == POLARSSL_PK_RSA )
00013 return rsa_gen_key( pk_rsa( *pk ), rnd_std_rand, NULL, 512, 3 );
00014 #endif
00015 #if defined(POLARSSL_ECP_C)
00016 if( pk_get_type( pk ) == POLARSSL_PK_ECKEY ||
00017 pk_get_type( pk ) == POLARSSL_PK_ECKEY_DH ||
00018 pk_get_type( pk ) == POLARSSL_PK_ECDSA )
00019 {
00020 int ret;
00021 if( ( ret = ecp_use_known_dp( &pk_ec( *pk )->grp,
00022 POLARSSL_ECP_DP_SECP192R1 ) ) != 0 )
00023 return( ret );
00024
00025 return ecp_gen_keypair( &pk_ec( *pk )->grp, &pk_ec( *pk )->d,
00026 &pk_ec( *pk )->Q, rnd_std_rand, NULL );
00027 }
00028 #endif
00029 return( -1 );
00030 }
00031 #endif
00032
00033
00034 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
00035 #include "polarssl/memory.h"
00036 #endif
00037
00038 #if defined(WANT_NOT_RND_MPI)
00039 #if defined(POLARSSL_BIGNUM_C)
00040 #include "polarssl/bignum.h"
00041 #else
00042 #error "not_rnd_mpi() need bignum.c"
00043 #endif
00044 #endif
00045
00046 #ifdef _MSC_VER
00047 #include <basetsd.h>
00048 typedef UINT32 uint32_t;
00049 #else
00050 #include <inttypes.h>
00051 #endif
00052
00053 #include <assert.h>
00054 #include <stdlib.h>
00055 #include <string.h>
00056
00057
00058
00059
00060 #ifndef GET_UINT32_BE
00061 #define GET_UINT32_BE(n,b,i) \
00062 { \
00063 (n) = ( (uint32_t) (b)[(i) ] << 24 ) \
00064 | ( (uint32_t) (b)[(i) + 1] << 16 ) \
00065 | ( (uint32_t) (b)[(i) + 2] << 8 ) \
00066 | ( (uint32_t) (b)[(i) + 3] ); \
00067 }
00068 #endif
00069
00070 #ifndef PUT_UINT32_BE
00071 #define PUT_UINT32_BE(n,b,i) \
00072 { \
00073 (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
00074 (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
00075 (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
00076 (b)[(i) + 3] = (unsigned char) ( (n) ); \
00077 }
00078 #endif
00079
00080 static int unhexify(unsigned char *obuf, const char *ibuf)
00081 {
00082 unsigned char c, c2;
00083 int len = strlen(ibuf) / 2;
00084 assert(!(strlen(ibuf) %1));
00085
00086 while (*ibuf != 0)
00087 {
00088 c = *ibuf++;
00089 if( c >= '0' && c <= '9' )
00090 c -= '0';
00091 else if( c >= 'a' && c <= 'f' )
00092 c -= 'a' - 10;
00093 else if( c >= 'A' && c <= 'F' )
00094 c -= 'A' - 10;
00095 else
00096 assert( 0 );
00097
00098 c2 = *ibuf++;
00099 if( c2 >= '0' && c2 <= '9' )
00100 c2 -= '0';
00101 else if( c2 >= 'a' && c2 <= 'f' )
00102 c2 -= 'a' - 10;
00103 else if( c2 >= 'A' && c2 <= 'F' )
00104 c2 -= 'A' - 10;
00105 else
00106 assert( 0 );
00107
00108 *obuf++ = ( c << 4 ) | c2;
00109 }
00110
00111 return len;
00112 }
00113
00114 static void hexify(unsigned char *obuf, const unsigned char *ibuf, int len)
00115 {
00116 unsigned char l, h;
00117
00118 while (len != 0)
00119 {
00120 h = (*ibuf) / 16;
00121 l = (*ibuf) % 16;
00122
00123 if( h < 10 )
00124 *obuf++ = '0' + h;
00125 else
00126 *obuf++ = 'a' + h - 10;
00127
00128 if( l < 10 )
00129 *obuf++ = '0' + l;
00130 else
00131 *obuf++ = 'a' + l - 10;
00132
00133 ++ibuf;
00134 len--;
00135 }
00136 }
00137
00147 static int rnd_std_rand( void *rng_state, unsigned char *output, size_t len )
00148 {
00149 size_t i;
00150
00151 if( rng_state != NULL )
00152 rng_state = NULL;
00153
00154 for( i = 0; i < len; ++i )
00155 output[i] = rand();
00156
00157 return( 0 );
00158 }
00159
00165 static int rnd_zero_rand( void *rng_state, unsigned char *output, size_t len )
00166 {
00167 if( rng_state != NULL )
00168 rng_state = NULL;
00169
00170 memset( output, 0, len );
00171
00172 return( 0 );
00173 }
00174
00175 typedef struct
00176 {
00177 unsigned char *buf;
00178 size_t length;
00179 } rnd_buf_info;
00180
00192 static int rnd_buffer_rand( void *rng_state, unsigned char *output, size_t len )
00193 {
00194 rnd_buf_info *info = (rnd_buf_info *) rng_state;
00195 size_t use_len;
00196
00197 if( rng_state == NULL )
00198 return( rnd_std_rand( NULL, output, len ) );
00199
00200 use_len = len;
00201 if( len > info->length )
00202 use_len = info->length;
00203
00204 if( use_len )
00205 {
00206 memcpy( output, info->buf, use_len );
00207 info->buf += use_len;
00208 info->length -= use_len;
00209 }
00210
00211 if( len - use_len > 0 )
00212 return( rnd_std_rand( NULL, output + use_len, len - use_len ) );
00213
00214 return( 0 );
00215 }
00216
00224 typedef struct
00225 {
00226 uint32_t key[16];
00227 uint32_t v0, v1;
00228 } rnd_pseudo_info;
00229
00238 static int rnd_pseudo_rand( void *rng_state, unsigned char *output, size_t len )
00239 {
00240 rnd_pseudo_info *info = (rnd_pseudo_info *) rng_state;
00241 uint32_t i, *k, sum, delta=0x9E3779B9;
00242 unsigned char result[4];
00243
00244 if( rng_state == NULL )
00245 return( rnd_std_rand( NULL, output, len ) );
00246
00247 k = info->key;
00248
00249 while( len > 0 )
00250 {
00251 size_t use_len = ( len > 4 ) ? 4 : len;
00252 sum = 0;
00253
00254 for( i = 0; i < 32; i++ )
00255 {
00256 info->v0 += (((info->v1 << 4) ^ (info->v1 >> 5)) + info->v1) ^ (sum + k[sum & 3]);
00257 sum += delta;
00258 info->v1 += (((info->v0 << 4) ^ (info->v0 >> 5)) + info->v0) ^ (sum + k[(sum>>11) & 3]);
00259 }
00260
00261 PUT_UINT32_BE( info->v0, result, 0 );
00262 memcpy( output, result, use_len );
00263 len -= use_len;
00264 }
00265
00266 return( 0 );
00267 }
00268
00269 #if defined(WANT_NOT_RND_MPI)
00270
00278 #define ciL (sizeof(t_uint))
00279 #define CHARS_TO_LIMBS(i) (((i) + ciL - 1) / ciL)
00280 static int not_rnd_mpi( void *in, unsigned char *out, size_t len )
00281 {
00282 char *str = (char *) in;
00283 mpi X;
00284
00285
00286
00287
00288
00289 X.s = 1;
00290 X.p = (t_uint *) out;
00291 X.n = CHARS_TO_LIMBS( len );
00292
00293
00294
00295
00296
00297 assert( strlen( str ) / 2 == len );
00298
00299 return( mpi_read_string( &X, 16, str ) );
00300 }
00301 #endif
00302
00303
00304 #include <stdio.h>
00305 #include <string.h>
00306
00307 static int test_errors = 0;
00308
00309 #ifdef POLARSSL_PK_C
00310
00311 #define TEST_SUITE_ACTIVE
00312
00313 static int test_assert( int correct, char *test )
00314 {
00315 if( correct )
00316 return( 0 );
00317
00318 test_errors++;
00319 if( test_errors == 1 )
00320 printf( "FAILED\n" );
00321 printf( " %s\n", test );
00322
00323 return( 1 );
00324 }
00325
00326 #define TEST_ASSERT( TEST ) \
00327 do { test_assert( (TEST) ? 1 : 0, #TEST ); \
00328 if( test_errors) return; \
00329 } while (0)
00330
00331 int verify_string( char **str )
00332 {
00333 if( (*str)[0] != '"' ||
00334 (*str)[strlen( *str ) - 1] != '"' )
00335 {
00336 printf( "Expected string (with \"\") for parameter and got: %s\n", *str );
00337 return( -1 );
00338 }
00339
00340 (*str)++;
00341 (*str)[strlen( *str ) - 1] = '\0';
00342
00343 return( 0 );
00344 }
00345
00346 int verify_int( char *str, int *value )
00347 {
00348 size_t i;
00349 int minus = 0;
00350 int digits = 1;
00351 int hex = 0;
00352
00353 for( i = 0; i < strlen( str ); i++ )
00354 {
00355 if( i == 0 && str[i] == '-' )
00356 {
00357 minus = 1;
00358 continue;
00359 }
00360
00361 if( ( ( minus && i == 2 ) || ( !minus && i == 1 ) ) &&
00362 str[i - 1] == '0' && str[i] == 'x' )
00363 {
00364 hex = 1;
00365 continue;
00366 }
00367
00368 if( str[i] < '0' || str[i] > '9' )
00369 {
00370 digits = 0;
00371 break;
00372 }
00373 }
00374
00375 if( digits )
00376 {
00377 if( hex )
00378 *value = strtol( str, NULL, 16 );
00379 else
00380 *value = strtol( str, NULL, 10 );
00381
00382 return( 0 );
00383 }
00384
00385 if( strcmp( str, "POLARSSL_PK_ECKEY" ) == 0 )
00386 {
00387 *value = ( POLARSSL_PK_ECKEY );
00388 return( 0 );
00389 }
00390 #ifdef POLARSSL_ECDSA_C
00391 if( strcmp( str, "POLARSSL_ECP_DP_SECP192R1" ) == 0 )
00392 {
00393 *value = ( POLARSSL_ECP_DP_SECP192R1 );
00394 return( 0 );
00395 }
00396 #endif // POLARSSL_ECDSA_C
00397 #ifdef POLARSSL_RSA_C
00398 if( strcmp( str, "POLARSSL_ERR_RSA_VERIFY_FAILED" ) == 0 )
00399 {
00400 *value = ( POLARSSL_ERR_RSA_VERIFY_FAILED );
00401 return( 0 );
00402 }
00403 #endif // POLARSSL_RSA_C
00404 #ifdef POLARSSL_RSA_C
00405 if( strcmp( str, "POLARSSL_ERR_RSA_INVALID_PADDING" ) == 0 )
00406 {
00407 *value = ( POLARSSL_ERR_RSA_INVALID_PADDING );
00408 return( 0 );
00409 }
00410 #endif // POLARSSL_RSA_C
00411 if( strcmp( str, "POLARSSL_PK_RSA" ) == 0 )
00412 {
00413 *value = ( POLARSSL_PK_RSA );
00414 return( 0 );
00415 }
00416 #ifdef POLARSSL_ECDSA_C
00417 if( strcmp( str, "POLARSSL_ERR_ECP_VERIFY_FAILED" ) == 0 )
00418 {
00419 *value = ( POLARSSL_ERR_ECP_VERIFY_FAILED );
00420 return( 0 );
00421 }
00422 #endif // POLARSSL_ECDSA_C
00423 if( strcmp( str, "POLARSSL_PK_ECKEY_DH" ) == 0 )
00424 {
00425 *value = ( POLARSSL_PK_ECKEY_DH );
00426 return( 0 );
00427 }
00428 if( strcmp( str, "POLARSSL_ERR_PK_TYPE_MISMATCH" ) == 0 )
00429 {
00430 *value = ( POLARSSL_ERR_PK_TYPE_MISMATCH );
00431 return( 0 );
00432 }
00433 if( strcmp( str, "POLARSSL_PK_ECDSA" ) == 0 )
00434 {
00435 *value = ( POLARSSL_PK_ECDSA );
00436 return( 0 );
00437 }
00438 #ifdef POLARSSL_RSA_C
00439 if( strcmp( str, "POLARSSL_MD_SHA1" ) == 0 )
00440 {
00441 *value = ( POLARSSL_MD_SHA1 );
00442 return( 0 );
00443 }
00444 #endif // POLARSSL_RSA_C
00445
00446
00447 printf( "Expected integer for parameter and got: %s\n", str );
00448 return( -1 );
00449 }
00450
00451 void test_suite_pk_utils( int type, int size, int len, char *name )
00452 {
00453 pk_context pk;
00454
00455 pk_init( &pk );
00456
00457 TEST_ASSERT( pk_init_ctx( &pk, pk_info_from_type( type ) ) == 0 );
00458 TEST_ASSERT( pk_genkey( &pk ) == 0 );
00459
00460 TEST_ASSERT( (int) pk_get_type( &pk ) == type );
00461 TEST_ASSERT( pk_can_do( &pk, type ) );
00462 TEST_ASSERT( pk_get_size( &pk ) == (unsigned) size );
00463 TEST_ASSERT( pk_get_len( &pk ) == (unsigned) len );
00464 TEST_ASSERT( strcmp( pk_get_name( &pk), name ) == 0 );
00465
00466 pk_free( &pk );
00467 }
00468
00469 #ifdef POLARSSL_RSA_C
00470 void test_suite_pk_rsa_verify_test_vec( char *message_hex_string, int digest,
00471 int mod, int radix_N, char *input_N, int radix_E,
00472 char *input_E, char *result_hex_str, int result )
00473 {
00474 unsigned char message_str[1000];
00475 unsigned char hash_result[1000];
00476 unsigned char result_str[1000];
00477 rsa_context *rsa;
00478 pk_context pk;
00479 int msg_len;
00480
00481 pk_init( &pk );
00482
00483 memset( message_str, 0x00, 1000 );
00484 memset( hash_result, 0x00, 1000 );
00485 memset( result_str, 0x00, 1000 );
00486
00487 TEST_ASSERT( pk_init_ctx( &pk, pk_info_from_type( POLARSSL_PK_RSA ) ) == 0 );
00488 rsa = pk_rsa( pk );
00489
00490 rsa->len = mod / 8;
00491 TEST_ASSERT( mpi_read_string( &rsa->N, radix_N, input_N ) == 0 );
00492 TEST_ASSERT( mpi_read_string( &rsa->E, radix_E, input_E ) == 0 );
00493
00494 msg_len = unhexify( message_str, message_hex_string );
00495 unhexify( result_str, result_hex_str );
00496
00497 if( md_info_from_type( digest ) != NULL )
00498 TEST_ASSERT( md( md_info_from_type( digest ), message_str, msg_len, hash_result ) == 0 );
00499
00500 TEST_ASSERT( pk_verify( &pk, digest, hash_result, 0,
00501 result_str, pk_get_len( &pk ) ) == result );
00502
00503 pk_free( &pk );
00504 }
00505 #endif
00506
00507 #ifdef POLARSSL_ECDSA_C
00508 void test_suite_pk_ec_test_vec( int type, int id, char *key_str,
00509 char *hash_str, char * sig_str, int ret )
00510 {
00511 pk_context pk;
00512 ecp_keypair *eckey;
00513 unsigned char hash[100], sig[500], key[500];
00514 size_t hash_len, sig_len, key_len;
00515
00516 pk_init( &pk );
00517
00518 memset( hash, 0, sizeof( hash ) ); hash_len = unhexify(hash, hash_str);
00519 memset( sig, 0, sizeof( sig ) ); sig_len = unhexify(sig, sig_str);
00520 memset( key, 0, sizeof( key ) ); key_len = unhexify(key, key_str);
00521
00522 TEST_ASSERT( pk_init_ctx( &pk, pk_info_from_type( type ) ) == 0 );
00523
00524 TEST_ASSERT( pk_can_do( &pk, POLARSSL_PK_ECDSA ) );
00525 eckey = pk_ec( pk );
00526
00527 TEST_ASSERT( ecp_use_known_dp( &eckey->grp, id ) == 0 );
00528 TEST_ASSERT( ecp_point_read_binary( &eckey->grp, &eckey->Q,
00529 key, key_len ) == 0 );
00530
00531 TEST_ASSERT( pk_verify( &pk, POLARSSL_MD_NONE,
00532 hash, hash_len, sig, sig_len ) == ret );
00533
00534 pk_free( &pk );
00535 }
00536 #endif
00537
00538 void test_suite_pk_sign_verify( int type, int sign_ret, int verify_ret )
00539 {
00540 pk_context pk;
00541 unsigned char hash[50], sig[5000];
00542 size_t sig_len;
00543
00544 pk_init( &pk );
00545
00546 memset( hash, 0x2a, sizeof hash );
00547 memset( sig, 0, sizeof sig );
00548
00549 TEST_ASSERT( pk_init_ctx( &pk, pk_info_from_type( type ) ) == 0 );
00550 TEST_ASSERT( pk_genkey( &pk ) == 0 );
00551
00552 TEST_ASSERT( pk_sign( &pk, POLARSSL_MD_NONE, hash, sizeof hash,
00553 sig, &sig_len, rnd_std_rand, NULL ) == sign_ret );
00554
00555 TEST_ASSERT( pk_verify( &pk, POLARSSL_MD_NONE,
00556 hash, sizeof hash, sig, sig_len ) == verify_ret );
00557
00558 pk_free( &pk );
00559 }
00560
00561 #ifdef POLARSSL_RSA_C
00562 void test_suite_pk_rsa_encrypt_test_vec( char *message_hex, int mod,
00563 int radix_N, char *input_N,
00564 int radix_E, char *input_E,
00565 char *result_hex, int ret )
00566 {
00567 unsigned char message[1000];
00568 unsigned char output[1000];
00569 unsigned char result[1000];
00570 size_t msg_len, olen, res_len;
00571 rnd_pseudo_info rnd_info;
00572 rsa_context *rsa;
00573 pk_context pk;
00574
00575 memset( &rnd_info, 0, sizeof( rnd_pseudo_info ) );
00576 memset( message, 0, sizeof( message ) );
00577 memset( output, 0, sizeof( output ) );
00578 memset( result, 0, sizeof( result ) );
00579
00580 msg_len = unhexify( message, message_hex );
00581 res_len = unhexify( result, result_hex );
00582
00583 pk_init( &pk );
00584 TEST_ASSERT( pk_init_ctx( &pk, pk_info_from_type( POLARSSL_PK_RSA ) ) == 0 );
00585 rsa = pk_rsa( pk );
00586
00587 rsa->len = mod / 8;
00588 TEST_ASSERT( mpi_read_string( &rsa->N, radix_N, input_N ) == 0 );
00589 TEST_ASSERT( mpi_read_string( &rsa->E, radix_E, input_E ) == 0 );
00590
00591 TEST_ASSERT( pk_encrypt( &pk, message, msg_len,
00592 output, &olen, sizeof( output ),
00593 rnd_pseudo_rand, &rnd_info ) == ret );
00594 TEST_ASSERT( olen == res_len );
00595 TEST_ASSERT( memcmp( output, result, olen ) == 0 );
00596
00597 pk_free( &pk );
00598 }
00599 #endif
00600
00601 #ifdef POLARSSL_RSA_C
00602 void test_suite_pk_rsa_decrypt_test_vec( char *cipher_hex, int mod,
00603 int radix_P, char *input_P,
00604 int radix_Q, char *input_Q,
00605 int radix_N, char *input_N,
00606 int radix_E, char *input_E,
00607 char *clear_hex, int ret )
00608 {
00609 unsigned char clear[1000];
00610 unsigned char output[1000];
00611 unsigned char cipher[1000];
00612 size_t clear_len, olen, cipher_len;
00613 rnd_pseudo_info rnd_info;
00614 mpi P1, Q1, H, G;
00615 rsa_context *rsa;
00616 pk_context pk;
00617
00618 pk_init( &pk );
00619 mpi_init( &P1 ); mpi_init( &Q1 ); mpi_init( &H ); mpi_init( &G );
00620
00621 memset( &rnd_info, 0, sizeof( rnd_pseudo_info ) );
00622 memset( clear, 0, sizeof( clear ) );
00623 memset( cipher, 0, sizeof( cipher ) );
00624
00625 clear_len = unhexify( clear, clear_hex );
00626 cipher_len = unhexify( cipher, cipher_hex );
00627
00628
00629 TEST_ASSERT( pk_init_ctx( &pk, pk_info_from_type( POLARSSL_PK_RSA ) ) == 0 );
00630 rsa = pk_rsa( pk );
00631
00632
00633 rsa->len = mod / 8;
00634 TEST_ASSERT( mpi_read_string( &rsa->N, radix_N, input_N ) == 0 );
00635 TEST_ASSERT( mpi_read_string( &rsa->E, radix_E, input_E ) == 0 );
00636
00637
00638 TEST_ASSERT( mpi_read_string( &rsa->P, radix_P, input_P ) == 0 );
00639 TEST_ASSERT( mpi_read_string( &rsa->Q, radix_Q, input_Q ) == 0 );
00640 TEST_ASSERT( mpi_sub_int( &P1, &rsa->P, 1 ) == 0 );
00641 TEST_ASSERT( mpi_sub_int( &Q1, &rsa->Q, 1 ) == 0 );
00642 TEST_ASSERT( mpi_mul_mpi( &H, &P1, &Q1 ) == 0 );
00643 TEST_ASSERT( mpi_gcd( &G, &rsa->E, &H ) == 0 );
00644 TEST_ASSERT( mpi_inv_mod( &rsa->D , &rsa->E, &H ) == 0 );
00645 TEST_ASSERT( mpi_mod_mpi( &rsa->DP, &rsa->D, &P1 ) == 0 );
00646 TEST_ASSERT( mpi_mod_mpi( &rsa->DQ, &rsa->D, &Q1 ) == 0 );
00647 TEST_ASSERT( mpi_inv_mod( &rsa->QP, &rsa->Q, &rsa->P ) == 0 );
00648
00649
00650 memset( output, 0, sizeof( output ) );
00651 olen = 0;
00652 TEST_ASSERT( pk_decrypt( &pk, cipher, cipher_len,
00653 output, &olen, sizeof( output ),
00654 rnd_pseudo_rand, &rnd_info ) == ret );
00655 if( ret == 0 )
00656 {
00657 TEST_ASSERT( olen == clear_len );
00658 TEST_ASSERT( memcmp( output, clear, olen ) == 0 );
00659 }
00660
00661 mpi_free( &P1 ); mpi_free( &Q1 ); mpi_free( &H ); mpi_free( &G );
00662 pk_free( &pk );
00663 }
00664 #endif
00665
00666 void test_suite_pk_ec_nocrypt( int type )
00667 {
00668 pk_context pk;
00669 unsigned char output[100];
00670 unsigned char input[100];
00671 rnd_pseudo_info rnd_info;
00672 size_t olen = 0;
00673 int ret = POLARSSL_ERR_PK_TYPE_MISMATCH;
00674
00675 pk_init( &pk );
00676
00677 memset( &rnd_info, 0, sizeof( rnd_pseudo_info ) );
00678 memset( output, 0, sizeof( output ) );
00679 memset( input, 0, sizeof( input ) );
00680
00681 TEST_ASSERT( pk_init_ctx( &pk, pk_info_from_type( type ) ) == 0 );
00682
00683 TEST_ASSERT( pk_encrypt( &pk, input, sizeof( input ),
00684 output, &olen, sizeof( output ),
00685 rnd_pseudo_rand, &rnd_info ) == ret );
00686
00687 TEST_ASSERT( pk_decrypt( &pk, input, sizeof( input ),
00688 output, &olen, sizeof( output ),
00689 rnd_pseudo_rand, &rnd_info ) == ret );
00690
00691 pk_free( &pk );
00692 }
00693
00694
00695 #endif
00696
00697
00698 int dep_check( char *str )
00699 {
00700 if( str == NULL )
00701 return( 1 );
00702
00703 if( strcmp( str, "POLARSSL_SHA1_C" ) == 0 )
00704 {
00705 #if defined(POLARSSL_SHA1_C)
00706 return( 0 );
00707 #else
00708 return( 1 );
00709 #endif
00710 }
00711 if( strcmp( str, "POLARSSL_ECDSA_C" ) == 0 )
00712 {
00713 #if defined(POLARSSL_ECDSA_C)
00714 return( 0 );
00715 #else
00716 return( 1 );
00717 #endif
00718 }
00719 if( strcmp( str, "POLARSSL_ECP_DP_SECP192R1_ENABLED" ) == 0 )
00720 {
00721 #if defined(POLARSSL_ECP_DP_SECP192R1_ENABLED)
00722 return( 0 );
00723 #else
00724 return( 1 );
00725 #endif
00726 }
00727 if( strcmp( str, "POLARSSL_PKCS1_V15" ) == 0 )
00728 {
00729 #if defined(POLARSSL_PKCS1_V15)
00730 return( 0 );
00731 #else
00732 return( 1 );
00733 #endif
00734 }
00735 if( strcmp( str, "POLARSSL_ECP_C" ) == 0 )
00736 {
00737 #if defined(POLARSSL_ECP_C)
00738 return( 0 );
00739 #else
00740 return( 1 );
00741 #endif
00742 }
00743 if( strcmp( str, "POLARSSL_RSA_C" ) == 0 )
00744 {
00745 #if defined(POLARSSL_RSA_C)
00746 return( 0 );
00747 #else
00748 return( 1 );
00749 #endif
00750 }
00751
00752
00753 return( 1 );
00754 }
00755
00756 int dispatch_test(int cnt, char *params[50])
00757 {
00758 int ret;
00759 ((void) cnt);
00760 ((void) params);
00761
00762 #if defined(TEST_SUITE_ACTIVE)
00763 if( strcmp( params[0], "pk_utils" ) == 0 )
00764 {
00765
00766 int param1;
00767 int param2;
00768 int param3;
00769 char *param4 = params[4];
00770
00771 if( cnt != 5 )
00772 {
00773 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 5 );
00774 return( 2 );
00775 }
00776
00777 if( verify_int( params[1], ¶m1 ) != 0 ) return( 2 );
00778 if( verify_int( params[2], ¶m2 ) != 0 ) return( 2 );
00779 if( verify_int( params[3], ¶m3 ) != 0 ) return( 2 );
00780 if( verify_string( ¶m4 ) != 0 ) return( 2 );
00781
00782 test_suite_pk_utils( param1, param2, param3, param4 );
00783 return ( 0 );
00784
00785 return ( 3 );
00786 }
00787 else
00788 if( strcmp( params[0], "pk_rsa_verify_test_vec" ) == 0 )
00789 {
00790 #ifdef POLARSSL_RSA_C
00791
00792 char *param1 = params[1];
00793 int param2;
00794 int param3;
00795 int param4;
00796 char *param5 = params[5];
00797 int param6;
00798 char *param7 = params[7];
00799 char *param8 = params[8];
00800 int param9;
00801
00802 if( cnt != 10 )
00803 {
00804 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 10 );
00805 return( 2 );
00806 }
00807
00808 if( verify_string( ¶m1 ) != 0 ) return( 2 );
00809 if( verify_int( params[2], ¶m2 ) != 0 ) return( 2 );
00810 if( verify_int( params[3], ¶m3 ) != 0 ) return( 2 );
00811 if( verify_int( params[4], ¶m4 ) != 0 ) return( 2 );
00812 if( verify_string( ¶m5 ) != 0 ) return( 2 );
00813 if( verify_int( params[6], ¶m6 ) != 0 ) return( 2 );
00814 if( verify_string( ¶m7 ) != 0 ) return( 2 );
00815 if( verify_string( ¶m8 ) != 0 ) return( 2 );
00816 if( verify_int( params[9], ¶m9 ) != 0 ) return( 2 );
00817
00818 test_suite_pk_rsa_verify_test_vec( param1, param2, param3, param4, param5, param6, param7, param8, param9 );
00819 return ( 0 );
00820 #endif
00821
00822 return ( 3 );
00823 }
00824 else
00825 if( strcmp( params[0], "pk_ec_test_vec" ) == 0 )
00826 {
00827 #ifdef POLARSSL_ECDSA_C
00828
00829 int param1;
00830 int param2;
00831 char *param3 = params[3];
00832 char *param4 = params[4];
00833 char *param5 = params[5];
00834 int param6;
00835
00836 if( cnt != 7 )
00837 {
00838 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 7 );
00839 return( 2 );
00840 }
00841
00842 if( verify_int( params[1], ¶m1 ) != 0 ) return( 2 );
00843 if( verify_int( params[2], ¶m2 ) != 0 ) return( 2 );
00844 if( verify_string( ¶m3 ) != 0 ) return( 2 );
00845 if( verify_string( ¶m4 ) != 0 ) return( 2 );
00846 if( verify_string( ¶m5 ) != 0 ) return( 2 );
00847 if( verify_int( params[6], ¶m6 ) != 0 ) return( 2 );
00848
00849 test_suite_pk_ec_test_vec( param1, param2, param3, param4, param5, param6 );
00850 return ( 0 );
00851 #endif
00852
00853 return ( 3 );
00854 }
00855 else
00856 if( strcmp( params[0], "pk_sign_verify" ) == 0 )
00857 {
00858
00859 int param1;
00860 int param2;
00861 int param3;
00862
00863 if( cnt != 4 )
00864 {
00865 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
00866 return( 2 );
00867 }
00868
00869 if( verify_int( params[1], ¶m1 ) != 0 ) return( 2 );
00870 if( verify_int( params[2], ¶m2 ) != 0 ) return( 2 );
00871 if( verify_int( params[3], ¶m3 ) != 0 ) return( 2 );
00872
00873 test_suite_pk_sign_verify( param1, param2, param3 );
00874 return ( 0 );
00875
00876 return ( 3 );
00877 }
00878 else
00879 if( strcmp( params[0], "pk_rsa_encrypt_test_vec" ) == 0 )
00880 {
00881 #ifdef POLARSSL_RSA_C
00882
00883 char *param1 = params[1];
00884 int param2;
00885 int param3;
00886 char *param4 = params[4];
00887 int param5;
00888 char *param6 = params[6];
00889 char *param7 = params[7];
00890 int param8;
00891
00892 if( cnt != 9 )
00893 {
00894 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 9 );
00895 return( 2 );
00896 }
00897
00898 if( verify_string( ¶m1 ) != 0 ) return( 2 );
00899 if( verify_int( params[2], ¶m2 ) != 0 ) return( 2 );
00900 if( verify_int( params[3], ¶m3 ) != 0 ) return( 2 );
00901 if( verify_string( ¶m4 ) != 0 ) return( 2 );
00902 if( verify_int( params[5], ¶m5 ) != 0 ) return( 2 );
00903 if( verify_string( ¶m6 ) != 0 ) return( 2 );
00904 if( verify_string( ¶m7 ) != 0 ) return( 2 );
00905 if( verify_int( params[8], ¶m8 ) != 0 ) return( 2 );
00906
00907 test_suite_pk_rsa_encrypt_test_vec( param1, param2, param3, param4, param5, param6, param7, param8 );
00908 return ( 0 );
00909 #endif
00910
00911 return ( 3 );
00912 }
00913 else
00914 if( strcmp( params[0], "pk_rsa_decrypt_test_vec" ) == 0 )
00915 {
00916 #ifdef POLARSSL_RSA_C
00917
00918 char *param1 = params[1];
00919 int param2;
00920 int param3;
00921 char *param4 = params[4];
00922 int param5;
00923 char *param6 = params[6];
00924 int param7;
00925 char *param8 = params[8];
00926 int param9;
00927 char *param10 = params[10];
00928 char *param11 = params[11];
00929 int param12;
00930
00931 if( cnt != 13 )
00932 {
00933 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 13 );
00934 return( 2 );
00935 }
00936
00937 if( verify_string( ¶m1 ) != 0 ) return( 2 );
00938 if( verify_int( params[2], ¶m2 ) != 0 ) return( 2 );
00939 if( verify_int( params[3], ¶m3 ) != 0 ) return( 2 );
00940 if( verify_string( ¶m4 ) != 0 ) return( 2 );
00941 if( verify_int( params[5], ¶m5 ) != 0 ) return( 2 );
00942 if( verify_string( ¶m6 ) != 0 ) return( 2 );
00943 if( verify_int( params[7], ¶m7 ) != 0 ) return( 2 );
00944 if( verify_string( ¶m8 ) != 0 ) return( 2 );
00945 if( verify_int( params[9], ¶m9 ) != 0 ) return( 2 );
00946 if( verify_string( ¶m10 ) != 0 ) return( 2 );
00947 if( verify_string( ¶m11 ) != 0 ) return( 2 );
00948 if( verify_int( params[12], ¶m12 ) != 0 ) return( 2 );
00949
00950 test_suite_pk_rsa_decrypt_test_vec( param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12 );
00951 return ( 0 );
00952 #endif
00953
00954 return ( 3 );
00955 }
00956 else
00957 if( strcmp( params[0], "pk_ec_nocrypt" ) == 0 )
00958 {
00959
00960 int param1;
00961
00962 if( cnt != 2 )
00963 {
00964 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 2 );
00965 return( 2 );
00966 }
00967
00968 if( verify_int( params[1], ¶m1 ) != 0 ) return( 2 );
00969
00970 test_suite_pk_ec_nocrypt( param1 );
00971 return ( 0 );
00972
00973 return ( 3 );
00974 }
00975 else
00976
00977 {
00978 fprintf( stdout, "FAILED\nSkipping unknown test function '%s'\n", params[0] );
00979 fflush( stdout );
00980 return( 1 );
00981 }
00982 #else
00983 return( 3 );
00984 #endif
00985 return( ret );
00986 }
00987
00988 int get_line( FILE *f, char *buf, size_t len )
00989 {
00990 char *ret;
00991
00992 ret = fgets( buf, len, f );
00993 if( ret == NULL )
00994 return( -1 );
00995
00996 if( strlen( buf ) && buf[strlen(buf) - 1] == '\n' )
00997 buf[strlen(buf) - 1] = '\0';
00998 if( strlen( buf ) && buf[strlen(buf) - 1] == '\r' )
00999 buf[strlen(buf) - 1] = '\0';
01000
01001 return( 0 );
01002 }
01003
01004 int parse_arguments( char *buf, size_t len, char *params[50] )
01005 {
01006 int cnt = 0, i;
01007 char *cur = buf;
01008 char *p = buf, *q;
01009
01010 params[cnt++] = cur;
01011
01012 while( *p != '\0' && p < buf + len )
01013 {
01014 if( *p == '\\' )
01015 {
01016 *p++;
01017 *p++;
01018 continue;
01019 }
01020 if( *p == ':' )
01021 {
01022 if( p + 1 < buf + len )
01023 {
01024 cur = p + 1;
01025 params[cnt++] = cur;
01026 }
01027 *p = '\0';
01028 }
01029
01030 *p++;
01031 }
01032
01033
01034 for( i = 0; i < cnt; i++ )
01035 {
01036 p = params[i];
01037 q = params[i];
01038
01039 while( *p != '\0' )
01040 {
01041 if( *p == '\\' && *(p + 1) == 'n' )
01042 {
01043 p += 2;
01044 *(q++) = '\n';
01045 }
01046 else if( *p == '\\' && *(p + 1) == ':' )
01047 {
01048 p += 2;
01049 *(q++) = ':';
01050 }
01051 else if( *p == '\\' && *(p + 1) == '?' )
01052 {
01053 p += 2;
01054 *(q++) = '?';
01055 }
01056 else
01057 *(q++) = *(p++);
01058 }
01059 *q = '\0';
01060 }
01061
01062 return( cnt );
01063 }
01064
01065 int main()
01066 {
01067 int ret, i, cnt, total_errors = 0, total_tests = 0, total_skipped = 0;
01068 const char *filename = "/home/abuild/rpmbuild/BUILD/polarssl-1.3.2/tests/suites/test_suite_pk.data";
01069 FILE *file;
01070 char buf[5000];
01071 char *params[50];
01072
01073 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
01074 unsigned char alloc_buf[1000000];
01075 memory_buffer_alloc_init( alloc_buf, sizeof(alloc_buf) );
01076 #endif
01077
01078 file = fopen( filename, "r" );
01079 if( file == NULL )
01080 {
01081 fprintf( stderr, "Failed to open\n" );
01082 return( 1 );
01083 }
01084
01085 while( !feof( file ) )
01086 {
01087 int skip = 0;
01088
01089 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
01090 break;
01091 fprintf( stdout, "%s%.66s", test_errors ? "\n" : "", buf );
01092 fprintf( stdout, " " );
01093 for( i = strlen( buf ) + 1; i < 67; i++ )
01094 fprintf( stdout, "." );
01095 fprintf( stdout, " " );
01096 fflush( stdout );
01097
01098 total_tests++;
01099
01100 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
01101 break;
01102 cnt = parse_arguments( buf, strlen(buf), params );
01103
01104 if( strcmp( params[0], "depends_on" ) == 0 )
01105 {
01106 for( i = 1; i < cnt; i++ )
01107 if( dep_check( params[i] ) != 0 )
01108 skip = 1;
01109
01110 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
01111 break;
01112 cnt = parse_arguments( buf, strlen(buf), params );
01113 }
01114
01115 if( skip == 0 )
01116 {
01117 test_errors = 0;
01118 ret = dispatch_test( cnt, params );
01119 }
01120
01121 if( skip == 1 || ret == 3 )
01122 {
01123 total_skipped++;
01124 fprintf( stdout, "----\n" );
01125 fflush( stdout );
01126 }
01127 else if( ret == 0 && test_errors == 0 )
01128 {
01129 fprintf( stdout, "PASS\n" );
01130 fflush( stdout );
01131 }
01132 else if( ret == 2 )
01133 {
01134 fprintf( stderr, "FAILED: FATAL PARSE ERROR\n" );
01135 fclose(file);
01136 exit( 2 );
01137 }
01138 else
01139 total_errors++;
01140
01141 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
01142 break;
01143 if( strlen(buf) != 0 )
01144 {
01145 fprintf( stderr, "Should be empty %d\n", (int) strlen(buf) );
01146 return( 1 );
01147 }
01148 }
01149 fclose(file);
01150
01151 fprintf( stdout, "\n----------------------------------------------------------------------------\n\n");
01152 if( total_errors == 0 )
01153 fprintf( stdout, "PASSED" );
01154 else
01155 fprintf( stdout, "FAILED" );
01156
01157 fprintf( stdout, " (%d / %d tests (%d skipped))\n",
01158 total_tests - total_errors, total_tests, total_skipped );
01159
01160 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
01161 #if defined(POLARSSL_MEMORY_DEBUG)
01162 memory_buffer_alloc_status();
01163 #endif
01164 memory_buffer_alloc_free();
01165 #endif
01166
01167 return( total_errors != 0 );
01168 }
01169
01170