开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
ytest.c
资源名称：rtsp-1.0.1.tar.gz　[点击查看]
上传用户：sy_wanhua
上传日期：2013-07-25
资源大小：3048k
文件大小：13k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

C/C++

ytest.c：源码内容
  1. /* -*- Mode: C; c-file-style: "bsd" -*- */
  2. /*
  3.  * Yarrow - Cryptographic Pseudo-Random Number Generator
  4.  * Copyright (c) 2000 Zero-Knowledge Systems, Inc.
  5.  *
  6.  * See the accompanying LICENSE file for license information.
  7.  */
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <string.h>
  12. #include <errno.h>
  13. #include "yarrow.h"
  14. #include "yexcep.h"
  15. #include "ystate.h"
  17. void hex_print( FILE* f, const char* var, void* data, size_t size );
  18. void dump_yarrow_state( FILE* f, Yarrow_CTX* y );
  20. #define YARROW_SEED_FILE "seed"
  22. static void print_yarrow_status( Yarrow_CTX *y )
  23. {
  24.     int sid, pool;
  25.     Source* source;
  27.     for ( pool = 0; pool < 2; pool++ )
  28.     {
  29. printf( " %s: ", pool == YARROW_SLOW_POOL ? "slow" : "fast" );
  30. for ( sid = 0; sid < y->num_sources; sid++ )
  31. {
  32.     source = &y->source[ sid ];
  33.     printf( "#%d=%d/%d, ", sid, source->entropy[pool], 
  34.     pool == YARROW_SLOW_POOL ? 
  35.     y->slow_thresh : y->fast_thresh );
  36. }
  37.     }
  38.     printf( "n" );
  39. }
  41. int yarrow_verbose = 0;
  42. #define VERBOSE( x ) if ( yarrow_verbose ) { x }
  44. int Instrumented_Yarrow_Input( Yarrow_CTX* y, int sid, void* sample,
  45.        size_t size, int entropy )
  46. {
  47.     int ret;
  49.     VERBOSE( printf( "Yarrow_Input( #%d, %d bits, %s ) = [", sid, entropy, 
  50.      y->source[sid].pool == 
  51.      YARROW_SLOW_POOL ? "slow" : "fast" ); );
  52.     ret = Yarrow_Input( y, sid, sample, size, entropy );
  54.     VERBOSE( printf( "%s]n", Yarrow_Str_Error( ret ) ); );
  55.     VERBOSE( print_yarrow_status( y ); );
  56.     return (ret);
  57. }
  59. typedef int (*test_fn)( void );
  61. int test_1( void );
  62. int test_2( void );
  63. int test_3( void );
  64. int test_4( void );
  65. int test_5( void );
  67. test_fn test_func[] =
  68. {
  69.     test_1, test_2, test_3, test_4, test_5
  70. };
  72. #define num_tests ( sizeof(test_func) / sizeof(test_fn) )
  74. int do_test( int t )
  75. {
  76.     EXCEP_DECL;
  77.     int ret;
  79.     printf( "doing test %d ... ", t ); fflush( stdout );
  80.     ret = test_func[ t-1 ]();
  81.     VERBOSE( printf( "ndone test %d ", t ); );
  82.     printf( "[%s]n", Yarrow_Str_Error( ret ) ); fflush( stdout );
  83.     THROW( ret );
  85.  CATCH:
  86.     THROW( EXCEP_BOOL );
  87.     EXCEP_RET;
  88. }
  90. int main( int argc, char* argv[] )
  91. {
  92.     EXCEP_DECL;
  93.     int test = 0;
  94.     char** argvp;
  95.     char* arg;
  96.     char* conv_ok = NULL;
  97.     int ok = YARROW_OK;
  98.     int done_some_tests = 0;
  99.     int i;
  100.     int ret;
  102. #if defined(__MWERKS__) && defined(macintosh)
  103.     argc = ccommand(&argv);
  104. #endif
  105.     
  106.     for ( argvp = argv+1, i = 1; i < argc; i++, argvp++ )
  107.     {
  108. arg = *argvp;
  109. if ( arg[0] == '-' ) 
  110. {
  111.     switch ( arg[1] )
  112.     {
  113.     case 'v': yarrow_verbose = 1; continue; 
  114.     default: fprintf( stderr, "usage: test [-v] [[test] ... ]n" );
  115. THROW( YARROW_FAIL );
  116.     }
  117. }
  118. conv_ok = NULL;
  119. test = strtoul( arg, &conv_ok, 10 );
  120. if ( !conv_ok || test < 1 || test > num_tests )
  121. {
  122.     fprintf( stderr, "usage: test [-v] [[test] ... ]n" );
  123.     THROW( YARROW_FAIL );
  124. }
  125. else
  126. {
  127.     ret = do_test( test );
  128.     if ( ok ) { ok = ret; }
  129.     done_some_tests = 1;
  130. }
  131.     }
  133.     if ( !done_some_tests )
  134.     {
  135. for ( i = 1; i <= num_tests; i++ )
  136. {
  137.     ret = do_test( i );
  138.     if ( ok ) { ok = ret; }
  139. }
  140.     }
  141.     THROW( ok );
  143.  CATCH:
  144.     switch (EXCEPTION)
  145.     {
  146.     case YARROW_OK:
  147. exit( EXIT_SUCCESS );
  148.     default:
  149. exit( EXIT_FAILURE );
  150.     }
  151. }
  153. int printhex( FILE* f, byte* bin, int size )
  154. {
  155.     int i;
  157.     for ( i = 0; i < size; i++ )
  158.     {
  159. if ( fprintf( f, "%02x", bin[i] ) != 2 ) { return YARROW_FAIL; }
  160.     }
  161.     return YARROW_OK;
  162. }
  164. int hex2bin( byte* bin, const char* hex, int size )
  165. {
  166.     int i, d;
  167.     char pair[3];
  169.     if ( strlen( hex ) != size * 2 ) { return YARROW_FAIL; }
  170.     pair[2]='';
  171.     for ( i = 0; i < size; i++ )
  172.     {
  173. pair[0] = hex[i*2];
  174. pair[1] = hex[i*2+1];
  175. if ( sscanf( pair, "%x", &d ) < 1 ) { return YARROW_FAIL; }
  176. bin[i] = (byte)d;
  177.     }
  178.     return YARROW_OK;
  179. }
  181. typedef struct 
  182. {
  183.     char* string;
  184.     int reps;
  185.     char* result;
  186. } Hash_Test;
  188. int test_1( void )
  189. {
  190.     EXCEP_DECL;
  191.     byte digest[ HASH_DIGEST_SIZE ];
  192.     byte expected_digest[ HASH_DIGEST_SIZE ];
  193.     HASH_CTX hash;
  194.     int i, j;
  196. #if defined(YARROW_HASH_SHA1)
  198.     /* test vectors from FIPS-180-1 */
  200.     Hash_Test hash_test[] = 
  201.     {
  202. { "abc", 1, 
  203.   "A9993E364706816ABA3E25717850C26C9CD0D89D" } ,
  205. { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 1,
  206.   "84983E441C3BD26EBAAE4AA1F95129E5E54670F1" },
  208. { "aaaaaaaaaa", 100000, 
  209.   "34AA973CD4C4DAA4F61EEB2BDBAD27316534016F" }
  210.     };
  212.     VERBOSE( printf( "nsha1 testnn" ); );
  214. #elif defined(YARROW_HASH_MD5)
  216.     /* test vectors from RFC1321 */
  218.     Hash_Test hash_test[] = 
  219.     {
  220. { "", 1, "d41d8cd98f00b204e9800998ecf8427e" },
  221. { "a", 1, "0cc175b9c0f1b6a831c399e269772661" },
  222. { "abc", 1, "900150983cd24fb0d6963f7d28e17f72" },
  223. { "message digest", 1, "f96b697d7cb7938d525a2f31aaf161d0" },
  225. { "abcdefghijklmnopqrstuvwxyz", 1, 
  226.   "c3fcd3d76192e4007dfb496cca67e13b" },
  228. { "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", 1,
  229.   "d174ab98d277d9f5a5611c2c9f419d9f" },
  231. { "123456789012345678901234567890123456789012345678901234567890123456"
  232.   "78901234567890", 1, 
  233.   "57edf4a22be3c955ac49da2e2107b67a" }
  234.     };
  236.     VERBOSE( printf( "nmd5 testnn" ); );
  238. #else
  239.     VERBOSE( printf( "nunknown hash functionnn" ); );
  240.     THROW( YARROW_NOT_IMPL );
  241. #endif
  243. #define hash_test_num_tests ( sizeof( hash_test ) / sizeof( Hash_Test ) )
  245.     for ( i = 0; i < hash_test_num_tests; i++ )
  246.     {
  247. TRY( hex2bin( expected_digest, hash_test[ i ].result, 
  248.       HASH_DIGEST_SIZE ) );
  249. VERBOSE( printf( "test %cn", 'a'+i );
  250.  printf( "HASH( "%s" ", hash_test[ i ].string );
  251.  if ( hash_test[ i ].reps > 1 ) 
  252.          { 
  253.      printf( "x%d ", hash_test[ i ].reps );
  254.  }
  255.  printf( ")n" ); 
  256.  printf( "expected = " );
  257.  printhex( stdout, expected_digest, HASH_DIGEST_SIZE );
  258.  printf( "n" ); );
  260. HASH_Init( &hash );
  261. for ( j = 0; j < hash_test[ i ].reps; j++ )
  262. {
  263.     HASH_Update( &hash, hash_test[ i ].string, 
  264.  strlen( hash_test[ i ].string ) );
  265. }
  266. HASH_Final( &hash, digest );
  267. VERBOSE( printf( "result   = " );
  268.  printhex( stdout, digest, HASH_DIGEST_SIZE );
  269.  printf( "n" ); );
  270. if ( memcmp( digest, expected_digest, HASH_DIGEST_SIZE ) != 0 )
  271. {
  272.     THROW( YARROW_FAIL );
  273. }
  274.     }
  276.  CATCH:
  277.     EXCEP_RET;
  278. }
  280. int test_2( void )
  281. {
  282.     EXCEP_DECL;
  284. #if defined(YARROW_CIPHER_3DES)
  285.     VERBOSE( printf( "n3des testnn" ); );
  286.     THROW( YARROW_NOT_IMPL );
  287. #elif defined(YARROW_CIPHER_BLOWFISH)
  288.     VERBOSE( printf( "nblowfish testnn" ); );
  289.     THROW( YARROW_NOT_IMPL );
  290. #elif defined(YARROW_CIPHER_IDEA)
  291.     VERBOSE( printf( "nidea testnn" ); );
  292.     THROW( YARROW_NOT_IMPL );
  293. #else
  294.     VERBOSE( printf( "nunknown encryption functionnn" ); );
  295.     THROW( YARROW_NOT_IMPL );
  296. #endif
  297.  CATCH:
  298.     EXCEP_RET;
  299. }
  301. int test_3( void )
  302. {
  303.     EXCEP_DECL;
  305. #if !defined(YARROW_CIPHER_3DES) || !defined(YARROW_HASH_SHA1)
  306.     VERBOSE( printf( "nnot Yarrow-SHA1-3DES (aka Yarrow-160)nn" ); );
  307.     THROW( YARROW_NOT_IMPL );
  308. #endif
  310.     VERBOSE( printf( "nYarrow_Stretchnn" ); );
  311.     THROW( YARROW_NOT_IMPL );
  312.     
  313.  CATCH:
  314.     EXCEP_RET;
  315. }
  317. int test_4( void )
  318. {
  319.     EXCEP_DECL;
  321. #if defined( YARROW_SAVE_STATE )
  322.     if ( unlink( YARROW_SEED_FILE ) != 0 && errno != ENOENT ) 
  323.     { 
  324. THROW( YARROW_STATE_ERROR );
  325.     }
  326. #endif
  327.     TRY( test_general() );
  329.  CATCH:
  330.     EXCEP_RET;
  331. }
  333. int state_to_load = 0;
  335. int test_5( void )
  336. {
  337.     EXCEP_DECL;
  339.     Yarrow_STATE state;
  340.     byte* state_b = (byte*) &state;
  341.     int i;
  343. #if !defined( YARROW_SAVE_STATE )
  344.     VERBOSE( print( "state saving off, so test not relevantn" ); );
  345.     THROW( YARROW_OK );
  346. #endif
  347.     
  348.     for ( i = 0; i < sizeof( state ); i++ )
  349.     {
  350. state_b[ i ] = i % 256;
  351.     }
  352.     TRY( STATE_Save( YARROW_SEED_FILE, &state ) );
  353.     state_to_load = 1;
  354.     TRY( test_general() );
  356.  CATCH:
  357.     state_to_load = 0;
  358.     EXCEP_RET;
  359. }
  361. int test_general( void )
  362. {
  363.     EXCEP_DECL;
  364.     Yarrow_CTX yarrow;
  365.     int initialized = 0;
  366.     unsigned user, mouse, keyboard;
  367.     int i, ret;
  368.     byte user_sample[ 20 ];
  369.     byte mouse_sample[ 4 ];
  370.     byte keyboard_sample[ 2 ];
  371.     byte random[ 30 ];
  372.     byte expected_random[ 30 ];
  373.     byte junk[ 48 ];
  374.     Yarrow_STATE state;
  376.     const char* expected_random_no_load_str = 
  377. "0573f728da11381cfc7db5d386ad9a2f30e75c7df0411f307ed3c1000fdb";
  378.     const char* expected_random_with_load_str = 
  379. "a02c2492cca9ac5f1244eb05cbccc9bc17cfd095f35307927ef7e2c5f881";
  381.     TRY( hex2bin( expected_random, 
  382.   state_to_load ? expected_random_with_load_str :
  383.   expected_random_no_load_str, 
  384.   sizeof( expected_random ) ) );
  386.     memset( user_sample,     3, sizeof( user_sample ) );
  387.     memset( mouse_sample,    1, sizeof( mouse_sample ) );
  388.     memset( keyboard_sample, 2, sizeof( keyboard_sample ) );
  390.     VERBOSE( printf( "nGeneral workout test" ); 
  391.      if ( state_to_load ) { printf( " with state to load" ); }
  392.      printf( "nn" ); );
  394.     if ( !state_to_load )
  395.     {
  396. ret = STATE_Load( YARROW_SEED_FILE, &state );
  397. if ( ret == YARROW_OK )
  398. {
  399.     VERBOSE( printf( "found state where there should be nonen" ); );
  400.     THROW( YARROW_STATE_ERROR );
  401. }
  402.     }
  404.     VERBOSE( printf( "Yarrow_Init() = [" ); );
  405.     ret = Yarrow_Init( &yarrow, YARROW_SEED_FILE );
  406.     VERBOSE( printf( "%s]n", Yarrow_Str_Error( ret ) ); );
  408.     if ( ret != YARROW_OK && ret != YARROW_NOT_SEEDED ) { THROW( ret ); }
  409.     initialized = 1;
  411. #if defined( YARROW_DEBUG )
  412.     dump_yarrow_state( stdout, &yarrow );
  413. #endif
  415.     ret = Yarrow_New_Source( &yarrow, &user );
  416.     VERBOSE( printf( "Yarrow_New_Source() = [%s]n",
  417.      Yarrow_Str_Error( ret ) ); );
  418.     if ( ret != YARROW_OK ) { THROW( ret ); }
  419.   
  420.     VERBOSE( printf( "Yarrow_Poll( #%d ) = [", user ); );
  421.     ret = Yarrow_Poll( &yarrow, user );
  422.     VERBOSE( printf( "%s]n", Yarrow_Str_Error( ret ) ); );
  424.     ret = Yarrow_New_Source( &yarrow, &mouse );
  425.     VERBOSE( printf( "Yarrow_New_Source() = [%s]n", 
  426.      Yarrow_Str_Error( ret ) ); );
  427.     if ( ret != YARROW_OK ) { THROW( ret ); }
  429.     ret = Yarrow_New_Source( &yarrow, &keyboard );
  430.     VERBOSE( printf( "Yarrow_New_Source() = [%s]n", 
  431.      Yarrow_Str_Error( ret ) ); );
  432.     if ( ret != YARROW_OK ) { THROW( ret ); }
  434. /*  prematurely try to draw output, to check failure when no
  435.  *  seed file, or state saving turned off
  436.  */
  438.     VERBOSE( printf( "Yarrow_Output( %d ) = [", (int)sizeof( random ) ); );
  439.     ret = Yarrow_Output( &yarrow, random, sizeof( random ) );
  440.     VERBOSE( printf( "%s]n", Yarrow_Str_Error( ret ) ); );
  442. /*   do it twice so that we some slow samples 
  443.  *   (first sample goes to fast pool, and then samples alternate)
  444.  */
  446.     for ( i = 0; i < 2; i++ )
  447.     {
  448. TRY( Instrumented_Yarrow_Input( &yarrow, mouse, mouse_sample, 
  449. sizeof( mouse_sample ), 2 ) );
  451. TRY( Instrumented_Yarrow_Input( &yarrow, keyboard, keyboard_sample, 
  452. sizeof( keyboard_sample ), 2 ) );
  454. TRY( Instrumented_Yarrow_Input( &yarrow, user, user_sample, 
  455. sizeof( user_sample ), 2 ) );
  456.     }
  458. #if defined( YARROW_DEBUG )
  459.     dump_yarrow_state( stdout, &yarrow );
  460. #endif
  462.     VERBOSE( printf( "nInduce user source (#%d) to reach "
  463.      "slow thresholdnn", user ); );
  465.     /* induce fast reseed */
  467.     for ( i = 0; i < 7; i++ )
  468.     {
  469. TRY( Instrumented_Yarrow_Input( &yarrow, user, user_sample, 
  470. sizeof( user_sample ), 
  471. sizeof( user_sample ) * 3 ) );
  472.     }
  474.     VERBOSE( printf( "nInduce mouse source (#%d) to reach "
  475.      "slow threshold reseednn", mouse ); );
  477.     /* induce slow reseed, by triggering a second source to reach it's
  478.        threshold */
  480.     for ( i = 0; i < 40; i++ )
  481.     {
  482. TRY( Instrumented_Yarrow_Input( &yarrow, mouse, mouse_sample, 
  483. sizeof( mouse_sample ), 
  484. sizeof( mouse_sample )*2 ) );
  485.     }
  487.     VERBOSE( printf( "nProduce some outputnn" ); );
  489.     for ( i = 0; i < 30; i++ )
  490.     {
  491. VERBOSE( printf( "Yarrow_Output( %d ) = [", (int)sizeof( junk ) ); );
  492. ret = Yarrow_Output( &yarrow, junk, sizeof( junk ) );
  493. VERBOSE( printf( "%s]n", Yarrow_Str_Error( ret ) ); );
  494. if ( ret != YARROW_OK ) { THROW( ret ); }
  495.     }
  497.     memset( junk, 0, sizeof( junk ) );
  499.     VERBOSE( printf( "nTrigger some fast and slow reseedsnn" ); );
  501.     for ( i = 0; i < 30; i++ )
  502.     {
  503. /* odd input to a different source so there are some slow reseeds */
  505. if ( i % 16 == 0 )
  506. {
  507.     TRY( Instrumented_Yarrow_Input( &yarrow, mouse, junk, 
  508.     sizeof( junk ), 
  509.     sizeof( junk ) * 3 ) );
  510. }
  511. else
  512. {
  513.     TRY( Instrumented_Yarrow_Input( &yarrow, user, junk, 
  514.     sizeof( junk ), 
  515.     sizeof( junk ) * 3 ) );
  516. }
  517.     }
  519.     VERBOSE( printf( "nPrint some random outputnn" ); );
  520.     
  521.     VERBOSE( hex_print( stdout, "expected random", expected_random,
  522. sizeof( expected_random ) ); );
  523.     VERBOSE( printf( "Yarrow_Output( %d ) = [", (int)sizeof( random ) ); );
  524.     ret = Yarrow_Output( &yarrow, random, sizeof( random ) );
  525.     VERBOSE( printf( "%s]n", Yarrow_Str_Error( ret ) ); );
  527.     VERBOSE( hex_print( stdout, "result   random", random,
  528. sizeof( random ) ); );
  530.     if ( ret != YARROW_OK )
  531.     {
  532. THROW( ret );
  533.     }
  535.     VERBOSE( printf( "nClose down Yarrownn" ); );
  537.  CATCH:
  538.     if ( initialized )
  539.     {
  540. VERBOSE( printf( "Yarrow_Final() = [" ); );
  541. ret = Yarrow_Final( &yarrow );
  542. VERBOSE( printf( "%s]n", Yarrow_Str_Error( ret ) ); );
  543. THROW( ret );
  544.     }
  545.     EXCEP_RET;
  546. }
  548. void hex_print( FILE* f, const char* var, void* data, size_t size )
  549. {
  550.     const char* conv = "0123456789abcdef";
  551.     size_t i;
  552.     char* p = (char*) data;
  553.     char c, d;
  554.     
  555.     fprintf( f, var );
  556.     fprintf( f, " = " );
  557.     for ( i = 0; i < size; i++ )
  558.     {
  559. c = conv[ (p[ i ] >> 4) & 0xf ];
  560. d = conv[ p[ i ] & 0xf ];
  561. fprintf( f, "%c%c", c, d );
  562.     }
  563.     fprintf( f, "n" );
  564. }
  566. void dump_yarrow_state( FILE* f, Yarrow_CTX* y )
  567. {
  568.     fprintf( f, "===Yarrow State===n" );
  569.     hex_print( f, "C", y->C, sizeof( y->C ) );
  570.     hex_print( f, "K", y->K, sizeof( y->K ) );
  571. }