00001 #include <polarssl/config.h>
00002
00003 #ifdef POLARSSL_RSA_C
00004 #ifdef POLARSSL_BIGNUM_C
00005 #ifdef POLARSSL_GENPRIME
00006
00007 #include <polarssl/rsa.h>
00008 #include <polarssl/md2.h>
00009 #include <polarssl/md4.h>
00010 #include <polarssl/md5.h>
00011 #include <polarssl/sha1.h>
00012 #include <polarssl/sha256.h>
00013 #include <polarssl/sha512.h>
00014 #include <polarssl/entropy.h>
00015 #include <polarssl/ctr_drbg.h>
00016 #endif
00017 #endif
00018 #endif
00019
00020
00021 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
00022 #include "polarssl/memory.h"
00023 #endif
00024
00025 #if defined(WANT_NOT_RND_MPI)
00026 #if defined(POLARSSL_BIGNUM_C)
00027 #include "polarssl/bignum.h"
00028 #else
00029 #error "not_rnd_mpi() need bignum.c"
00030 #endif
00031 #endif
00032
00033 #ifdef _MSC_VER
00034 #include <basetsd.h>
00035 typedef UINT32 uint32_t;
00036 #else
00037 #include <inttypes.h>
00038 #endif
00039
00040 #include <assert.h>
00041 #include <stdlib.h>
00042 #include <string.h>
00043
00044
00045
00046
00047 #ifndef GET_UINT32_BE
00048 #define GET_UINT32_BE(n,b,i) \
00049 { \
00050 (n) = ( (uint32_t) (b)[(i) ] << 24 ) \
00051 | ( (uint32_t) (b)[(i) + 1] << 16 ) \
00052 | ( (uint32_t) (b)[(i) + 2] << 8 ) \
00053 | ( (uint32_t) (b)[(i) + 3] ); \
00054 }
00055 #endif
00056
00057 #ifndef PUT_UINT32_BE
00058 #define PUT_UINT32_BE(n,b,i) \
00059 { \
00060 (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
00061 (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
00062 (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
00063 (b)[(i) + 3] = (unsigned char) ( (n) ); \
00064 }
00065 #endif
00066
00067 static int unhexify(unsigned char *obuf, const char *ibuf)
00068 {
00069 unsigned char c, c2;
00070 int len = strlen(ibuf) / 2;
00071 assert(!(strlen(ibuf) %1));
00072
00073 while (*ibuf != 0)
00074 {
00075 c = *ibuf++;
00076 if( c >= '0' && c <= '9' )
00077 c -= '0';
00078 else if( c >= 'a' && c <= 'f' )
00079 c -= 'a' - 10;
00080 else if( c >= 'A' && c <= 'F' )
00081 c -= 'A' - 10;
00082 else
00083 assert( 0 );
00084
00085 c2 = *ibuf++;
00086 if( c2 >= '0' && c2 <= '9' )
00087 c2 -= '0';
00088 else if( c2 >= 'a' && c2 <= 'f' )
00089 c2 -= 'a' - 10;
00090 else if( c2 >= 'A' && c2 <= 'F' )
00091 c2 -= 'A' - 10;
00092 else
00093 assert( 0 );
00094
00095 *obuf++ = ( c << 4 ) | c2;
00096 }
00097
00098 return len;
00099 }
00100
00101 static void hexify(unsigned char *obuf, const unsigned char *ibuf, int len)
00102 {
00103 unsigned char l, h;
00104
00105 while (len != 0)
00106 {
00107 h = (*ibuf) / 16;
00108 l = (*ibuf) % 16;
00109
00110 if( h < 10 )
00111 *obuf++ = '0' + h;
00112 else
00113 *obuf++ = 'a' + h - 10;
00114
00115 if( l < 10 )
00116 *obuf++ = '0' + l;
00117 else
00118 *obuf++ = 'a' + l - 10;
00119
00120 ++ibuf;
00121 len--;
00122 }
00123 }
00124
00134 static int rnd_std_rand( void *rng_state, unsigned char *output, size_t len )
00135 {
00136 size_t i;
00137
00138 if( rng_state != NULL )
00139 rng_state = NULL;
00140
00141 for( i = 0; i < len; ++i )
00142 output[i] = rand();
00143
00144 return( 0 );
00145 }
00146
00152 static int rnd_zero_rand( void *rng_state, unsigned char *output, size_t len )
00153 {
00154 if( rng_state != NULL )
00155 rng_state = NULL;
00156
00157 memset( output, 0, len );
00158
00159 return( 0 );
00160 }
00161
00162 typedef struct
00163 {
00164 unsigned char *buf;
00165 size_t length;
00166 } rnd_buf_info;
00167
00179 static int rnd_buffer_rand( void *rng_state, unsigned char *output, size_t len )
00180 {
00181 rnd_buf_info *info = (rnd_buf_info *) rng_state;
00182 size_t use_len;
00183
00184 if( rng_state == NULL )
00185 return( rnd_std_rand( NULL, output, len ) );
00186
00187 use_len = len;
00188 if( len > info->length )
00189 use_len = info->length;
00190
00191 if( use_len )
00192 {
00193 memcpy( output, info->buf, use_len );
00194 info->buf += use_len;
00195 info->length -= use_len;
00196 }
00197
00198 if( len - use_len > 0 )
00199 return( rnd_std_rand( NULL, output + use_len, len - use_len ) );
00200
00201 return( 0 );
00202 }
00203
00211 typedef struct
00212 {
00213 uint32_t key[16];
00214 uint32_t v0, v1;
00215 } rnd_pseudo_info;
00216
00225 static int rnd_pseudo_rand( void *rng_state, unsigned char *output, size_t len )
00226 {
00227 rnd_pseudo_info *info = (rnd_pseudo_info *) rng_state;
00228 uint32_t i, *k, sum, delta=0x9E3779B9;
00229 unsigned char result[4];
00230
00231 if( rng_state == NULL )
00232 return( rnd_std_rand( NULL, output, len ) );
00233
00234 k = info->key;
00235
00236 while( len > 0 )
00237 {
00238 size_t use_len = ( len > 4 ) ? 4 : len;
00239 sum = 0;
00240
00241 for( i = 0; i < 32; i++ )
00242 {
00243 info->v0 += (((info->v1 << 4) ^ (info->v1 >> 5)) + info->v1) ^ (sum + k[sum & 3]);
00244 sum += delta;
00245 info->v1 += (((info->v0 << 4) ^ (info->v0 >> 5)) + info->v0) ^ (sum + k[(sum>>11) & 3]);
00246 }
00247
00248 PUT_UINT32_BE( info->v0, result, 0 );
00249 memcpy( output, result, use_len );
00250 len -= use_len;
00251 }
00252
00253 return( 0 );
00254 }
00255
00256 #if defined(WANT_NOT_RND_MPI)
00257
00265 #define ciL (sizeof(t_uint))
00266 #define CHARS_TO_LIMBS(i) (((i) + ciL - 1) / ciL)
00267 static int not_rnd_mpi( void *in, unsigned char *out, size_t len )
00268 {
00269 char *str = (char *) in;
00270 mpi X;
00271
00272
00273
00274
00275
00276 X.s = 1;
00277 X.p = (t_uint *) out;
00278 X.n = CHARS_TO_LIMBS( len );
00279
00280
00281
00282
00283
00284 assert( strlen( str ) / 2 == len );
00285
00286 return( mpi_read_string( &X, 16, str ) );
00287 }
00288 #endif
00289
00290
00291 #include <stdio.h>
00292 #include <string.h>
00293
00294 static int test_errors = 0;
00295
00296 #ifdef POLARSSL_RSA_C
00297 #ifdef POLARSSL_BIGNUM_C
00298 #ifdef POLARSSL_GENPRIME
00299
00300 #define TEST_SUITE_ACTIVE
00301
00302 static int test_assert( int correct, char *test )
00303 {
00304 if( correct )
00305 return( 0 );
00306
00307 test_errors++;
00308 if( test_errors == 1 )
00309 printf( "FAILED\n" );
00310 printf( " %s\n", test );
00311
00312 return( 1 );
00313 }
00314
00315 #define TEST_ASSERT( TEST ) \
00316 do { test_assert( (TEST) ? 1 : 0, #TEST ); \
00317 if( test_errors) return; \
00318 } while (0)
00319
00320 int verify_string( char **str )
00321 {
00322 if( (*str)[0] != '"' ||
00323 (*str)[strlen( *str ) - 1] != '"' )
00324 {
00325 printf( "Expected string (with \"\") for parameter and got: %s\n", *str );
00326 return( -1 );
00327 }
00328
00329 (*str)++;
00330 (*str)[strlen( *str ) - 1] = '\0';
00331
00332 return( 0 );
00333 }
00334
00335 int verify_int( char *str, int *value )
00336 {
00337 size_t i;
00338 int minus = 0;
00339 int digits = 1;
00340 int hex = 0;
00341
00342 for( i = 0; i < strlen( str ); i++ )
00343 {
00344 if( i == 0 && str[i] == '-' )
00345 {
00346 minus = 1;
00347 continue;
00348 }
00349
00350 if( ( ( minus && i == 2 ) || ( !minus && i == 1 ) ) &&
00351 str[i - 1] == '0' && str[i] == 'x' )
00352 {
00353 hex = 1;
00354 continue;
00355 }
00356
00357 if( str[i] < '0' || str[i] > '9' )
00358 {
00359 digits = 0;
00360 break;
00361 }
00362 }
00363
00364 if( digits )
00365 {
00366 if( hex )
00367 *value = strtol( str, NULL, 16 );
00368 else
00369 *value = strtol( str, NULL, 10 );
00370
00371 return( 0 );
00372 }
00373
00374 if( strcmp( str, "POLARSSL_ERR_RSA_OUTPUT_TOO_LARGE" ) == 0 )
00375 {
00376 *value = ( POLARSSL_ERR_RSA_OUTPUT_TOO_LARGE );
00377 return( 0 );
00378 }
00379 if( strcmp( str, "POLARSSL_MD_MD4" ) == 0 )
00380 {
00381 *value = ( POLARSSL_MD_MD4 );
00382 return( 0 );
00383 }
00384 if( strcmp( str, "POLARSSL_MD_SHA256" ) == 0 )
00385 {
00386 *value = ( POLARSSL_MD_SHA256 );
00387 return( 0 );
00388 }
00389 if( strcmp( str, "POLARSSL_MD_SHA512" ) == 0 )
00390 {
00391 *value = ( POLARSSL_MD_SHA512 );
00392 return( 0 );
00393 }
00394 if( strcmp( str, "POLARSSL_ERR_RSA_VERIFY_FAILED" ) == 0 )
00395 {
00396 *value = ( POLARSSL_ERR_RSA_VERIFY_FAILED );
00397 return( 0 );
00398 }
00399 if( strcmp( str, "POLARSSL_ERR_RSA_INVALID_PADDING" ) == 0 )
00400 {
00401 *value = ( POLARSSL_ERR_RSA_INVALID_PADDING );
00402 return( 0 );
00403 }
00404 if( strcmp( str, "POLARSSL_MD_SHA224" ) == 0 )
00405 {
00406 *value = ( POLARSSL_MD_SHA224 );
00407 return( 0 );
00408 }
00409 if( strcmp( str, "POLARSSL_MD_MD5" ) == 0 )
00410 {
00411 *value = ( POLARSSL_MD_MD5 );
00412 return( 0 );
00413 }
00414 if( strcmp( str, "POLARSSL_MD_MD2" ) == 0 )
00415 {
00416 *value = ( POLARSSL_MD_MD2 );
00417 return( 0 );
00418 }
00419 if( strcmp( str, "POLARSSL_ERR_RSA_KEY_CHECK_FAILED" ) == 0 )
00420 {
00421 *value = ( POLARSSL_ERR_RSA_KEY_CHECK_FAILED );
00422 return( 0 );
00423 }
00424 if( strcmp( str, "RSA_PKCS_V15" ) == 0 )
00425 {
00426 *value = ( RSA_PKCS_V15 );
00427 return( 0 );
00428 }
00429 if( strcmp( str, "POLARSSL_ERR_RSA_BAD_INPUT_DATA" ) == 0 )
00430 {
00431 *value = ( POLARSSL_ERR_RSA_BAD_INPUT_DATA );
00432 return( 0 );
00433 }
00434 if( strcmp( str, "POLARSSL_ERR_RSA_RNG_FAILED" ) == 0 )
00435 {
00436 *value = ( POLARSSL_ERR_RSA_RNG_FAILED );
00437 return( 0 );
00438 }
00439 if( strcmp( str, "POLARSSL_MD_SHA1" ) == 0 )
00440 {
00441 *value = ( POLARSSL_MD_SHA1 );
00442 return( 0 );
00443 }
00444 if( strcmp( str, "POLARSSL_MD_SHA384" ) == 0 )
00445 {
00446 *value = ( POLARSSL_MD_SHA384 );
00447 return( 0 );
00448 }
00449
00450
00451 printf( "Expected integer for parameter and got: %s\n", str );
00452 return( -1 );
00453 }
00454
00455 void test_suite_rsa_pkcs1_sign( char *message_hex_string, int padding_mode, int digest,
00456 int mod, int radix_P, char *input_P, int radix_Q,
00457 char *input_Q, int radix_N, char *input_N, int radix_E,
00458 char *input_E, char *result_hex_str, int result )
00459 {
00460 unsigned char message_str[1000];
00461 unsigned char hash_result[1000];
00462 unsigned char output[1000];
00463 unsigned char output_str[1000];
00464 rsa_context ctx;
00465 mpi P1, Q1, H, G;
00466 int msg_len;
00467 rnd_pseudo_info rnd_info;
00468
00469 mpi_init( &P1 ); mpi_init( &Q1 ); mpi_init( &H ); mpi_init( &G );
00470 rsa_init( &ctx, padding_mode, 0 );
00471
00472 memset( message_str, 0x00, 1000 );
00473 memset( hash_result, 0x00, 1000 );
00474 memset( output, 0x00, 1000 );
00475 memset( output_str, 0x00, 1000 );
00476 memset( &rnd_info, 0, sizeof( rnd_pseudo_info ) );
00477
00478 ctx.len = mod / 8;
00479 TEST_ASSERT( mpi_read_string( &ctx.P, radix_P, input_P ) == 0 );
00480 TEST_ASSERT( mpi_read_string( &ctx.Q, radix_Q, input_Q ) == 0 );
00481 TEST_ASSERT( mpi_read_string( &ctx.N, radix_N, input_N ) == 0 );
00482 TEST_ASSERT( mpi_read_string( &ctx.E, radix_E, input_E ) == 0 );
00483
00484 TEST_ASSERT( mpi_sub_int( &P1, &ctx.P, 1 ) == 0 );
00485 TEST_ASSERT( mpi_sub_int( &Q1, &ctx.Q, 1 ) == 0 );
00486 TEST_ASSERT( mpi_mul_mpi( &H, &P1, &Q1 ) == 0 );
00487 TEST_ASSERT( mpi_gcd( &G, &ctx.E, &H ) == 0 );
00488 TEST_ASSERT( mpi_inv_mod( &ctx.D , &ctx.E, &H ) == 0 );
00489 TEST_ASSERT( mpi_mod_mpi( &ctx.DP, &ctx.D, &P1 ) == 0 );
00490 TEST_ASSERT( mpi_mod_mpi( &ctx.DQ, &ctx.D, &Q1 ) == 0 );
00491 TEST_ASSERT( mpi_inv_mod( &ctx.QP, &ctx.Q, &ctx.P ) == 0 );
00492
00493 TEST_ASSERT( rsa_check_privkey( &ctx ) == 0 );
00494
00495 msg_len = unhexify( message_str, message_hex_string );
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( rsa_pkcs1_sign( &ctx, &rnd_pseudo_rand, &rnd_info, RSA_PRIVATE, digest, 0, hash_result, output ) == result );
00501 if( result == 0 )
00502 {
00503 hexify( output_str, output, ctx.len );
00504
00505 TEST_ASSERT( strcasecmp( (char *) output_str, result_hex_str ) == 0 );
00506 }
00507
00508 mpi_free( &P1 ); mpi_free( &Q1 ); mpi_free( &H ); mpi_free( &G );
00509 rsa_free( &ctx );
00510 }
00511
00512 void test_suite_rsa_pkcs1_verify( char *message_hex_string, int padding_mode, int digest,
00513 int mod, int radix_N, char *input_N, int radix_E,
00514 char *input_E, char *result_hex_str, int result )
00515 {
00516 unsigned char message_str[1000];
00517 unsigned char hash_result[1000];
00518 unsigned char result_str[1000];
00519 rsa_context ctx;
00520 int msg_len;
00521
00522 rsa_init( &ctx, padding_mode, 0 );
00523 memset( message_str, 0x00, 1000 );
00524 memset( hash_result, 0x00, 1000 );
00525 memset( result_str, 0x00, 1000 );
00526
00527 ctx.len = mod / 8;
00528 TEST_ASSERT( mpi_read_string( &ctx.N, radix_N, input_N ) == 0 );
00529 TEST_ASSERT( mpi_read_string( &ctx.E, radix_E, input_E ) == 0 );
00530
00531 TEST_ASSERT( rsa_check_pubkey( &ctx ) == 0 );
00532
00533 msg_len = unhexify( message_str, message_hex_string );
00534 unhexify( result_str, result_hex_str );
00535
00536 if( md_info_from_type( digest ) != NULL )
00537 TEST_ASSERT( md( md_info_from_type( digest ), message_str, msg_len, hash_result ) == 0 );
00538
00539 TEST_ASSERT( rsa_pkcs1_verify( &ctx, NULL, NULL, RSA_PUBLIC, digest, 0, hash_result, result_str ) == result );
00540
00541 rsa_free( &ctx );
00542 }
00543
00544 void test_suite_rsa_pkcs1_sign_raw( char *message_hex_string, char *hash_result_string,
00545 int padding_mode, int mod, int radix_P, char *input_P,
00546 int radix_Q, char *input_Q, int radix_N,
00547 char *input_N, int radix_E, char *input_E,
00548 char *result_hex_str )
00549 {
00550 unsigned char message_str[1000];
00551 unsigned char hash_result[1000];
00552 unsigned char output[1000];
00553 unsigned char output_str[1000];
00554 rsa_context ctx;
00555 mpi P1, Q1, H, G;
00556 int hash_len;
00557 rnd_pseudo_info rnd_info;
00558
00559 mpi_init( &P1 ); mpi_init( &Q1 ); mpi_init( &H ); mpi_init( &G );
00560 rsa_init( &ctx, padding_mode, 0 );
00561
00562 memset( message_str, 0x00, 1000 );
00563 memset( hash_result, 0x00, 1000 );
00564 memset( output, 0x00, 1000 );
00565 memset( output_str, 0x00, 1000 );
00566 memset( &rnd_info, 0, sizeof( rnd_pseudo_info ) );
00567
00568 ctx.len = mod / 8;
00569 TEST_ASSERT( mpi_read_string( &ctx.P, radix_P, input_P ) == 0 );
00570 TEST_ASSERT( mpi_read_string( &ctx.Q, radix_Q, input_Q ) == 0 );
00571 TEST_ASSERT( mpi_read_string( &ctx.N, radix_N, input_N ) == 0 );
00572 TEST_ASSERT( mpi_read_string( &ctx.E, radix_E, input_E ) == 0 );
00573
00574 TEST_ASSERT( mpi_sub_int( &P1, &ctx.P, 1 ) == 0 );
00575 TEST_ASSERT( mpi_sub_int( &Q1, &ctx.Q, 1 ) == 0 );
00576 TEST_ASSERT( mpi_mul_mpi( &H, &P1, &Q1 ) == 0 );
00577 TEST_ASSERT( mpi_gcd( &G, &ctx.E, &H ) == 0 );
00578 TEST_ASSERT( mpi_inv_mod( &ctx.D , &ctx.E, &H ) == 0 );
00579 TEST_ASSERT( mpi_mod_mpi( &ctx.DP, &ctx.D, &P1 ) == 0 );
00580 TEST_ASSERT( mpi_mod_mpi( &ctx.DQ, &ctx.D, &Q1 ) == 0 );
00581 TEST_ASSERT( mpi_inv_mod( &ctx.QP, &ctx.Q, &ctx.P ) == 0 );
00582
00583 TEST_ASSERT( rsa_check_privkey( &ctx ) == 0 );
00584
00585 unhexify( message_str, message_hex_string );
00586 hash_len = unhexify( hash_result, hash_result_string );
00587
00588 TEST_ASSERT( rsa_pkcs1_sign( &ctx, &rnd_pseudo_rand, &rnd_info, RSA_PRIVATE, POLARSSL_MD_NONE, hash_len, hash_result, output ) == 0 );
00589
00590 hexify( output_str, output, ctx.len );
00591
00592 TEST_ASSERT( strcasecmp( (char *) output_str, result_hex_str ) == 0 );
00593
00594 mpi_free( &P1 ); mpi_free( &Q1 ); mpi_free( &H ); mpi_free( &G );
00595 rsa_free( &ctx );
00596 }
00597
00598 void test_suite_rsa_pkcs1_verify_raw( char *message_hex_string, char *hash_result_string,
00599 int padding_mode, int mod, int radix_N,
00600 char *input_N, int radix_E, char *input_E,
00601 char *result_hex_str, int correct )
00602 {
00603 unsigned char message_str[1000];
00604 unsigned char hash_result[1000];
00605 unsigned char result_str[1000];
00606 rsa_context ctx;
00607 size_t hash_len;
00608
00609 rsa_init( &ctx, padding_mode, 0 );
00610 memset( message_str, 0x00, 1000 );
00611 memset( hash_result, 0x00, 1000 );
00612 memset( result_str, 0x00, 1000 );
00613
00614 ctx.len = mod / 8;
00615 TEST_ASSERT( mpi_read_string( &ctx.N, radix_N, input_N ) == 0 );
00616 TEST_ASSERT( mpi_read_string( &ctx.E, radix_E, input_E ) == 0 );
00617
00618 TEST_ASSERT( rsa_check_pubkey( &ctx ) == 0 );
00619
00620 unhexify( message_str, message_hex_string );
00621 hash_len = unhexify( hash_result, hash_result_string );
00622 unhexify( result_str, result_hex_str );
00623
00624 TEST_ASSERT( rsa_pkcs1_verify( &ctx, NULL, NULL, RSA_PUBLIC, POLARSSL_MD_NONE, hash_len, hash_result, result_str ) == correct );
00625
00626 rsa_free( &ctx );
00627 }
00628
00629 void test_suite_rsa_pkcs1_encrypt( char *message_hex_string, int padding_mode, int mod,
00630 int radix_N, char *input_N, int radix_E, char *input_E,
00631 char *result_hex_str, int result )
00632 {
00633 unsigned char message_str[1000];
00634 unsigned char output[1000];
00635 unsigned char output_str[1000];
00636 rsa_context ctx;
00637 size_t msg_len;
00638 rnd_pseudo_info rnd_info;
00639
00640 memset( &rnd_info, 0, sizeof( rnd_pseudo_info ) );
00641
00642 rsa_init( &ctx, padding_mode, 0 );
00643 memset( message_str, 0x00, 1000 );
00644 memset( output, 0x00, 1000 );
00645 memset( output_str, 0x00, 1000 );
00646
00647 ctx.len = mod / 8;
00648 TEST_ASSERT( mpi_read_string( &ctx.N, radix_N, input_N ) == 0 );
00649 TEST_ASSERT( mpi_read_string( &ctx.E, radix_E, input_E ) == 0 );
00650
00651 TEST_ASSERT( rsa_check_pubkey( &ctx ) == 0 );
00652
00653 msg_len = unhexify( message_str, message_hex_string );
00654
00655 TEST_ASSERT( rsa_pkcs1_encrypt( &ctx, &rnd_pseudo_rand, &rnd_info, RSA_PUBLIC, msg_len, message_str, output ) == result );
00656 if( result == 0 )
00657 {
00658 hexify( output_str, output, ctx.len );
00659
00660 TEST_ASSERT( strcasecmp( (char *) output_str, result_hex_str ) == 0 );
00661 }
00662
00663 rsa_free( &ctx );
00664 }
00665
00666 void test_suite_rsa_pkcs1_encrypt_bad_rng( char *message_hex_string, int padding_mode,
00667 int mod, int radix_N, char *input_N,
00668 int radix_E, char *input_E,
00669 char *result_hex_str, int result )
00670 {
00671 unsigned char message_str[1000];
00672 unsigned char output[1000];
00673 unsigned char output_str[1000];
00674 rsa_context ctx;
00675 size_t msg_len;
00676
00677 rsa_init( &ctx, padding_mode, 0 );
00678 memset( message_str, 0x00, 1000 );
00679 memset( output, 0x00, 1000 );
00680 memset( output_str, 0x00, 1000 );
00681
00682 ctx.len = mod / 8;
00683 TEST_ASSERT( mpi_read_string( &ctx.N, radix_N, input_N ) == 0 );
00684 TEST_ASSERT( mpi_read_string( &ctx.E, radix_E, input_E ) == 0 );
00685
00686 TEST_ASSERT( rsa_check_pubkey( &ctx ) == 0 );
00687
00688 msg_len = unhexify( message_str, message_hex_string );
00689
00690 TEST_ASSERT( rsa_pkcs1_encrypt( &ctx, &rnd_zero_rand, NULL, RSA_PUBLIC, msg_len, message_str, output ) == result );
00691 if( result == 0 )
00692 {
00693 hexify( output_str, output, ctx.len );
00694
00695 TEST_ASSERT( strcasecmp( (char *) output_str, result_hex_str ) == 0 );
00696 }
00697
00698 rsa_free( &ctx );
00699 }
00700
00701 void test_suite_rsa_pkcs1_decrypt( char *message_hex_string, int padding_mode, int mod,
00702 int radix_P, char *input_P, int radix_Q, char *input_Q,
00703 int radix_N, char *input_N, int radix_E, char *input_E,
00704 int max_output, char *result_hex_str, int result )
00705 {
00706 unsigned char message_str[1000];
00707 unsigned char output[1000];
00708 unsigned char output_str[1000];
00709 rsa_context ctx;
00710 mpi P1, Q1, H, G;
00711 size_t output_len;
00712 rnd_pseudo_info rnd_info;
00713
00714 mpi_init( &P1 ); mpi_init( &Q1 ); mpi_init( &H ); mpi_init( &G );
00715 rsa_init( &ctx, padding_mode, 0 );
00716
00717 memset( message_str, 0x00, 1000 );
00718 memset( output, 0x00, 1000 );
00719 memset( output_str, 0x00, 1000 );
00720 memset( &rnd_info, 0, sizeof( rnd_pseudo_info ) );
00721
00722 ctx.len = mod / 8;
00723 TEST_ASSERT( mpi_read_string( &ctx.P, radix_P, input_P ) == 0 );
00724 TEST_ASSERT( mpi_read_string( &ctx.Q, radix_Q, input_Q ) == 0 );
00725 TEST_ASSERT( mpi_read_string( &ctx.N, radix_N, input_N ) == 0 );
00726 TEST_ASSERT( mpi_read_string( &ctx.E, radix_E, input_E ) == 0 );
00727
00728 TEST_ASSERT( mpi_sub_int( &P1, &ctx.P, 1 ) == 0 );
00729 TEST_ASSERT( mpi_sub_int( &Q1, &ctx.Q, 1 ) == 0 );
00730 TEST_ASSERT( mpi_mul_mpi( &H, &P1, &Q1 ) == 0 );
00731 TEST_ASSERT( mpi_gcd( &G, &ctx.E, &H ) == 0 );
00732 TEST_ASSERT( mpi_inv_mod( &ctx.D , &ctx.E, &H ) == 0 );
00733 TEST_ASSERT( mpi_mod_mpi( &ctx.DP, &ctx.D, &P1 ) == 0 );
00734 TEST_ASSERT( mpi_mod_mpi( &ctx.DQ, &ctx.D, &Q1 ) == 0 );
00735 TEST_ASSERT( mpi_inv_mod( &ctx.QP, &ctx.Q, &ctx.P ) == 0 );
00736
00737 TEST_ASSERT( rsa_check_privkey( &ctx ) == 0 );
00738
00739 unhexify( message_str, message_hex_string );
00740 output_len = 0;
00741
00742 TEST_ASSERT( rsa_pkcs1_decrypt( &ctx, rnd_pseudo_rand, &rnd_info, RSA_PRIVATE, &output_len, message_str, output, max_output ) == result );
00743 if( result == 0 )
00744 {
00745 hexify( output_str, output, ctx.len );
00746
00747 TEST_ASSERT( strncasecmp( (char *) output_str, result_hex_str, strlen( result_hex_str ) ) == 0 );
00748 }
00749
00750 mpi_free( &P1 ); mpi_free( &Q1 ); mpi_free( &H ); mpi_free( &G );
00751 rsa_free( &ctx );
00752 }
00753
00754 void test_suite_rsa_public( char *message_hex_string, int mod, int radix_N, char *input_N,
00755 int radix_E, char *input_E, char *result_hex_str, int result )
00756 {
00757 unsigned char message_str[1000];
00758 unsigned char output[1000];
00759 unsigned char output_str[1000];
00760 rsa_context ctx;
00761
00762 rsa_init( &ctx, RSA_PKCS_V15, 0 );
00763 memset( message_str, 0x00, 1000 );
00764 memset( output, 0x00, 1000 );
00765 memset( output_str, 0x00, 1000 );
00766
00767 ctx.len = mod / 8;
00768 TEST_ASSERT( mpi_read_string( &ctx.N, radix_N, input_N ) == 0 );
00769 TEST_ASSERT( mpi_read_string( &ctx.E, radix_E, input_E ) == 0 );
00770
00771 TEST_ASSERT( rsa_check_pubkey( &ctx ) == 0 );
00772
00773 unhexify( message_str, message_hex_string );
00774
00775 TEST_ASSERT( rsa_public( &ctx, message_str, output ) == result );
00776 if( result == 0 )
00777 {
00778 hexify( output_str, output, ctx.len );
00779
00780 TEST_ASSERT( strcasecmp( (char *) output_str, result_hex_str ) == 0 );
00781 }
00782
00783 rsa_free( &ctx );
00784 }
00785
00786 void test_suite_rsa_private( char *message_hex_string, int mod, int radix_P, char *input_P,
00787 int radix_Q, char *input_Q, int radix_N, char *input_N,
00788 int radix_E, char *input_E, char *result_hex_str, int result )
00789 {
00790 unsigned char message_str[1000];
00791 unsigned char output[1000];
00792 unsigned char output_str[1000];
00793 rsa_context ctx;
00794 mpi P1, Q1, H, G;
00795 rnd_pseudo_info rnd_info;
00796 int i;
00797
00798 mpi_init( &P1 ); mpi_init( &Q1 ); mpi_init( &H ); mpi_init( &G );
00799 rsa_init( &ctx, RSA_PKCS_V15, 0 );
00800
00801 memset( message_str, 0x00, 1000 );
00802 memset( &rnd_info, 0, sizeof( rnd_pseudo_info ) );
00803
00804 ctx.len = mod / 8;
00805 TEST_ASSERT( mpi_read_string( &ctx.P, radix_P, input_P ) == 0 );
00806 TEST_ASSERT( mpi_read_string( &ctx.Q, radix_Q, input_Q ) == 0 );
00807 TEST_ASSERT( mpi_read_string( &ctx.N, radix_N, input_N ) == 0 );
00808 TEST_ASSERT( mpi_read_string( &ctx.E, radix_E, input_E ) == 0 );
00809
00810 TEST_ASSERT( mpi_sub_int( &P1, &ctx.P, 1 ) == 0 );
00811 TEST_ASSERT( mpi_sub_int( &Q1, &ctx.Q, 1 ) == 0 );
00812 TEST_ASSERT( mpi_mul_mpi( &H, &P1, &Q1 ) == 0 );
00813 TEST_ASSERT( mpi_gcd( &G, &ctx.E, &H ) == 0 );
00814 TEST_ASSERT( mpi_inv_mod( &ctx.D , &ctx.E, &H ) == 0 );
00815 TEST_ASSERT( mpi_mod_mpi( &ctx.DP, &ctx.D, &P1 ) == 0 );
00816 TEST_ASSERT( mpi_mod_mpi( &ctx.DQ, &ctx.D, &Q1 ) == 0 );
00817 TEST_ASSERT( mpi_inv_mod( &ctx.QP, &ctx.Q, &ctx.P ) == 0 );
00818
00819 TEST_ASSERT( rsa_check_privkey( &ctx ) == 0 );
00820
00821 unhexify( message_str, message_hex_string );
00822
00823
00824 for( i = 0; i < 3; i++ )
00825 {
00826 memset( output, 0x00, 1000 );
00827 memset( output_str, 0x00, 1000 );
00828 TEST_ASSERT( rsa_private( &ctx, rnd_pseudo_rand, &rnd_info,
00829 message_str, output ) == result );
00830 if( result == 0 )
00831 {
00832 hexify( output_str, output, ctx.len );
00833
00834 TEST_ASSERT( strcasecmp( (char *) output_str,
00835 result_hex_str ) == 0 );
00836 }
00837 }
00838
00839 mpi_free( &P1 ); mpi_free( &Q1 ); mpi_free( &H ); mpi_free( &G );
00840 rsa_free( &ctx );
00841 }
00842
00843 void test_suite_rsa_check_privkey_null()
00844 {
00845 rsa_context ctx;
00846 memset( &ctx, 0x00, sizeof( rsa_context ) );
00847
00848 TEST_ASSERT( rsa_check_privkey( &ctx ) == POLARSSL_ERR_RSA_KEY_CHECK_FAILED );
00849 }
00850
00851 void test_suite_rsa_check_pubkey( int radix_N, char *input_N, int radix_E, char *input_E,
00852 int result )
00853 {
00854 rsa_context ctx;
00855
00856 rsa_init( &ctx, RSA_PKCS_V15, 0 );
00857
00858 if( strlen( input_N ) )
00859 {
00860 TEST_ASSERT( mpi_read_string( &ctx.N, radix_N, input_N ) == 0 );
00861 }
00862 if( strlen( input_E ) )
00863 {
00864 TEST_ASSERT( mpi_read_string( &ctx.E, radix_E, input_E ) == 0 );
00865 }
00866
00867 TEST_ASSERT( rsa_check_pubkey( &ctx ) == result );
00868
00869 rsa_free( &ctx );
00870 }
00871
00872 void test_suite_rsa_check_privkey( int mod, int radix_P, char *input_P, int radix_Q,
00873 char *input_Q, int radix_N, char *input_N,
00874 int radix_E, char *input_E, int radix_D, char *input_D,
00875 int radix_DP, char *input_DP, int radix_DQ,
00876 char *input_DQ, int radix_QP, char *input_QP,
00877 int result )
00878 {
00879 rsa_context ctx;
00880
00881 rsa_init( &ctx, RSA_PKCS_V15, 0 );
00882
00883 ctx.len = mod / 8;
00884 if( strlen( input_P ) )
00885 {
00886 TEST_ASSERT( mpi_read_string( &ctx.P, radix_P, input_P ) == 0 );
00887 }
00888 if( strlen( input_Q ) )
00889 {
00890 TEST_ASSERT( mpi_read_string( &ctx.Q, radix_Q, input_Q ) == 0 );
00891 }
00892 if( strlen( input_N ) )
00893 {
00894 TEST_ASSERT( mpi_read_string( &ctx.N, radix_N, input_N ) == 0 );
00895 }
00896 if( strlen( input_E ) )
00897 {
00898 TEST_ASSERT( mpi_read_string( &ctx.E, radix_E, input_E ) == 0 );
00899 }
00900 if( strlen( input_D ) )
00901 {
00902 TEST_ASSERT( mpi_read_string( &ctx.D, radix_D, input_D ) == 0 );
00903 }
00904 if( strlen( input_DP ) )
00905 {
00906 TEST_ASSERT( mpi_read_string( &ctx.DP, radix_DP, input_DP ) == 0 );
00907 }
00908 if( strlen( input_DQ ) )
00909 {
00910 TEST_ASSERT( mpi_read_string( &ctx.DQ, radix_DQ, input_DQ ) == 0 );
00911 }
00912 if( strlen( input_QP ) )
00913 {
00914 TEST_ASSERT( mpi_read_string( &ctx.QP, radix_QP, input_QP ) == 0 );
00915 }
00916
00917 TEST_ASSERT( rsa_check_privkey( &ctx ) == result );
00918
00919 rsa_free( &ctx );
00920 }
00921
00922 #ifdef POLARSSL_CTR_CRBG_C
00923 #ifdef POLARSSL_ENTROPY_C
00924 void test_suite_rsa_gen_key( int nrbits, int exponent, int result)
00925 {
00926 rsa_context ctx;
00927 entropy_context entropy;
00928 ctr_drbg_context ctr_drbg;
00929 const char *pers = "test_suite_rsa";
00930
00931 entropy_init( &entropy );
00932 TEST_ASSERT( ctr_drbg_init( &ctr_drbg, entropy_func, &entropy,
00933 (const unsigned char *) pers, strlen( pers ) ) == 0 );
00934
00935 rsa_init( &ctx, 0, 0 );
00936
00937 TEST_ASSERT( rsa_gen_key( &ctx, ctr_drbg_random, &ctr_drbg, nrbits, exponent ) == result );
00938 if( result == 0 )
00939 {
00940 TEST_ASSERT( rsa_check_privkey( &ctx ) == 0 );
00941 }
00942
00943 rsa_free( &ctx );
00944 entropy_free( &entropy );
00945 }
00946 #endif
00947 #endif
00948
00949 #ifdef POLARSSL_SELF_TEST
00950 void test_suite_rsa_selftest()
00951 {
00952 TEST_ASSERT( rsa_self_test( 0 ) == 0 );
00953 }
00954 #endif
00955
00956
00957 #endif
00958 #endif
00959 #endif
00960
00961
00962 int dep_check( char *str )
00963 {
00964 if( str == NULL )
00965 return( 1 );
00966
00967 if( strcmp( str, "POLARSSL_MD4_C" ) == 0 )
00968 {
00969 #if defined(POLARSSL_MD4_C)
00970 return( 0 );
00971 #else
00972 return( 1 );
00973 #endif
00974 }
00975 if( strcmp( str, "POLARSSL_SHA1_C" ) == 0 )
00976 {
00977 #if defined(POLARSSL_SHA1_C)
00978 return( 0 );
00979 #else
00980 return( 1 );
00981 #endif
00982 }
00983 if( strcmp( str, "POLARSSL_PKCS1_V15" ) == 0 )
00984 {
00985 #if defined(POLARSSL_PKCS1_V15)
00986 return( 0 );
00987 #else
00988 return( 1 );
00989 #endif
00990 }
00991 if( strcmp( str, "POLARSSL_CTR_DRBG_C" ) == 0 )
00992 {
00993 #if defined(POLARSSL_CTR_DRBG_C)
00994 return( 0 );
00995 #else
00996 return( 1 );
00997 #endif
00998 }
00999 if( strcmp( str, "POLARSSL_ENTROPY_C" ) == 0 )
01000 {
01001 #if defined(POLARSSL_ENTROPY_C)
01002 return( 0 );
01003 #else
01004 return( 1 );
01005 #endif
01006 }
01007 if( strcmp( str, "POLARSSL_SELF_TEST" ) == 0 )
01008 {
01009 #if defined(POLARSSL_SELF_TEST)
01010 return( 0 );
01011 #else
01012 return( 1 );
01013 #endif
01014 }
01015 if( strcmp( str, "POLARSSL_MD5_C" ) == 0 )
01016 {
01017 #if defined(POLARSSL_MD5_C)
01018 return( 0 );
01019 #else
01020 return( 1 );
01021 #endif
01022 }
01023 if( strcmp( str, "POLARSSL_SHA256_C" ) == 0 )
01024 {
01025 #if defined(POLARSSL_SHA256_C)
01026 return( 0 );
01027 #else
01028 return( 1 );
01029 #endif
01030 }
01031 if( strcmp( str, "POLARSSL_MD2_C" ) == 0 )
01032 {
01033 #if defined(POLARSSL_MD2_C)
01034 return( 0 );
01035 #else
01036 return( 1 );
01037 #endif
01038 }
01039 if( strcmp( str, "POLARSSL_SHA512_C" ) == 0 )
01040 {
01041 #if defined(POLARSSL_SHA512_C)
01042 return( 0 );
01043 #else
01044 return( 1 );
01045 #endif
01046 }
01047
01048
01049 return( 1 );
01050 }
01051
01052 int dispatch_test(int cnt, char *params[50])
01053 {
01054 int ret;
01055 ((void) cnt);
01056 ((void) params);
01057
01058 #if defined(TEST_SUITE_ACTIVE)
01059 if( strcmp( params[0], "rsa_pkcs1_sign" ) == 0 )
01060 {
01061
01062 char *param1 = params[1];
01063 int param2;
01064 int param3;
01065 int param4;
01066 int param5;
01067 char *param6 = params[6];
01068 int param7;
01069 char *param8 = params[8];
01070 int param9;
01071 char *param10 = params[10];
01072 int param11;
01073 char *param12 = params[12];
01074 char *param13 = params[13];
01075 int param14;
01076
01077 if( cnt != 15 )
01078 {
01079 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 15 );
01080 return( 2 );
01081 }
01082
01083 if( verify_string( ¶m1 ) != 0 ) return( 2 );
01084 if( verify_int( params[2], ¶m2 ) != 0 ) return( 2 );
01085 if( verify_int( params[3], ¶m3 ) != 0 ) return( 2 );
01086 if( verify_int( params[4], ¶m4 ) != 0 ) return( 2 );
01087 if( verify_int( params[5], ¶m5 ) != 0 ) return( 2 );
01088 if( verify_string( ¶m6 ) != 0 ) return( 2 );
01089 if( verify_int( params[7], ¶m7 ) != 0 ) return( 2 );
01090 if( verify_string( ¶m8 ) != 0 ) return( 2 );
01091 if( verify_int( params[9], ¶m9 ) != 0 ) return( 2 );
01092 if( verify_string( ¶m10 ) != 0 ) return( 2 );
01093 if( verify_int( params[11], ¶m11 ) != 0 ) return( 2 );
01094 if( verify_string( ¶m12 ) != 0 ) return( 2 );
01095 if( verify_string( ¶m13 ) != 0 ) return( 2 );
01096 if( verify_int( params[14], ¶m14 ) != 0 ) return( 2 );
01097
01098 test_suite_rsa_pkcs1_sign( param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14 );
01099 return ( 0 );
01100
01101 return ( 3 );
01102 }
01103 else
01104 if( strcmp( params[0], "rsa_pkcs1_verify" ) == 0 )
01105 {
01106
01107 char *param1 = params[1];
01108 int param2;
01109 int param3;
01110 int param4;
01111 int param5;
01112 char *param6 = params[6];
01113 int param7;
01114 char *param8 = params[8];
01115 char *param9 = params[9];
01116 int param10;
01117
01118 if( cnt != 11 )
01119 {
01120 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 11 );
01121 return( 2 );
01122 }
01123
01124 if( verify_string( ¶m1 ) != 0 ) return( 2 );
01125 if( verify_int( params[2], ¶m2 ) != 0 ) return( 2 );
01126 if( verify_int( params[3], ¶m3 ) != 0 ) return( 2 );
01127 if( verify_int( params[4], ¶m4 ) != 0 ) return( 2 );
01128 if( verify_int( params[5], ¶m5 ) != 0 ) return( 2 );
01129 if( verify_string( ¶m6 ) != 0 ) return( 2 );
01130 if( verify_int( params[7], ¶m7 ) != 0 ) return( 2 );
01131 if( verify_string( ¶m8 ) != 0 ) return( 2 );
01132 if( verify_string( ¶m9 ) != 0 ) return( 2 );
01133 if( verify_int( params[10], ¶m10 ) != 0 ) return( 2 );
01134
01135 test_suite_rsa_pkcs1_verify( param1, param2, param3, param4, param5, param6, param7, param8, param9, param10 );
01136 return ( 0 );
01137
01138 return ( 3 );
01139 }
01140 else
01141 if( strcmp( params[0], "rsa_pkcs1_sign_raw" ) == 0 )
01142 {
01143
01144 char *param1 = params[1];
01145 char *param2 = params[2];
01146 int param3;
01147 int param4;
01148 int param5;
01149 char *param6 = params[6];
01150 int param7;
01151 char *param8 = params[8];
01152 int param9;
01153 char *param10 = params[10];
01154 int param11;
01155 char *param12 = params[12];
01156 char *param13 = params[13];
01157
01158 if( cnt != 14 )
01159 {
01160 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 14 );
01161 return( 2 );
01162 }
01163
01164 if( verify_string( ¶m1 ) != 0 ) return( 2 );
01165 if( verify_string( ¶m2 ) != 0 ) return( 2 );
01166 if( verify_int( params[3], ¶m3 ) != 0 ) return( 2 );
01167 if( verify_int( params[4], ¶m4 ) != 0 ) return( 2 );
01168 if( verify_int( params[5], ¶m5 ) != 0 ) return( 2 );
01169 if( verify_string( ¶m6 ) != 0 ) return( 2 );
01170 if( verify_int( params[7], ¶m7 ) != 0 ) return( 2 );
01171 if( verify_string( ¶m8 ) != 0 ) return( 2 );
01172 if( verify_int( params[9], ¶m9 ) != 0 ) return( 2 );
01173 if( verify_string( ¶m10 ) != 0 ) return( 2 );
01174 if( verify_int( params[11], ¶m11 ) != 0 ) return( 2 );
01175 if( verify_string( ¶m12 ) != 0 ) return( 2 );
01176 if( verify_string( ¶m13 ) != 0 ) return( 2 );
01177
01178 test_suite_rsa_pkcs1_sign_raw( param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13 );
01179 return ( 0 );
01180
01181 return ( 3 );
01182 }
01183 else
01184 if( strcmp( params[0], "rsa_pkcs1_verify_raw" ) == 0 )
01185 {
01186
01187 char *param1 = params[1];
01188 char *param2 = params[2];
01189 int param3;
01190 int param4;
01191 int param5;
01192 char *param6 = params[6];
01193 int param7;
01194 char *param8 = params[8];
01195 char *param9 = params[9];
01196 int param10;
01197
01198 if( cnt != 11 )
01199 {
01200 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 11 );
01201 return( 2 );
01202 }
01203
01204 if( verify_string( ¶m1 ) != 0 ) return( 2 );
01205 if( verify_string( ¶m2 ) != 0 ) return( 2 );
01206 if( verify_int( params[3], ¶m3 ) != 0 ) return( 2 );
01207 if( verify_int( params[4], ¶m4 ) != 0 ) return( 2 );
01208 if( verify_int( params[5], ¶m5 ) != 0 ) return( 2 );
01209 if( verify_string( ¶m6 ) != 0 ) return( 2 );
01210 if( verify_int( params[7], ¶m7 ) != 0 ) return( 2 );
01211 if( verify_string( ¶m8 ) != 0 ) return( 2 );
01212 if( verify_string( ¶m9 ) != 0 ) return( 2 );
01213 if( verify_int( params[10], ¶m10 ) != 0 ) return( 2 );
01214
01215 test_suite_rsa_pkcs1_verify_raw( param1, param2, param3, param4, param5, param6, param7, param8, param9, param10 );
01216 return ( 0 );
01217
01218 return ( 3 );
01219 }
01220 else
01221 if( strcmp( params[0], "rsa_pkcs1_encrypt" ) == 0 )
01222 {
01223
01224 char *param1 = params[1];
01225 int param2;
01226 int param3;
01227 int param4;
01228 char *param5 = params[5];
01229 int param6;
01230 char *param7 = params[7];
01231 char *param8 = params[8];
01232 int param9;
01233
01234 if( cnt != 10 )
01235 {
01236 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 10 );
01237 return( 2 );
01238 }
01239
01240 if( verify_string( ¶m1 ) != 0 ) return( 2 );
01241 if( verify_int( params[2], ¶m2 ) != 0 ) return( 2 );
01242 if( verify_int( params[3], ¶m3 ) != 0 ) return( 2 );
01243 if( verify_int( params[4], ¶m4 ) != 0 ) return( 2 );
01244 if( verify_string( ¶m5 ) != 0 ) return( 2 );
01245 if( verify_int( params[6], ¶m6 ) != 0 ) return( 2 );
01246 if( verify_string( ¶m7 ) != 0 ) return( 2 );
01247 if( verify_string( ¶m8 ) != 0 ) return( 2 );
01248 if( verify_int( params[9], ¶m9 ) != 0 ) return( 2 );
01249
01250 test_suite_rsa_pkcs1_encrypt( param1, param2, param3, param4, param5, param6, param7, param8, param9 );
01251 return ( 0 );
01252
01253 return ( 3 );
01254 }
01255 else
01256 if( strcmp( params[0], "rsa_pkcs1_encrypt_bad_rng" ) == 0 )
01257 {
01258
01259 char *param1 = params[1];
01260 int param2;
01261 int param3;
01262 int param4;
01263 char *param5 = params[5];
01264 int param6;
01265 char *param7 = params[7];
01266 char *param8 = params[8];
01267 int param9;
01268
01269 if( cnt != 10 )
01270 {
01271 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 10 );
01272 return( 2 );
01273 }
01274
01275 if( verify_string( ¶m1 ) != 0 ) return( 2 );
01276 if( verify_int( params[2], ¶m2 ) != 0 ) return( 2 );
01277 if( verify_int( params[3], ¶m3 ) != 0 ) return( 2 );
01278 if( verify_int( params[4], ¶m4 ) != 0 ) return( 2 );
01279 if( verify_string( ¶m5 ) != 0 ) return( 2 );
01280 if( verify_int( params[6], ¶m6 ) != 0 ) return( 2 );
01281 if( verify_string( ¶m7 ) != 0 ) return( 2 );
01282 if( verify_string( ¶m8 ) != 0 ) return( 2 );
01283 if( verify_int( params[9], ¶m9 ) != 0 ) return( 2 );
01284
01285 test_suite_rsa_pkcs1_encrypt_bad_rng( param1, param2, param3, param4, param5, param6, param7, param8, param9 );
01286 return ( 0 );
01287
01288 return ( 3 );
01289 }
01290 else
01291 if( strcmp( params[0], "rsa_pkcs1_decrypt" ) == 0 )
01292 {
01293
01294 char *param1 = params[1];
01295 int param2;
01296 int param3;
01297 int param4;
01298 char *param5 = params[5];
01299 int param6;
01300 char *param7 = params[7];
01301 int param8;
01302 char *param9 = params[9];
01303 int param10;
01304 char *param11 = params[11];
01305 int param12;
01306 char *param13 = params[13];
01307 int param14;
01308
01309 if( cnt != 15 )
01310 {
01311 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 15 );
01312 return( 2 );
01313 }
01314
01315 if( verify_string( ¶m1 ) != 0 ) return( 2 );
01316 if( verify_int( params[2], ¶m2 ) != 0 ) return( 2 );
01317 if( verify_int( params[3], ¶m3 ) != 0 ) return( 2 );
01318 if( verify_int( params[4], ¶m4 ) != 0 ) return( 2 );
01319 if( verify_string( ¶m5 ) != 0 ) return( 2 );
01320 if( verify_int( params[6], ¶m6 ) != 0 ) return( 2 );
01321 if( verify_string( ¶m7 ) != 0 ) return( 2 );
01322 if( verify_int( params[8], ¶m8 ) != 0 ) return( 2 );
01323 if( verify_string( ¶m9 ) != 0 ) return( 2 );
01324 if( verify_int( params[10], ¶m10 ) != 0 ) return( 2 );
01325 if( verify_string( ¶m11 ) != 0 ) return( 2 );
01326 if( verify_int( params[12], ¶m12 ) != 0 ) return( 2 );
01327 if( verify_string( ¶m13 ) != 0 ) return( 2 );
01328 if( verify_int( params[14], ¶m14 ) != 0 ) return( 2 );
01329
01330 test_suite_rsa_pkcs1_decrypt( param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14 );
01331 return ( 0 );
01332
01333 return ( 3 );
01334 }
01335 else
01336 if( strcmp( params[0], "rsa_public" ) == 0 )
01337 {
01338
01339 char *param1 = params[1];
01340 int param2;
01341 int param3;
01342 char *param4 = params[4];
01343 int param5;
01344 char *param6 = params[6];
01345 char *param7 = params[7];
01346 int param8;
01347
01348 if( cnt != 9 )
01349 {
01350 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 9 );
01351 return( 2 );
01352 }
01353
01354 if( verify_string( ¶m1 ) != 0 ) return( 2 );
01355 if( verify_int( params[2], ¶m2 ) != 0 ) return( 2 );
01356 if( verify_int( params[3], ¶m3 ) != 0 ) return( 2 );
01357 if( verify_string( ¶m4 ) != 0 ) return( 2 );
01358 if( verify_int( params[5], ¶m5 ) != 0 ) return( 2 );
01359 if( verify_string( ¶m6 ) != 0 ) return( 2 );
01360 if( verify_string( ¶m7 ) != 0 ) return( 2 );
01361 if( verify_int( params[8], ¶m8 ) != 0 ) return( 2 );
01362
01363 test_suite_rsa_public( param1, param2, param3, param4, param5, param6, param7, param8 );
01364 return ( 0 );
01365
01366 return ( 3 );
01367 }
01368 else
01369 if( strcmp( params[0], "rsa_private" ) == 0 )
01370 {
01371
01372 char *param1 = params[1];
01373 int param2;
01374 int param3;
01375 char *param4 = params[4];
01376 int param5;
01377 char *param6 = params[6];
01378 int param7;
01379 char *param8 = params[8];
01380 int param9;
01381 char *param10 = params[10];
01382 char *param11 = params[11];
01383 int param12;
01384
01385 if( cnt != 13 )
01386 {
01387 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 13 );
01388 return( 2 );
01389 }
01390
01391 if( verify_string( ¶m1 ) != 0 ) return( 2 );
01392 if( verify_int( params[2], ¶m2 ) != 0 ) return( 2 );
01393 if( verify_int( params[3], ¶m3 ) != 0 ) return( 2 );
01394 if( verify_string( ¶m4 ) != 0 ) return( 2 );
01395 if( verify_int( params[5], ¶m5 ) != 0 ) return( 2 );
01396 if( verify_string( ¶m6 ) != 0 ) return( 2 );
01397 if( verify_int( params[7], ¶m7 ) != 0 ) return( 2 );
01398 if( verify_string( ¶m8 ) != 0 ) return( 2 );
01399 if( verify_int( params[9], ¶m9 ) != 0 ) return( 2 );
01400 if( verify_string( ¶m10 ) != 0 ) return( 2 );
01401 if( verify_string( ¶m11 ) != 0 ) return( 2 );
01402 if( verify_int( params[12], ¶m12 ) != 0 ) return( 2 );
01403
01404 test_suite_rsa_private( param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12 );
01405 return ( 0 );
01406
01407 return ( 3 );
01408 }
01409 else
01410 if( strcmp( params[0], "rsa_check_privkey_null" ) == 0 )
01411 {
01412
01413
01414 if( cnt != 1 )
01415 {
01416 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 1 );
01417 return( 2 );
01418 }
01419
01420
01421 test_suite_rsa_check_privkey_null( );
01422 return ( 0 );
01423
01424 return ( 3 );
01425 }
01426 else
01427 if( strcmp( params[0], "rsa_check_pubkey" ) == 0 )
01428 {
01429
01430 int param1;
01431 char *param2 = params[2];
01432 int param3;
01433 char *param4 = params[4];
01434 int param5;
01435
01436 if( cnt != 6 )
01437 {
01438 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 6 );
01439 return( 2 );
01440 }
01441
01442 if( verify_int( params[1], ¶m1 ) != 0 ) return( 2 );
01443 if( verify_string( ¶m2 ) != 0 ) return( 2 );
01444 if( verify_int( params[3], ¶m3 ) != 0 ) return( 2 );
01445 if( verify_string( ¶m4 ) != 0 ) return( 2 );
01446 if( verify_int( params[5], ¶m5 ) != 0 ) return( 2 );
01447
01448 test_suite_rsa_check_pubkey( param1, param2, param3, param4, param5 );
01449 return ( 0 );
01450
01451 return ( 3 );
01452 }
01453 else
01454 if( strcmp( params[0], "rsa_check_privkey" ) == 0 )
01455 {
01456
01457 int param1;
01458 int param2;
01459 char *param3 = params[3];
01460 int param4;
01461 char *param5 = params[5];
01462 int param6;
01463 char *param7 = params[7];
01464 int param8;
01465 char *param9 = params[9];
01466 int param10;
01467 char *param11 = params[11];
01468 int param12;
01469 char *param13 = params[13];
01470 int param14;
01471 char *param15 = params[15];
01472 int param16;
01473 char *param17 = params[17];
01474 int param18;
01475
01476 if( cnt != 19 )
01477 {
01478 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 19 );
01479 return( 2 );
01480 }
01481
01482 if( verify_int( params[1], ¶m1 ) != 0 ) return( 2 );
01483 if( verify_int( params[2], ¶m2 ) != 0 ) return( 2 );
01484 if( verify_string( ¶m3 ) != 0 ) return( 2 );
01485 if( verify_int( params[4], ¶m4 ) != 0 ) return( 2 );
01486 if( verify_string( ¶m5 ) != 0 ) return( 2 );
01487 if( verify_int( params[6], ¶m6 ) != 0 ) return( 2 );
01488 if( verify_string( ¶m7 ) != 0 ) return( 2 );
01489 if( verify_int( params[8], ¶m8 ) != 0 ) return( 2 );
01490 if( verify_string( ¶m9 ) != 0 ) return( 2 );
01491 if( verify_int( params[10], ¶m10 ) != 0 ) return( 2 );
01492 if( verify_string( ¶m11 ) != 0 ) return( 2 );
01493 if( verify_int( params[12], ¶m12 ) != 0 ) return( 2 );
01494 if( verify_string( ¶m13 ) != 0 ) return( 2 );
01495 if( verify_int( params[14], ¶m14 ) != 0 ) return( 2 );
01496 if( verify_string( ¶m15 ) != 0 ) return( 2 );
01497 if( verify_int( params[16], ¶m16 ) != 0 ) return( 2 );
01498 if( verify_string( ¶m17 ) != 0 ) return( 2 );
01499 if( verify_int( params[18], ¶m18 ) != 0 ) return( 2 );
01500
01501 test_suite_rsa_check_privkey( param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16, param17, param18 );
01502 return ( 0 );
01503
01504 return ( 3 );
01505 }
01506 else
01507 if( strcmp( params[0], "rsa_gen_key" ) == 0 )
01508 {
01509 #ifdef POLARSSL_CTR_CRBG_C
01510 #ifdef POLARSSL_ENTROPY_C
01511
01512 int param1;
01513 int param2;
01514 int param3;
01515
01516 if( cnt != 4 )
01517 {
01518 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 4 );
01519 return( 2 );
01520 }
01521
01522 if( verify_int( params[1], ¶m1 ) != 0 ) return( 2 );
01523 if( verify_int( params[2], ¶m2 ) != 0 ) return( 2 );
01524 if( verify_int( params[3], ¶m3 ) != 0 ) return( 2 );
01525
01526 test_suite_rsa_gen_key( param1, param2, param3 );
01527 return ( 0 );
01528 #endif
01529 #endif
01530
01531 return ( 3 );
01532 }
01533 else
01534 if( strcmp( params[0], "rsa_selftest" ) == 0 )
01535 {
01536 #ifdef POLARSSL_SELF_TEST
01537
01538
01539 if( cnt != 1 )
01540 {
01541 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 1 );
01542 return( 2 );
01543 }
01544
01545
01546 test_suite_rsa_selftest( );
01547 return ( 0 );
01548 #endif
01549
01550 return ( 3 );
01551 }
01552 else
01553
01554 {
01555 fprintf( stdout, "FAILED\nSkipping unknown test function '%s'\n", params[0] );
01556 fflush( stdout );
01557 return( 1 );
01558 }
01559 #else
01560 return( 3 );
01561 #endif
01562 return( ret );
01563 }
01564
01565 int get_line( FILE *f, char *buf, size_t len )
01566 {
01567 char *ret;
01568
01569 ret = fgets( buf, len, f );
01570 if( ret == NULL )
01571 return( -1 );
01572
01573 if( strlen( buf ) && buf[strlen(buf) - 1] == '\n' )
01574 buf[strlen(buf) - 1] = '\0';
01575 if( strlen( buf ) && buf[strlen(buf) - 1] == '\r' )
01576 buf[strlen(buf) - 1] = '\0';
01577
01578 return( 0 );
01579 }
01580
01581 int parse_arguments( char *buf, size_t len, char *params[50] )
01582 {
01583 int cnt = 0, i;
01584 char *cur = buf;
01585 char *p = buf, *q;
01586
01587 params[cnt++] = cur;
01588
01589 while( *p != '\0' && p < buf + len )
01590 {
01591 if( *p == '\\' )
01592 {
01593 *p++;
01594 *p++;
01595 continue;
01596 }
01597 if( *p == ':' )
01598 {
01599 if( p + 1 < buf + len )
01600 {
01601 cur = p + 1;
01602 params[cnt++] = cur;
01603 }
01604 *p = '\0';
01605 }
01606
01607 *p++;
01608 }
01609
01610
01611 for( i = 0; i < cnt; i++ )
01612 {
01613 p = params[i];
01614 q = params[i];
01615
01616 while( *p != '\0' )
01617 {
01618 if( *p == '\\' && *(p + 1) == 'n' )
01619 {
01620 p += 2;
01621 *(q++) = '\n';
01622 }
01623 else if( *p == '\\' && *(p + 1) == ':' )
01624 {
01625 p += 2;
01626 *(q++) = ':';
01627 }
01628 else if( *p == '\\' && *(p + 1) == '?' )
01629 {
01630 p += 2;
01631 *(q++) = '?';
01632 }
01633 else
01634 *(q++) = *(p++);
01635 }
01636 *q = '\0';
01637 }
01638
01639 return( cnt );
01640 }
01641
01642 int main()
01643 {
01644 int ret, i, cnt, total_errors = 0, total_tests = 0, total_skipped = 0;
01645 const char *filename = "/home/abuild/rpmbuild/BUILD/polarssl-1.3.2/tests/suites/test_suite_rsa.data";
01646 FILE *file;
01647 char buf[5000];
01648 char *params[50];
01649
01650 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
01651 unsigned char alloc_buf[1000000];
01652 memory_buffer_alloc_init( alloc_buf, sizeof(alloc_buf) );
01653 #endif
01654
01655 file = fopen( filename, "r" );
01656 if( file == NULL )
01657 {
01658 fprintf( stderr, "Failed to open\n" );
01659 return( 1 );
01660 }
01661
01662 while( !feof( file ) )
01663 {
01664 int skip = 0;
01665
01666 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
01667 break;
01668 fprintf( stdout, "%s%.66s", test_errors ? "\n" : "", buf );
01669 fprintf( stdout, " " );
01670 for( i = strlen( buf ) + 1; i < 67; i++ )
01671 fprintf( stdout, "." );
01672 fprintf( stdout, " " );
01673 fflush( stdout );
01674
01675 total_tests++;
01676
01677 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
01678 break;
01679 cnt = parse_arguments( buf, strlen(buf), params );
01680
01681 if( strcmp( params[0], "depends_on" ) == 0 )
01682 {
01683 for( i = 1; i < cnt; i++ )
01684 if( dep_check( params[i] ) != 0 )
01685 skip = 1;
01686
01687 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
01688 break;
01689 cnt = parse_arguments( buf, strlen(buf), params );
01690 }
01691
01692 if( skip == 0 )
01693 {
01694 test_errors = 0;
01695 ret = dispatch_test( cnt, params );
01696 }
01697
01698 if( skip == 1 || ret == 3 )
01699 {
01700 total_skipped++;
01701 fprintf( stdout, "----\n" );
01702 fflush( stdout );
01703 }
01704 else if( ret == 0 && test_errors == 0 )
01705 {
01706 fprintf( stdout, "PASS\n" );
01707 fflush( stdout );
01708 }
01709 else if( ret == 2 )
01710 {
01711 fprintf( stderr, "FAILED: FATAL PARSE ERROR\n" );
01712 fclose(file);
01713 exit( 2 );
01714 }
01715 else
01716 total_errors++;
01717
01718 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
01719 break;
01720 if( strlen(buf) != 0 )
01721 {
01722 fprintf( stderr, "Should be empty %d\n", (int) strlen(buf) );
01723 return( 1 );
01724 }
01725 }
01726 fclose(file);
01727
01728 fprintf( stdout, "\n----------------------------------------------------------------------------\n\n");
01729 if( total_errors == 0 )
01730 fprintf( stdout, "PASSED" );
01731 else
01732 fprintf( stdout, "FAILED" );
01733
01734 fprintf( stdout, " (%d / %d tests (%d skipped))\n",
01735 total_tests - total_errors, total_tests, total_skipped );
01736
01737 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
01738 #if defined(POLARSSL_MEMORY_DEBUG)
01739 memory_buffer_alloc_status();
01740 #endif
01741 memory_buffer_alloc_free();
01742 #endif
01743
01744 return( total_errors != 0 );
01745 }
01746
01747