00001 #include <polarssl/config.h>
00002
00003 #ifdef POLARSSL_DHM_C
00004 #ifdef POLARSSL_BIGNUM_C
00005
00006 #include <polarssl/dhm.h>
00007 #endif
00008 #endif
00009
00010
00011 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
00012 #include "polarssl/memory.h"
00013 #endif
00014
00015 #if defined(WANT_NOT_RND_MPI)
00016 #if defined(POLARSSL_BIGNUM_C)
00017 #include "polarssl/bignum.h"
00018 #else
00019 #error "not_rnd_mpi() need bignum.c"
00020 #endif
00021 #endif
00022
00023 #ifdef _MSC_VER
00024 #include <basetsd.h>
00025 typedef UINT32 uint32_t;
00026 #else
00027 #include <inttypes.h>
00028 #endif
00029
00030 #include <assert.h>
00031 #include <stdlib.h>
00032 #include <string.h>
00033
00034
00035
00036
00037 #ifndef GET_UINT32_BE
00038 #define GET_UINT32_BE(n,b,i) \
00039 { \
00040 (n) = ( (uint32_t) (b)[(i) ] << 24 ) \
00041 | ( (uint32_t) (b)[(i) + 1] << 16 ) \
00042 | ( (uint32_t) (b)[(i) + 2] << 8 ) \
00043 | ( (uint32_t) (b)[(i) + 3] ); \
00044 }
00045 #endif
00046
00047 #ifndef PUT_UINT32_BE
00048 #define PUT_UINT32_BE(n,b,i) \
00049 { \
00050 (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
00051 (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
00052 (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
00053 (b)[(i) + 3] = (unsigned char) ( (n) ); \
00054 }
00055 #endif
00056
00057 static int unhexify(unsigned char *obuf, const char *ibuf)
00058 {
00059 unsigned char c, c2;
00060 int len = strlen(ibuf) / 2;
00061 assert(!(strlen(ibuf) %1));
00062
00063 while (*ibuf != 0)
00064 {
00065 c = *ibuf++;
00066 if( c >= '0' && c <= '9' )
00067 c -= '0';
00068 else if( c >= 'a' && c <= 'f' )
00069 c -= 'a' - 10;
00070 else if( c >= 'A' && c <= 'F' )
00071 c -= 'A' - 10;
00072 else
00073 assert( 0 );
00074
00075 c2 = *ibuf++;
00076 if( c2 >= '0' && c2 <= '9' )
00077 c2 -= '0';
00078 else if( c2 >= 'a' && c2 <= 'f' )
00079 c2 -= 'a' - 10;
00080 else if( c2 >= 'A' && c2 <= 'F' )
00081 c2 -= 'A' - 10;
00082 else
00083 assert( 0 );
00084
00085 *obuf++ = ( c << 4 ) | c2;
00086 }
00087
00088 return len;
00089 }
00090
00091 static void hexify(unsigned char *obuf, const unsigned char *ibuf, int len)
00092 {
00093 unsigned char l, h;
00094
00095 while (len != 0)
00096 {
00097 h = (*ibuf) / 16;
00098 l = (*ibuf) % 16;
00099
00100 if( h < 10 )
00101 *obuf++ = '0' + h;
00102 else
00103 *obuf++ = 'a' + h - 10;
00104
00105 if( l < 10 )
00106 *obuf++ = '0' + l;
00107 else
00108 *obuf++ = 'a' + l - 10;
00109
00110 ++ibuf;
00111 len--;
00112 }
00113 }
00114
00124 static int rnd_std_rand( void *rng_state, unsigned char *output, size_t len )
00125 {
00126 size_t i;
00127
00128 if( rng_state != NULL )
00129 rng_state = NULL;
00130
00131 for( i = 0; i < len; ++i )
00132 output[i] = rand();
00133
00134 return( 0 );
00135 }
00136
00142 static int rnd_zero_rand( void *rng_state, unsigned char *output, size_t len )
00143 {
00144 if( rng_state != NULL )
00145 rng_state = NULL;
00146
00147 memset( output, 0, len );
00148
00149 return( 0 );
00150 }
00151
00152 typedef struct
00153 {
00154 unsigned char *buf;
00155 size_t length;
00156 } rnd_buf_info;
00157
00169 static int rnd_buffer_rand( void *rng_state, unsigned char *output, size_t len )
00170 {
00171 rnd_buf_info *info = (rnd_buf_info *) rng_state;
00172 size_t use_len;
00173
00174 if( rng_state == NULL )
00175 return( rnd_std_rand( NULL, output, len ) );
00176
00177 use_len = len;
00178 if( len > info->length )
00179 use_len = info->length;
00180
00181 if( use_len )
00182 {
00183 memcpy( output, info->buf, use_len );
00184 info->buf += use_len;
00185 info->length -= use_len;
00186 }
00187
00188 if( len - use_len > 0 )
00189 return( rnd_std_rand( NULL, output + use_len, len - use_len ) );
00190
00191 return( 0 );
00192 }
00193
00201 typedef struct
00202 {
00203 uint32_t key[16];
00204 uint32_t v0, v1;
00205 } rnd_pseudo_info;
00206
00215 static int rnd_pseudo_rand( void *rng_state, unsigned char *output, size_t len )
00216 {
00217 rnd_pseudo_info *info = (rnd_pseudo_info *) rng_state;
00218 uint32_t i, *k, sum, delta=0x9E3779B9;
00219 unsigned char result[4];
00220
00221 if( rng_state == NULL )
00222 return( rnd_std_rand( NULL, output, len ) );
00223
00224 k = info->key;
00225
00226 while( len > 0 )
00227 {
00228 size_t use_len = ( len > 4 ) ? 4 : len;
00229 sum = 0;
00230
00231 for( i = 0; i < 32; i++ )
00232 {
00233 info->v0 += (((info->v1 << 4) ^ (info->v1 >> 5)) + info->v1) ^ (sum + k[sum & 3]);
00234 sum += delta;
00235 info->v1 += (((info->v0 << 4) ^ (info->v0 >> 5)) + info->v0) ^ (sum + k[(sum>>11) & 3]);
00236 }
00237
00238 PUT_UINT32_BE( info->v0, result, 0 );
00239 memcpy( output, result, use_len );
00240 len -= use_len;
00241 }
00242
00243 return( 0 );
00244 }
00245
00246 #if defined(WANT_NOT_RND_MPI)
00247
00255 #define ciL (sizeof(t_uint))
00256 #define CHARS_TO_LIMBS(i) (((i) + ciL - 1) / ciL)
00257 static int not_rnd_mpi( void *in, unsigned char *out, size_t len )
00258 {
00259 char *str = (char *) in;
00260 mpi X;
00261
00262
00263
00264
00265
00266 X.s = 1;
00267 X.p = (t_uint *) out;
00268 X.n = CHARS_TO_LIMBS( len );
00269
00270
00271
00272
00273
00274 assert( strlen( str ) / 2 == len );
00275
00276 return( mpi_read_string( &X, 16, str ) );
00277 }
00278 #endif
00279
00280
00281 #include <stdio.h>
00282 #include <string.h>
00283
00284 static int test_errors = 0;
00285
00286 #ifdef POLARSSL_DHM_C
00287 #ifdef POLARSSL_BIGNUM_C
00288
00289 #define TEST_SUITE_ACTIVE
00290
00291 static int test_assert( int correct, char *test )
00292 {
00293 if( correct )
00294 return( 0 );
00295
00296 test_errors++;
00297 if( test_errors == 1 )
00298 printf( "FAILED\n" );
00299 printf( " %s\n", test );
00300
00301 return( 1 );
00302 }
00303
00304 #define TEST_ASSERT( TEST ) \
00305 do { test_assert( (TEST) ? 1 : 0, #TEST ); \
00306 if( test_errors) return; \
00307 } while (0)
00308
00309 int verify_string( char **str )
00310 {
00311 if( (*str)[0] != '"' ||
00312 (*str)[strlen( *str ) - 1] != '"' )
00313 {
00314 printf( "Expected string (with \"\") for parameter and got: %s\n", *str );
00315 return( -1 );
00316 }
00317
00318 (*str)++;
00319 (*str)[strlen( *str ) - 1] = '\0';
00320
00321 return( 0 );
00322 }
00323
00324 int verify_int( char *str, int *value )
00325 {
00326 size_t i;
00327 int minus = 0;
00328 int digits = 1;
00329 int hex = 0;
00330
00331 for( i = 0; i < strlen( str ); i++ )
00332 {
00333 if( i == 0 && str[i] == '-' )
00334 {
00335 minus = 1;
00336 continue;
00337 }
00338
00339 if( ( ( minus && i == 2 ) || ( !minus && i == 1 ) ) &&
00340 str[i - 1] == '0' && str[i] == 'x' )
00341 {
00342 hex = 1;
00343 continue;
00344 }
00345
00346 if( str[i] < '0' || str[i] > '9' )
00347 {
00348 digits = 0;
00349 break;
00350 }
00351 }
00352
00353 if( digits )
00354 {
00355 if( hex )
00356 *value = strtol( str, NULL, 16 );
00357 else
00358 *value = strtol( str, NULL, 10 );
00359
00360 return( 0 );
00361 }
00362
00363
00364
00365 printf( "Expected integer for parameter and got: %s\n", str );
00366 return( -1 );
00367 }
00368
00369 void test_suite_dhm_do_dhm( int radix_P, char *input_P,
00370 int radix_G, char *input_G )
00371 {
00372 dhm_context ctx_srv;
00373 dhm_context ctx_cli;
00374 unsigned char ske[1000];
00375 unsigned char *p = ske;
00376 unsigned char pub_cli[1000];
00377 unsigned char sec_srv[1000];
00378 unsigned char sec_cli[1000];
00379 size_t ske_len = 0;
00380 size_t pub_cli_len = 0;
00381 size_t sec_srv_len = 1000;
00382 size_t sec_cli_len = 1000;
00383 int x_size, i;
00384 rnd_pseudo_info rnd_info;
00385
00386 memset( &ctx_srv, 0x00, sizeof( dhm_context ) );
00387 memset( &ctx_cli, 0x00, sizeof( dhm_context ) );
00388 memset( ske, 0x00, 1000 );
00389 memset( pub_cli, 0x00, 1000 );
00390 memset( sec_srv, 0x00, 1000 );
00391 memset( sec_cli, 0x00, 1000 );
00392 memset( &rnd_info, 0x00, sizeof( rnd_pseudo_info ) );
00393
00394
00395
00396
00397 TEST_ASSERT( mpi_read_string( &ctx_srv.P, radix_P, input_P ) == 0 );
00398 TEST_ASSERT( mpi_read_string( &ctx_srv.G, radix_G, input_G ) == 0 );
00399 x_size = mpi_size( &ctx_srv.P );
00400 pub_cli_len = x_size;
00401
00402
00403
00404
00405 TEST_ASSERT( dhm_make_params( &ctx_srv, x_size, ske, &ske_len, &rnd_pseudo_rand, &rnd_info ) == 0 );
00406 ske[ske_len++] = 0;
00407 ske[ske_len++] = 0;
00408 TEST_ASSERT( dhm_read_params( &ctx_cli, &p, ske + ske_len ) == 0 );
00409
00410 TEST_ASSERT( dhm_make_public( &ctx_cli, x_size, pub_cli, pub_cli_len, &rnd_pseudo_rand, &rnd_info ) == 0 );
00411 TEST_ASSERT( dhm_read_public( &ctx_srv, pub_cli, pub_cli_len ) == 0 );
00412
00413 TEST_ASSERT( dhm_calc_secret( &ctx_srv, sec_srv, &sec_srv_len, &rnd_pseudo_rand, &rnd_info ) == 0 );
00414 TEST_ASSERT( dhm_calc_secret( &ctx_cli, sec_cli, &sec_cli_len, NULL, NULL ) == 0 );
00415
00416 TEST_ASSERT( sec_srv_len == sec_cli_len );
00417 TEST_ASSERT( sec_srv_len != 0 );
00418 TEST_ASSERT( memcmp( sec_srv, sec_cli, sec_srv_len ) == 0 );
00419
00420
00421 for( i = 0; i < 3; i++ )
00422 {
00423 sec_srv_len = 1000;
00424 TEST_ASSERT( dhm_calc_secret( &ctx_srv, sec_srv, &sec_srv_len, &rnd_pseudo_rand, &rnd_info ) == 0 );
00425
00426 TEST_ASSERT( sec_srv_len == sec_cli_len );
00427 TEST_ASSERT( sec_srv_len != 0 );
00428 TEST_ASSERT( memcmp( sec_srv, sec_cli, sec_srv_len ) == 0 );
00429 }
00430
00431
00432
00433
00434 sec_cli_len = 1000;
00435 sec_srv_len = 1000;
00436 p = ske;
00437
00438 TEST_ASSERT( dhm_make_params( &ctx_srv, x_size, ske, &ske_len, &rnd_pseudo_rand, &rnd_info ) == 0 );
00439 ske[ske_len++] = 0;
00440 ske[ske_len++] = 0;
00441 TEST_ASSERT( dhm_read_params( &ctx_cli, &p, ske + ske_len ) == 0 );
00442
00443 TEST_ASSERT( dhm_make_public( &ctx_cli, x_size, pub_cli, pub_cli_len, &rnd_pseudo_rand, &rnd_info ) == 0 );
00444 TEST_ASSERT( dhm_read_public( &ctx_srv, pub_cli, pub_cli_len ) == 0 );
00445
00446 TEST_ASSERT( dhm_calc_secret( &ctx_srv, sec_srv, &sec_srv_len, &rnd_pseudo_rand, &rnd_info ) == 0 );
00447 TEST_ASSERT( dhm_calc_secret( &ctx_cli, sec_cli, &sec_cli_len, NULL, NULL ) == 0 );
00448
00449 TEST_ASSERT( sec_srv_len == sec_cli_len );
00450 TEST_ASSERT( sec_srv_len != 0 );
00451 TEST_ASSERT( memcmp( sec_srv, sec_cli, sec_srv_len ) == 0 );
00452
00453 dhm_free( &ctx_srv );
00454 dhm_free( &ctx_cli );
00455 }
00456
00457 #ifdef POLARSSL_SELF_TEST
00458 void test_suite_dhm_selftest()
00459 {
00460 TEST_ASSERT( dhm_self_test( 0 ) == 0 );
00461 }
00462 #endif
00463
00464
00465 #endif
00466 #endif
00467
00468
00469 int dep_check( char *str )
00470 {
00471 if( str == NULL )
00472 return( 1 );
00473
00474
00475
00476 return( 1 );
00477 }
00478
00479 int dispatch_test(int cnt, char *params[50])
00480 {
00481 int ret;
00482 ((void) cnt);
00483 ((void) params);
00484
00485 #if defined(TEST_SUITE_ACTIVE)
00486 if( strcmp( params[0], "dhm_do_dhm" ) == 0 )
00487 {
00488
00489 int param1;
00490 char *param2 = params[2];
00491 int param3;
00492 char *param4 = params[4];
00493
00494 if( cnt != 5 )
00495 {
00496 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 5 );
00497 return( 2 );
00498 }
00499
00500 if( verify_int( params[1], ¶m1 ) != 0 ) return( 2 );
00501 if( verify_string( ¶m2 ) != 0 ) return( 2 );
00502 if( verify_int( params[3], ¶m3 ) != 0 ) return( 2 );
00503 if( verify_string( ¶m4 ) != 0 ) return( 2 );
00504
00505 test_suite_dhm_do_dhm( param1, param2, param3, param4 );
00506 return ( 0 );
00507
00508 return ( 3 );
00509 }
00510 else
00511 if( strcmp( params[0], "dhm_selftest" ) == 0 )
00512 {
00513 #ifdef POLARSSL_SELF_TEST
00514
00515
00516 if( cnt != 1 )
00517 {
00518 fprintf( stderr, "\nIncorrect argument count (%d != %d)\n", cnt, 1 );
00519 return( 2 );
00520 }
00521
00522
00523 test_suite_dhm_selftest( );
00524 return ( 0 );
00525 #endif
00526
00527 return ( 3 );
00528 }
00529 else
00530
00531 {
00532 fprintf( stdout, "FAILED\nSkipping unknown test function '%s'\n", params[0] );
00533 fflush( stdout );
00534 return( 1 );
00535 }
00536 #else
00537 return( 3 );
00538 #endif
00539 return( ret );
00540 }
00541
00542 int get_line( FILE *f, char *buf, size_t len )
00543 {
00544 char *ret;
00545
00546 ret = fgets( buf, len, f );
00547 if( ret == NULL )
00548 return( -1 );
00549
00550 if( strlen( buf ) && buf[strlen(buf) - 1] == '\n' )
00551 buf[strlen(buf) - 1] = '\0';
00552 if( strlen( buf ) && buf[strlen(buf) - 1] == '\r' )
00553 buf[strlen(buf) - 1] = '\0';
00554
00555 return( 0 );
00556 }
00557
00558 int parse_arguments( char *buf, size_t len, char *params[50] )
00559 {
00560 int cnt = 0, i;
00561 char *cur = buf;
00562 char *p = buf, *q;
00563
00564 params[cnt++] = cur;
00565
00566 while( *p != '\0' && p < buf + len )
00567 {
00568 if( *p == '\\' )
00569 {
00570 *p++;
00571 *p++;
00572 continue;
00573 }
00574 if( *p == ':' )
00575 {
00576 if( p + 1 < buf + len )
00577 {
00578 cur = p + 1;
00579 params[cnt++] = cur;
00580 }
00581 *p = '\0';
00582 }
00583
00584 *p++;
00585 }
00586
00587
00588 for( i = 0; i < cnt; i++ )
00589 {
00590 p = params[i];
00591 q = params[i];
00592
00593 while( *p != '\0' )
00594 {
00595 if( *p == '\\' && *(p + 1) == 'n' )
00596 {
00597 p += 2;
00598 *(q++) = '\n';
00599 }
00600 else if( *p == '\\' && *(p + 1) == ':' )
00601 {
00602 p += 2;
00603 *(q++) = ':';
00604 }
00605 else if( *p == '\\' && *(p + 1) == '?' )
00606 {
00607 p += 2;
00608 *(q++) = '?';
00609 }
00610 else
00611 *(q++) = *(p++);
00612 }
00613 *q = '\0';
00614 }
00615
00616 return( cnt );
00617 }
00618
00619 int main()
00620 {
00621 int ret, i, cnt, total_errors = 0, total_tests = 0, total_skipped = 0;
00622 const char *filename = "/home/abuild/rpmbuild/BUILD/polarssl-1.3.2/tests/suites/test_suite_dhm.data";
00623 FILE *file;
00624 char buf[5000];
00625 char *params[50];
00626
00627 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
00628 unsigned char alloc_buf[1000000];
00629 memory_buffer_alloc_init( alloc_buf, sizeof(alloc_buf) );
00630 #endif
00631
00632 file = fopen( filename, "r" );
00633 if( file == NULL )
00634 {
00635 fprintf( stderr, "Failed to open\n" );
00636 return( 1 );
00637 }
00638
00639 while( !feof( file ) )
00640 {
00641 int skip = 0;
00642
00643 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
00644 break;
00645 fprintf( stdout, "%s%.66s", test_errors ? "\n" : "", buf );
00646 fprintf( stdout, " " );
00647 for( i = strlen( buf ) + 1; i < 67; i++ )
00648 fprintf( stdout, "." );
00649 fprintf( stdout, " " );
00650 fflush( stdout );
00651
00652 total_tests++;
00653
00654 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
00655 break;
00656 cnt = parse_arguments( buf, strlen(buf), params );
00657
00658 if( strcmp( params[0], "depends_on" ) == 0 )
00659 {
00660 for( i = 1; i < cnt; i++ )
00661 if( dep_check( params[i] ) != 0 )
00662 skip = 1;
00663
00664 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
00665 break;
00666 cnt = parse_arguments( buf, strlen(buf), params );
00667 }
00668
00669 if( skip == 0 )
00670 {
00671 test_errors = 0;
00672 ret = dispatch_test( cnt, params );
00673 }
00674
00675 if( skip == 1 || ret == 3 )
00676 {
00677 total_skipped++;
00678 fprintf( stdout, "----\n" );
00679 fflush( stdout );
00680 }
00681 else if( ret == 0 && test_errors == 0 )
00682 {
00683 fprintf( stdout, "PASS\n" );
00684 fflush( stdout );
00685 }
00686 else if( ret == 2 )
00687 {
00688 fprintf( stderr, "FAILED: FATAL PARSE ERROR\n" );
00689 fclose(file);
00690 exit( 2 );
00691 }
00692 else
00693 total_errors++;
00694
00695 if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
00696 break;
00697 if( strlen(buf) != 0 )
00698 {
00699 fprintf( stderr, "Should be empty %d\n", (int) strlen(buf) );
00700 return( 1 );
00701 }
00702 }
00703 fclose(file);
00704
00705 fprintf( stdout, "\n----------------------------------------------------------------------------\n\n");
00706 if( total_errors == 0 )
00707 fprintf( stdout, "PASSED" );
00708 else
00709 fprintf( stdout, "FAILED" );
00710
00711 fprintf( stdout, " (%d / %d tests (%d skipped))\n",
00712 total_tests - total_errors, total_tests, total_skipped );
00713
00714 #if defined(POLARSSL_MEMORY_BUFFER_ALLOC_C)
00715 #if defined(POLARSSL_MEMORY_DEBUG)
00716 memory_buffer_alloc_status();
00717 #endif
00718 memory_buffer_alloc_free();
00719 #endif
00720
00721 return( total_errors != 0 );
00722 }
00723
00724