third_party/mbedtls/repo/tests/suites/test_suite_md.function

   1 /* BEGIN_HEADER */
   2 #include "mbedtls/md.h"
   3 /* END_HEADER */
   4
   5 /* BEGIN_DEPENDENCIES
   6  * depends_on:MBEDTLS_MD_C
   7  * END_DEPENDENCIES
   8  */
   9
  10 /* BEGIN_CASE */
  11 void mbedtls_md_process(  )
  12 {
  13     const int *md_type_ptr;
  14     const mbedtls_md_info_t *info;
  15     mbedtls_md_context_t ctx;
  16     unsigned char buf[150];
  17
  18     mbedtls_md_init( &ctx );
  19
  20     /*
  21      * Very minimal testing of mbedtls_md_process, just make sure the various
  22      * xxx_process_wrap() function pointers are valid. (Testing that they
  23      * indeed do the right thing whould require messing with the internal
  24      * state of the underlying mbedtls_md/sha context.)
  25      *
  26      * Also tests that mbedtls_md_list() only returns valid MDs.
  27      */
  28     for( md_type_ptr = mbedtls_md_list(); *md_type_ptr != 0; md_type_ptr++ )
  29     {
  30         info = mbedtls_md_info_from_type( *md_type_ptr );
  31         TEST_ASSERT( info != NULL );
  32         TEST_ASSERT( mbedtls_md_setup( &ctx, info, 0 ) == 0 );
  33         TEST_ASSERT( mbedtls_md_process( &ctx, buf ) == 0 );
  34         mbedtls_md_free( &ctx );
  35     }
  36
  37 exit:
  38     mbedtls_md_free( &ctx );
  39 }
  40 /* END_CASE */
  41
  42 /* BEGIN_CASE */
  43 void md_null_args(  )
  44 {
  45     mbedtls_md_context_t ctx;
  46     const mbedtls_md_info_t *info = mbedtls_md_info_from_type( *( mbedtls_md_list() ) );
  47     unsigned char buf[1] = { 0 };
  48
  49     mbedtls_md_init( &ctx );
  50
  51     TEST_ASSERT( mbedtls_md_get_size( NULL ) == 0 );
  52     TEST_ASSERT( mbedtls_md_get_type( NULL ) == MBEDTLS_MD_NONE );
  53     TEST_ASSERT( mbedtls_md_get_name( NULL ) == NULL );
  54
  55     TEST_ASSERT( mbedtls_md_info_from_string( NULL ) == NULL );
  56
  57     TEST_ASSERT( mbedtls_md_setup( &ctx, NULL, 0 ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
  58     TEST_ASSERT( mbedtls_md_setup( NULL, info, 0 ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
  59
  60     TEST_ASSERT( mbedtls_md_starts( NULL ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
  61     TEST_ASSERT( mbedtls_md_starts( &ctx ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
  62
  63     TEST_ASSERT( mbedtls_md_update( NULL, buf, 1 ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
  64     TEST_ASSERT( mbedtls_md_update( &ctx, buf, 1 ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
  65
  66     TEST_ASSERT( mbedtls_md_finish( NULL, buf ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
  67     TEST_ASSERT( mbedtls_md_finish( &ctx, buf ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
  68
  69     TEST_ASSERT( mbedtls_md( NULL, buf, 1, buf ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
  70
  71 #if defined(MBEDTLS_FS_IO)
  72     TEST_ASSERT( mbedtls_md_file( NULL, "", buf ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
  73 #endif
  74
  75     TEST_ASSERT( mbedtls_md_hmac_starts( NULL, buf, 1 )
  76                  == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
  77     TEST_ASSERT( mbedtls_md_hmac_starts( &ctx, buf, 1 )
  78                  == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
  79
  80     TEST_ASSERT( mbedtls_md_hmac_update( NULL, buf, 1 )
  81                  == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
  82     TEST_ASSERT( mbedtls_md_hmac_update( &ctx, buf, 1 )
  83                  == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
  84
  85     TEST_ASSERT( mbedtls_md_hmac_finish( NULL, buf )
  86                  == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
  87     TEST_ASSERT( mbedtls_md_hmac_finish( &ctx, buf )
  88                  == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
  89
  90     TEST_ASSERT( mbedtls_md_hmac_reset( NULL ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
  91     TEST_ASSERT( mbedtls_md_hmac_reset( &ctx ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
  92
  93     TEST_ASSERT( mbedtls_md_hmac( NULL, buf, 1, buf, 1, buf )
  94                  == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
  95
  96     TEST_ASSERT( mbedtls_md_process( NULL, buf ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
  97     TEST_ASSERT( mbedtls_md_process( &ctx, buf ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
  98
  99     /* Ok, this is not NULL arg but NULL return... */
 100     TEST_ASSERT( mbedtls_md_info_from_type( MBEDTLS_MD_NONE ) == NULL );
 101     TEST_ASSERT( mbedtls_md_info_from_string( "no such md" ) == NULL );
 102 }
 103 /* END_CASE */
 104
 105 /* BEGIN_CASE */
 106 void md_info( int md_type, char * md_name, int md_size )
 107 {
 108     const mbedtls_md_info_t *md_info;
 109     const int *md_type_ptr;
 110     int found;
 111
 112     md_info = mbedtls_md_info_from_type( md_type );
 113     TEST_ASSERT( md_info != NULL );
 114     TEST_ASSERT( md_info == mbedtls_md_info_from_string( md_name ) );
 115
 116     TEST_ASSERT( mbedtls_md_get_type( md_info ) == (mbedtls_md_type_t) md_type );
 117     TEST_ASSERT( mbedtls_md_get_size( md_info ) == (unsigned char) md_size );
 118     TEST_ASSERT( strcmp( mbedtls_md_get_name( md_info ), md_name ) == 0 );
 119
 120     found = 0;
 121     for( md_type_ptr = mbedtls_md_list(); *md_type_ptr != 0; md_type_ptr++ )
 122         if( *md_type_ptr == md_type )
 123             found = 1;
 124     TEST_ASSERT( found == 1 );
 125 }
 126 /* END_CASE */
 127
 128 /* BEGIN_CASE */
 129 void md_text( char * text_md_name, char * text_src_string,
 130               data_t * hex_hash_string )
 131 {
 132     char md_name[100];
 133     unsigned char src_str[1000];
 134     unsigned char output[100];
 135     const mbedtls_md_info_t *md_info = NULL;
 136
 137     memset( md_name, 0x00, 100 );
 138     memset( src_str, 0x00, 1000 );
 139     memset( output, 0x00, 100 );
 140
 141     strncpy( (char *) src_str, text_src_string, sizeof( src_str ) - 1 );
 142     strncpy( (char *) md_name, text_md_name, sizeof( md_name ) - 1 );
 143     md_info = mbedtls_md_info_from_string(md_name);
 144     TEST_ASSERT( md_info != NULL );
 145
 146     TEST_ASSERT ( 0 == mbedtls_md( md_info, src_str, strlen( (char *) src_str ), output ) );
 147
 148     TEST_ASSERT( hexcmp( output, hex_hash_string->x, mbedtls_md_get_size( md_info ), hex_hash_string->len ) == 0 );
 149 }
 150 /* END_CASE */
 151
 152 /* BEGIN_CASE */
 153 void md_hex( char * text_md_name, data_t * src_str,
 154              data_t * hex_hash_string )
 155 {
 156     char md_name[100];
 157     unsigned char output[100];
 158     const mbedtls_md_info_t *md_info = NULL;
 159
 160     memset( md_name, 0x00, 100 );
 161     memset( output, 0x00, 100 );
 162
 163     strncpy( (char *) md_name, text_md_name, sizeof( md_name ) - 1 );
 164     md_info = mbedtls_md_info_from_string( md_name );
 165     TEST_ASSERT( md_info != NULL );
 166
 167     TEST_ASSERT ( 0 == mbedtls_md( md_info, src_str->x, src_str->len, output ) );
 168
 169
 170     TEST_ASSERT( hexcmp( output, hex_hash_string->x,
 171                  mbedtls_md_get_size( md_info ), hex_hash_string->len ) == 0 );
 172 }
 173 /* END_CASE */
 174
 175 /* BEGIN_CASE */
 176 void md_text_multi( char * text_md_name, char * text_src_string,
 177                     data_t * hex_hash_string )
 178 {
 179     char md_name[100];
 180     unsigned char src_str[1000];
 181     unsigned char output[100];
 182     int halfway, len;
 183
 184     const mbedtls_md_info_t *md_info = NULL;
 185     mbedtls_md_context_t ctx, ctx_copy;
 186
 187     mbedtls_md_init( &ctx );
 188     mbedtls_md_init( &ctx_copy );
 189
 190     memset( md_name, 0x00, 100 );
 191     memset( src_str, 0x00, 1000 );
 192     memset( output, 0x00, 100 );
 193
 194     strncpy( (char *) src_str, text_src_string, sizeof(src_str) - 1 );
 195     strncpy( (char *) md_name, text_md_name, sizeof(md_name) - 1 );
 196     len = strlen( (char *) src_str );
 197     halfway = len / 2;
 198
 199     md_info = mbedtls_md_info_from_string(md_name);
 200     TEST_ASSERT( md_info != NULL );
 201     TEST_ASSERT ( 0 == mbedtls_md_setup( &ctx, md_info, 0 ) );
 202     TEST_ASSERT ( 0 == mbedtls_md_setup( &ctx_copy, md_info, 0 ) );
 203
 204     TEST_ASSERT ( 0 == mbedtls_md_starts( &ctx ) );
 205     TEST_ASSERT ( ctx.md_ctx != NULL );
 206     TEST_ASSERT ( 0 == mbedtls_md_update( &ctx, src_str, halfway ) );
 207     TEST_ASSERT ( 0 == mbedtls_md_clone( &ctx_copy, &ctx ) );
 208
 209     TEST_ASSERT ( 0 == mbedtls_md_update( &ctx, src_str + halfway, len - halfway ) );
 210     TEST_ASSERT ( 0 == mbedtls_md_finish( &ctx, output ) );
 211     TEST_ASSERT( hexcmp( output, hex_hash_string->x,
 212                  mbedtls_md_get_size( md_info ), hex_hash_string->len) == 0 );
 213
 214     /* Test clone */
 215     memset( output, 0x00, 100 );
 216
 217     TEST_ASSERT ( 0 == mbedtls_md_update( &ctx_copy, src_str + halfway, len - halfway ) );
 218     TEST_ASSERT ( 0 == mbedtls_md_finish( &ctx_copy, output ) );
 219     TEST_ASSERT( hexcmp( output, hex_hash_string->x, mbedtls_md_get_size( md_info ), hex_hash_string->len ) == 0 );
 220
 221 exit:
 222     mbedtls_md_free( &ctx );
 223     mbedtls_md_free( &ctx_copy );
 224 }
 225 /* END_CASE */
 226
 227 /* BEGIN_CASE */
 228 void md_hex_multi( char * text_md_name, data_t * src_str,
 229                    data_t * hex_hash_string )
 230 {
 231     char md_name[100];
 232     unsigned char output[100];
 233     const mbedtls_md_info_t *md_info = NULL;
 234     mbedtls_md_context_t ctx, ctx_copy;
 235     int halfway;
 236
 237     mbedtls_md_init( &ctx );
 238     mbedtls_md_init( &ctx_copy );
 239
 240     memset( md_name, 0x00, 100 );
 241     memset( output, 0x00, 100 );
 242
 243     strncpy( (char *) md_name, text_md_name, sizeof( md_name ) - 1 );
 244     md_info = mbedtls_md_info_from_string(md_name);
 245     TEST_ASSERT( md_info != NULL );
 246     TEST_ASSERT ( 0 == mbedtls_md_setup( &ctx, md_info, 0 ) );
 247     TEST_ASSERT ( 0 == mbedtls_md_setup( &ctx_copy, md_info, 0 ) );
 248
 249     halfway = src_str->len / 2;
 250
 251     TEST_ASSERT ( 0 == mbedtls_md_starts( &ctx ) );
 252     TEST_ASSERT ( ctx.md_ctx != NULL );
 253     TEST_ASSERT ( 0 == mbedtls_md_update( &ctx, src_str->x, halfway ) );
 254     TEST_ASSERT ( 0 == mbedtls_md_clone( &ctx_copy, &ctx ) );
 255
 256     TEST_ASSERT ( 0 == mbedtls_md_update( &ctx, src_str->x + halfway, src_str->len - halfway) );
 257     TEST_ASSERT ( 0 == mbedtls_md_finish( &ctx, output ) );
 258     TEST_ASSERT( hexcmp( output, hex_hash_string->x, mbedtls_md_get_size( md_info ), hex_hash_string->len ) == 0 );
 259
 260     /* Test clone */
 261     memset( output, 0x00, 100 );
 262
 263     TEST_ASSERT ( 0 == mbedtls_md_update( &ctx_copy, src_str->x + halfway, src_str->len - halfway ) );
 264     TEST_ASSERT ( 0 == mbedtls_md_finish( &ctx_copy, output ) );
 265     TEST_ASSERT( hexcmp( output, hex_hash_string->x, mbedtls_md_get_size( md_info ), hex_hash_string->len ) == 0 );
 266
 267 exit:
 268     mbedtls_md_free( &ctx );
 269     mbedtls_md_free( &ctx_copy );
 270 }
 271 /* END_CASE */
 272
 273 /* BEGIN_CASE */
 274 void mbedtls_md_hmac( char * text_md_name, int trunc_size,
 275                       data_t * key_str, data_t * src_str,
 276                       data_t * hex_hash_string )
 277 {
 278     char md_name[100];
 279     unsigned char output[100];
 280     const mbedtls_md_info_t *md_info = NULL;
 281
 282     memset( md_name, 0x00, 100 );
 283     memset( output, 0x00, 100 );
 284
 285     strncpy( (char *) md_name, text_md_name, sizeof( md_name ) - 1 );
 286     md_info = mbedtls_md_info_from_string( md_name );
 287     TEST_ASSERT( md_info != NULL );
 288
 289
 290     TEST_ASSERT ( mbedtls_md_hmac( md_info, key_str->x, key_str->len, src_str->x, src_str->len, output ) == 0 );
 291
 292     TEST_ASSERT( hexcmp( output, hex_hash_string->x, trunc_size, hex_hash_string->len ) == 0 );
 293 }
 294 /* END_CASE */
 295
 296 /* BEGIN_CASE */
 297 void md_hmac_multi( char * text_md_name, int trunc_size, data_t * key_str,
 298                     data_t * src_str, data_t * hex_hash_string )
 299 {
 300     char md_name[100];
 301     unsigned char output[100];
 302     const mbedtls_md_info_t *md_info = NULL;
 303     mbedtls_md_context_t ctx;
 304     int halfway;
 305
 306     mbedtls_md_init( &ctx );
 307
 308     memset( md_name, 0x00, 100 );
 309     memset( output, 0x00, 100 );
 310
 311     strncpy( (char *) md_name, text_md_name, sizeof( md_name ) - 1 );
 312     md_info = mbedtls_md_info_from_string( md_name );
 313     TEST_ASSERT( md_info != NULL );
 314     TEST_ASSERT ( 0 == mbedtls_md_setup( &ctx, md_info, 1 ) );
 315
 316     halfway = src_str->len / 2;
 317
 318     TEST_ASSERT ( 0 == mbedtls_md_hmac_starts( &ctx, key_str->x, key_str->len ) );
 319     TEST_ASSERT ( ctx.md_ctx != NULL );
 320     TEST_ASSERT ( 0 == mbedtls_md_hmac_update( &ctx, src_str->x, halfway ) );
 321     TEST_ASSERT ( 0 == mbedtls_md_hmac_update( &ctx, src_str->x + halfway, src_str->len - halfway ) );
 322     TEST_ASSERT ( 0 == mbedtls_md_hmac_finish( &ctx, output ) );
 323
 324     TEST_ASSERT( hexcmp( output, hex_hash_string->x, trunc_size, hex_hash_string->len ) == 0 );
 325
 326     /* Test again, for reset() */
 327     memset( output, 0x00, 100 );
 328
 329     TEST_ASSERT ( 0 == mbedtls_md_hmac_reset( &ctx ) );
 330     TEST_ASSERT ( 0 == mbedtls_md_hmac_update( &ctx, src_str->x, halfway ) );
 331     TEST_ASSERT ( 0 == mbedtls_md_hmac_update( &ctx, src_str->x + halfway, src_str->len - halfway ) );
 332     TEST_ASSERT ( 0 == mbedtls_md_hmac_finish( &ctx, output ) );
 333
 334     TEST_ASSERT( hexcmp( output, hex_hash_string->x, trunc_size, hex_hash_string->len ) == 0 );
 335
 336 exit:
 337     mbedtls_md_free( &ctx );
 338 }
 339 /* END_CASE */
 340
 341 /* BEGIN_CASE depends_on:MBEDTLS_FS_IO */
 342 void mbedtls_md_file( char * text_md_name, char * filename,
 343                       data_t * hex_hash_string )
 344 {
 345     char md_name[100];
 346     unsigned char output[100];
 347     const mbedtls_md_info_t *md_info = NULL;
 348
 349     memset( md_name, 0x00, 100 );
 350     memset( output, 0x00, 100 );
 351
 352     strncpy( (char *) md_name, text_md_name, sizeof( md_name ) - 1 );
 353     md_info = mbedtls_md_info_from_string( md_name );
 354     TEST_ASSERT( md_info != NULL );
 355
 356     TEST_ASSERT( mbedtls_md_file( md_info, filename, output ) == 0 );
 357
 358     TEST_ASSERT( hexcmp( output, hex_hash_string->x, mbedtls_md_get_size( md_info ), hex_hash_string->len ) == 0 );
 359 }
 360 /* END_CASE */