14 typedef UINT32 uint32_t;
23 #define GET_UINT32_BE(n,b,i) \
25 (n) = ( (uint32_t) (b)[(i) ] << 24 ) \
26 | ( (uint32_t) (b)[(i) + 1] << 16 ) \
27 | ( (uint32_t) (b)[(i) + 2] << 8 ) \
28 | ( (uint32_t) (b)[(i) + 3] ); \
33 #define PUT_UINT32_BE(n,b,i) \
35 (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
36 (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
37 (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
38 (b)[(i) + 3] = (unsigned char) ( (n) ); \
42 int unhexify(
unsigned char *obuf,
const char *ibuf)
45 int len = strlen(ibuf) / 2;
46 assert(!(strlen(ibuf) %1));
51 if( c >=
'0' && c <=
'9' )
53 else if( c >=
'a' && c <=
'f' )
55 else if( c >=
'A' && c <=
'F' )
61 if( c2 >=
'0' && c2 <=
'9' )
63 else if( c2 >=
'a' && c2 <=
'f' )
65 else if( c2 >=
'A' && c2 <=
'F' )
70 *obuf++ = ( c << 4 ) | c2;
76 void hexify(
unsigned char *obuf,
const unsigned char *ibuf,
int len)
88 *obuf++ =
'a' + h - 10;
93 *obuf++ =
'a' + l - 10;
109 static int rnd_std_rand(
void *rng_state,
unsigned char *output,
size_t len )
113 if( rng_state != NULL )
116 for( i = 0; i < len; ++i )
127 static int rnd_zero_rand(
void *rng_state,
unsigned char *output,
size_t len )
129 if( rng_state != NULL )
132 memset( output, 0, len );
159 if( rng_state == NULL )
168 memcpy( output, info->
buf, use_len );
169 info->
buf += use_len;
173 if( len - use_len > 0 )
174 return(
rnd_std_rand( NULL, output + use_len, len - use_len ) );
203 uint32_t i, *k, sum, delta=0x9E3779B9;
204 unsigned char result[4];
206 if( rng_state == NULL )
213 size_t use_len = ( len > 4 ) ? 4 : len;
216 for( i = 0; i < 32; i++ )
218 info->
v0 += (((info->
v1 << 4) ^ (info->
v1 >> 5)) + info->
v1) ^ (sum + k[sum & 3]);
220 info->
v1 += (((info->
v0 << 4) ^ (info->
v0 >> 5)) + info->
v0) ^ (sum + k[(sum>>11) & 3]);
224 memcpy( output, result, use_len );
237 FCT_SUITE_BGN(test_suite_md)
239 #ifdef POLARSSL_MD2_C
241 FCT_TEST_BGN(generic_md2_test_vector_rfc1319_1)
244 unsigned char src_str[1000];
245 unsigned char hash_str[1000];
246 unsigned char output[100];
249 memset(md_name, 0x00, 100);
250 memset(src_str, 0x00, 1000);
251 memset(hash_str, 0x00, 1000);
252 memset(output, 0x00, 100);
254 strcpy( (
char *) src_str,
"" );
256 strncpy( (
char *) md_name,
"md2", 100 );
258 fct_chk( md_info != NULL );
260 fct_chk ( 0 ==
md( md_info, src_str, strlen( (
char *) src_str ), output ) );
263 fct_chk( strcmp( (
char *) hash_str,
"8350e5a3e24c153df2275c9f80692773" ) == 0 );
268 #ifdef POLARSSL_MD2_C
270 FCT_TEST_BGN(generic_md2_test_vector_rfc1319_2)
273 unsigned char src_str[1000];
274 unsigned char hash_str[1000];
275 unsigned char output[100];
278 memset(md_name, 0x00, 100);
279 memset(src_str, 0x00, 1000);
280 memset(hash_str, 0x00, 1000);
281 memset(output, 0x00, 100);
283 strcpy( (
char *) src_str,
"a" );
285 strncpy( (
char *) md_name,
"md2", 100 );
287 fct_chk( md_info != NULL );
289 fct_chk ( 0 ==
md( md_info, src_str, strlen( (
char *) src_str ), output ) );
292 fct_chk( strcmp( (
char *) hash_str,
"32ec01ec4a6dac72c0ab96fb34c0b5d1" ) == 0 );
297 #ifdef POLARSSL_MD2_C
299 FCT_TEST_BGN(generic_md2_test_vector_rfc1319_3)
302 unsigned char src_str[1000];
303 unsigned char hash_str[1000];
304 unsigned char output[100];
307 memset(md_name, 0x00, 100);
308 memset(src_str, 0x00, 1000);
309 memset(hash_str, 0x00, 1000);
310 memset(output, 0x00, 100);
312 strcpy( (
char *) src_str,
"abc" );
314 strncpy( (
char *) md_name,
"md2", 100 );
316 fct_chk( md_info != NULL );
318 fct_chk ( 0 ==
md( md_info, src_str, strlen( (
char *) src_str ), output ) );
321 fct_chk( strcmp( (
char *) hash_str,
"da853b0d3f88d99b30283a69e6ded6bb" ) == 0 );
326 #ifdef POLARSSL_MD2_C
328 FCT_TEST_BGN(generic_md2_test_vector_rfc1319_4)
331 unsigned char src_str[1000];
332 unsigned char hash_str[1000];
333 unsigned char output[100];
336 memset(md_name, 0x00, 100);
337 memset(src_str, 0x00, 1000);
338 memset(hash_str, 0x00, 1000);
339 memset(output, 0x00, 100);
341 strcpy( (
char *) src_str,
"message digest" );
343 strncpy( (
char *) md_name,
"md2", 100 );
345 fct_chk( md_info != NULL );
347 fct_chk ( 0 ==
md( md_info, src_str, strlen( (
char *) src_str ), output ) );
350 fct_chk( strcmp( (
char *) hash_str,
"ab4f496bfb2a530b219ff33031fe06b0" ) == 0 );
355 #ifdef POLARSSL_MD2_C
357 FCT_TEST_BGN(generic_md2_test_vector_rfc1319_5)
360 unsigned char src_str[1000];
361 unsigned char hash_str[1000];
362 unsigned char output[100];
365 memset(md_name, 0x00, 100);
366 memset(src_str, 0x00, 1000);
367 memset(hash_str, 0x00, 1000);
368 memset(output, 0x00, 100);
370 strcpy( (
char *) src_str,
"abcdefghijklmnopqrstuvwxyz" );
372 strncpy( (
char *) md_name,
"md2", 100 );
374 fct_chk( md_info != NULL );
376 fct_chk ( 0 ==
md( md_info, src_str, strlen( (
char *) src_str ), output ) );
379 fct_chk( strcmp( (
char *) hash_str,
"4e8ddff3650292ab5a4108c3aa47940b" ) == 0 );
384 #ifdef POLARSSL_MD2_C
386 FCT_TEST_BGN(generic_md2_test_vector_rfc1319_6)
389 unsigned char src_str[1000];
390 unsigned char hash_str[1000];
391 unsigned char output[100];
394 memset(md_name, 0x00, 100);
395 memset(src_str, 0x00, 1000);
396 memset(hash_str, 0x00, 1000);
397 memset(output, 0x00, 100);
399 strcpy( (
char *) src_str,
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" );
401 strncpy( (
char *) md_name,
"md2", 100 );
403 fct_chk( md_info != NULL );
405 fct_chk ( 0 ==
md( md_info, src_str, strlen( (
char *) src_str ), output ) );
408 fct_chk( strcmp( (
char *) hash_str,
"da33def2a42df13975352846c30338cd" ) == 0 );
413 #ifdef POLARSSL_MD2_C
415 FCT_TEST_BGN(generic_md2_test_vector_rfc1319_7)
418 unsigned char src_str[1000];
419 unsigned char hash_str[1000];
420 unsigned char output[100];
423 memset(md_name, 0x00, 100);
424 memset(src_str, 0x00, 1000);
425 memset(hash_str, 0x00, 1000);
426 memset(output, 0x00, 100);
428 strcpy( (
char *) src_str,
"12345678901234567890123456789012345678901234567890123456789012345678901234567890" );
430 strncpy( (
char *) md_name,
"md2", 100 );
432 fct_chk( md_info != NULL );
434 fct_chk ( 0 ==
md( md_info, src_str, strlen( (
char *) src_str ), output ) );
437 fct_chk( strcmp( (
char *) hash_str,
"d5976f79d83d3a0dc9806c3c66f3efd8" ) == 0 );
442 #ifdef POLARSSL_MD4_C
444 FCT_TEST_BGN(generic_md4_test_vector_rfc1320_1)
447 unsigned char src_str[1000];
448 unsigned char hash_str[1000];
449 unsigned char output[100];
452 memset(md_name, 0x00, 100);
453 memset(src_str, 0x00, 1000);
454 memset(hash_str, 0x00, 1000);
455 memset(output, 0x00, 100);
457 strcpy( (
char *) src_str,
"" );
459 strncpy( (
char *) md_name,
"md4", 100 );
461 fct_chk( md_info != NULL );
463 fct_chk ( 0 ==
md( md_info, src_str, strlen( (
char *) src_str ), output ) );
466 fct_chk( strcmp( (
char *) hash_str,
"31d6cfe0d16ae931b73c59d7e0c089c0" ) == 0 );
471 #ifdef POLARSSL_MD4_C
473 FCT_TEST_BGN(generic_md4_test_vector_rfc1320_2)
476 unsigned char src_str[1000];
477 unsigned char hash_str[1000];
478 unsigned char output[100];
481 memset(md_name, 0x00, 100);
482 memset(src_str, 0x00, 1000);
483 memset(hash_str, 0x00, 1000);
484 memset(output, 0x00, 100);
486 strcpy( (
char *) src_str,
"a" );
488 strncpy( (
char *) md_name,
"md4", 100 );
490 fct_chk( md_info != NULL );
492 fct_chk ( 0 ==
md( md_info, src_str, strlen( (
char *) src_str ), output ) );
495 fct_chk( strcmp( (
char *) hash_str,
"bde52cb31de33e46245e05fbdbd6fb24" ) == 0 );
500 #ifdef POLARSSL_MD4_C
502 FCT_TEST_BGN(generic_md4_test_vector_rfc1320_3)
505 unsigned char src_str[1000];
506 unsigned char hash_str[1000];
507 unsigned char output[100];
510 memset(md_name, 0x00, 100);
511 memset(src_str, 0x00, 1000);
512 memset(hash_str, 0x00, 1000);
513 memset(output, 0x00, 100);
515 strcpy( (
char *) src_str,
"abc" );
517 strncpy( (
char *) md_name,
"md4", 100 );
519 fct_chk( md_info != NULL );
521 fct_chk ( 0 ==
md( md_info, src_str, strlen( (
char *) src_str ), output ) );
524 fct_chk( strcmp( (
char *) hash_str,
"a448017aaf21d8525fc10ae87aa6729d" ) == 0 );
529 #ifdef POLARSSL_MD4_C
531 FCT_TEST_BGN(generic_md4_test_vector_rfc1320_4)
534 unsigned char src_str[1000];
535 unsigned char hash_str[1000];
536 unsigned char output[100];
539 memset(md_name, 0x00, 100);
540 memset(src_str, 0x00, 1000);
541 memset(hash_str, 0x00, 1000);
542 memset(output, 0x00, 100);
544 strcpy( (
char *) src_str,
"message digest" );
546 strncpy( (
char *) md_name,
"md4", 100 );
548 fct_chk( md_info != NULL );
550 fct_chk ( 0 ==
md( md_info, src_str, strlen( (
char *) src_str ), output ) );
553 fct_chk( strcmp( (
char *) hash_str,
"d9130a8164549fe818874806e1c7014b" ) == 0 );
558 #ifdef POLARSSL_MD4_C
560 FCT_TEST_BGN(generic_md4_test_vector_rfc1320_5)
563 unsigned char src_str[1000];
564 unsigned char hash_str[1000];
565 unsigned char output[100];
568 memset(md_name, 0x00, 100);
569 memset(src_str, 0x00, 1000);
570 memset(hash_str, 0x00, 1000);
571 memset(output, 0x00, 100);
573 strcpy( (
char *) src_str,
"abcdefghijklmnopqrstuvwxyz" );
575 strncpy( (
char *) md_name,
"md4", 100 );
577 fct_chk( md_info != NULL );
579 fct_chk ( 0 ==
md( md_info, src_str, strlen( (
char *) src_str ), output ) );
582 fct_chk( strcmp( (
char *) hash_str,
"d79e1c308aa5bbcdeea8ed63df412da9" ) == 0 );
587 #ifdef POLARSSL_MD4_C
589 FCT_TEST_BGN(generic_md4_test_vector_rfc1320_6)
592 unsigned char src_str[1000];
593 unsigned char hash_str[1000];
594 unsigned char output[100];
597 memset(md_name, 0x00, 100);
598 memset(src_str, 0x00, 1000);
599 memset(hash_str, 0x00, 1000);
600 memset(output, 0x00, 100);
602 strcpy( (
char *) src_str,
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" );
604 strncpy( (
char *) md_name,
"md4", 100 );
606 fct_chk( md_info != NULL );
608 fct_chk ( 0 ==
md( md_info, src_str, strlen( (
char *) src_str ), output ) );
611 fct_chk( strcmp( (
char *) hash_str,
"043f8582f241db351ce627e153e7f0e4" ) == 0 );
616 #ifdef POLARSSL_MD4_C
618 FCT_TEST_BGN(generic_md4_test_vector_rfc1320_7)
621 unsigned char src_str[1000];
622 unsigned char hash_str[1000];
623 unsigned char output[100];
626 memset(md_name, 0x00, 100);
627 memset(src_str, 0x00, 1000);
628 memset(hash_str, 0x00, 1000);
629 memset(output, 0x00, 100);
631 strcpy( (
char *) src_str,
"12345678901234567890123456789012345678901234567890123456789012345678901234567890" );
633 strncpy( (
char *) md_name,
"md4", 100 );
635 fct_chk( md_info != NULL );
637 fct_chk ( 0 ==
md( md_info, src_str, strlen( (
char *) src_str ), output ) );
640 fct_chk( strcmp( (
char *) hash_str,
"e33b4ddc9c38f2199c3e7b164fcc0536" ) == 0 );
645 #ifdef POLARSSL_MD5_C
647 FCT_TEST_BGN(generic_md5_test_vector_rfc1321_1)
650 unsigned char src_str[1000];
651 unsigned char hash_str[1000];
652 unsigned char output[100];
655 memset(md_name, 0x00, 100);
656 memset(src_str, 0x00, 1000);
657 memset(hash_str, 0x00, 1000);
658 memset(output, 0x00, 100);
660 strcpy( (
char *) src_str,
"" );
662 strncpy( (
char *) md_name,
"md5", 100 );
664 fct_chk( md_info != NULL );
666 fct_chk ( 0 ==
md( md_info, src_str, strlen( (
char *) src_str ), output ) );
669 fct_chk( strcmp( (
char *) hash_str,
"d41d8cd98f00b204e9800998ecf8427e" ) == 0 );
674 #ifdef POLARSSL_MD5_C
676 FCT_TEST_BGN(generic_md5_test_vector_rfc1321_2)
679 unsigned char src_str[1000];
680 unsigned char hash_str[1000];
681 unsigned char output[100];
684 memset(md_name, 0x00, 100);
685 memset(src_str, 0x00, 1000);
686 memset(hash_str, 0x00, 1000);
687 memset(output, 0x00, 100);
689 strcpy( (
char *) src_str,
"a" );
691 strncpy( (
char *) md_name,
"md5", 100 );
693 fct_chk( md_info != NULL );
695 fct_chk ( 0 ==
md( md_info, src_str, strlen( (
char *) src_str ), output ) );
698 fct_chk( strcmp( (
char *) hash_str,
"0cc175b9c0f1b6a831c399e269772661" ) == 0 );
703 #ifdef POLARSSL_MD5_C
705 FCT_TEST_BGN(generic_md5_test_vector_rfc1321_3)
708 unsigned char src_str[1000];
709 unsigned char hash_str[1000];
710 unsigned char output[100];
713 memset(md_name, 0x00, 100);
714 memset(src_str, 0x00, 1000);
715 memset(hash_str, 0x00, 1000);
716 memset(output, 0x00, 100);
718 strcpy( (
char *) src_str,
"abc" );
720 strncpy( (
char *) md_name,
"md5", 100 );
722 fct_chk( md_info != NULL );
724 fct_chk ( 0 ==
md( md_info, src_str, strlen( (
char *) src_str ), output ) );
727 fct_chk( strcmp( (
char *) hash_str,
"900150983cd24fb0d6963f7d28e17f72" ) == 0 );
732 #ifdef POLARSSL_MD5_C
734 FCT_TEST_BGN(generic_md5_test_vector_rfc1321_4)
737 unsigned char src_str[1000];
738 unsigned char hash_str[1000];
739 unsigned char output[100];
742 memset(md_name, 0x00, 100);
743 memset(src_str, 0x00, 1000);
744 memset(hash_str, 0x00, 1000);
745 memset(output, 0x00, 100);
747 strcpy( (
char *) src_str,
"message digest" );
749 strncpy( (
char *) md_name,
"md5", 100 );
751 fct_chk( md_info != NULL );
753 fct_chk ( 0 ==
md( md_info, src_str, strlen( (
char *) src_str ), output ) );
756 fct_chk( strcmp( (
char *) hash_str,
"f96b697d7cb7938d525a2f31aaf161d0" ) == 0 );
761 #ifdef POLARSSL_MD5_C
763 FCT_TEST_BGN(generic_md5_test_vector_rfc1321_5)
766 unsigned char src_str[1000];
767 unsigned char hash_str[1000];
768 unsigned char output[100];
771 memset(md_name, 0x00, 100);
772 memset(src_str, 0x00, 1000);
773 memset(hash_str, 0x00, 1000);
774 memset(output, 0x00, 100);
776 strcpy( (
char *) src_str,
"abcdefghijklmnopqrstuvwxyz" );
778 strncpy( (
char *) md_name,
"md5", 100 );
780 fct_chk( md_info != NULL );
782 fct_chk ( 0 ==
md( md_info, src_str, strlen( (
char *) src_str ), output ) );
785 fct_chk( strcmp( (
char *) hash_str,
"c3fcd3d76192e4007dfb496cca67e13b" ) == 0 );
790 #ifdef POLARSSL_MD5_C
792 FCT_TEST_BGN(generic_md5_test_vector_rfc1321_6)
795 unsigned char src_str[1000];
796 unsigned char hash_str[1000];
797 unsigned char output[100];
800 memset(md_name, 0x00, 100);
801 memset(src_str, 0x00, 1000);
802 memset(hash_str, 0x00, 1000);
803 memset(output, 0x00, 100);
805 strcpy( (
char *) src_str,
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" );
807 strncpy( (
char *) md_name,
"md5", 100 );
809 fct_chk( md_info != NULL );
811 fct_chk ( 0 ==
md( md_info, src_str, strlen( (
char *) src_str ), output ) );
814 fct_chk( strcmp( (
char *) hash_str,
"d174ab98d277d9f5a5611c2c9f419d9f" ) == 0 );
819 #ifdef POLARSSL_MD5_C
821 FCT_TEST_BGN(generic_md5_test_vector_rfc1321_7)
824 unsigned char src_str[1000];
825 unsigned char hash_str[1000];
826 unsigned char output[100];
829 memset(md_name, 0x00, 100);
830 memset(src_str, 0x00, 1000);
831 memset(hash_str, 0x00, 1000);
832 memset(output, 0x00, 100);
834 strcpy( (
char *) src_str,
"12345678901234567890123456789012345678901234567890123456789012345678901234567890" );
836 strncpy( (
char *) md_name,
"md5", 100 );
838 fct_chk( md_info != NULL );
840 fct_chk ( 0 ==
md( md_info, src_str, strlen( (
char *) src_str ), output ) );
843 fct_chk( strcmp( (
char *) hash_str,
"57edf4a22be3c955ac49da2e2107b67a" ) == 0 );
848 #ifdef POLARSSL_MD2_C
850 FCT_TEST_BGN(generic_hmac_md2_hash_file_openssl_test_1)
853 unsigned char src_str[10000];
854 unsigned char key_str[10000];
855 unsigned char hash_str[10000];
856 unsigned char output[100];
857 int key_len, src_len;
860 memset(md_name, 0x00, 100);
861 memset(src_str, 0x00, 10000);
862 memset(key_str, 0x00, 10000);
863 memset(hash_str, 0x00, 10000);
864 memset(output, 0x00, 100);
866 strncpy( (
char *) md_name,
"md2", 100 );
868 fct_chk( md_info != NULL );
870 key_len =
unhexify( key_str,
"61616161616161616161616161616161" );
871 src_len =
unhexify( src_str,
"b91ce5ac77d33c234e61002ed6" );
873 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
876 fct_chk( strncmp( (
char *) hash_str,
"d5732582f494f5ddf35efd166c85af9c", 16 * 2 ) == 0 );
881 #ifdef POLARSSL_MD2_C
883 FCT_TEST_BGN(generic_hmac_md2_hash_file_openssl_test_2)
886 unsigned char src_str[10000];
887 unsigned char key_str[10000];
888 unsigned char hash_str[10000];
889 unsigned char output[100];
890 int key_len, src_len;
893 memset(md_name, 0x00, 100);
894 memset(src_str, 0x00, 10000);
895 memset(key_str, 0x00, 10000);
896 memset(hash_str, 0x00, 10000);
897 memset(output, 0x00, 100);
899 strncpy( (
char *) md_name,
"md2", 100 );
901 fct_chk( md_info != NULL );
903 key_len =
unhexify( key_str,
"61616161616161616161616161616161" );
904 src_len =
unhexify( src_str,
"270fcf11f27c27448457d7049a7edb084a3e554e0b2acf5806982213f0ad516402e4c869c4ff2171e18e3489baa3125d2c3056ebb616296f9b6aa97ef68eeabcdc0b6dde47775004096a241efcf0a90d19b34e898cc7340cdc940f8bdd46e23e352f34bca131d4d67a7c2ddb8d0d68b67f06152a128168e1c341c37e0a66c5018999b7059bcc300beed2c19dd1152d2fe062853293b8f3c8b5" );
906 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
909 fct_chk( strncmp( (
char *) hash_str,
"54ab68503f7d1b5c7741340dff2722a9", 16 * 2 ) == 0 );
914 #ifdef POLARSSL_MD2_C
916 FCT_TEST_BGN(generic_hmac_md2_hash_file_openssl_test_3)
919 unsigned char src_str[10000];
920 unsigned char key_str[10000];
921 unsigned char hash_str[10000];
922 unsigned char output[100];
923 int key_len, src_len;
926 memset(md_name, 0x00, 100);
927 memset(src_str, 0x00, 10000);
928 memset(key_str, 0x00, 10000);
929 memset(hash_str, 0x00, 10000);
930 memset(output, 0x00, 100);
932 strncpy( (
char *) md_name,
"md2", 100 );
934 fct_chk( md_info != NULL );
936 key_len =
unhexify( key_str,
"61616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161" );
937 src_len =
unhexify( src_str,
"b91ce5ac77d33c234e61002ed6" );
939 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
942 fct_chk( strncmp( (
char *) hash_str,
"d850e5f554558cf0fe79a0612e1d0365", 16 * 2 ) == 0 );
947 #ifdef POLARSSL_MD4_C
949 FCT_TEST_BGN(generic_hmac_md4_hash_file_openssl_test_1)
952 unsigned char src_str[10000];
953 unsigned char key_str[10000];
954 unsigned char hash_str[10000];
955 unsigned char output[100];
956 int key_len, src_len;
959 memset(md_name, 0x00, 100);
960 memset(src_str, 0x00, 10000);
961 memset(key_str, 0x00, 10000);
962 memset(hash_str, 0x00, 10000);
963 memset(output, 0x00, 100);
965 strncpy( (
char *) md_name,
"md4", 100 );
967 fct_chk( md_info != NULL );
969 key_len =
unhexify( key_str,
"61616161616161616161616161616161" );
970 src_len =
unhexify( src_str,
"b91ce5ac77d33c234e61002ed6" );
972 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
975 fct_chk( strncmp( (
char *) hash_str,
"eabd0fbefb82fb0063a25a6d7b8bdc0f", 16 * 2 ) == 0 );
980 #ifdef POLARSSL_MD4_C
982 FCT_TEST_BGN(generic_hmac_md4_hash_file_openssl_test_2)
985 unsigned char src_str[10000];
986 unsigned char key_str[10000];
987 unsigned char hash_str[10000];
988 unsigned char output[100];
989 int key_len, src_len;
992 memset(md_name, 0x00, 100);
993 memset(src_str, 0x00, 10000);
994 memset(key_str, 0x00, 10000);
995 memset(hash_str, 0x00, 10000);
996 memset(output, 0x00, 100);
998 strncpy( (
char *) md_name,
"md4", 100 );
1000 fct_chk( md_info != NULL );
1002 key_len =
unhexify( key_str,
"61616161616161616161616161616161" );
1003 src_len =
unhexify( src_str,
"270fcf11f27c27448457d7049a7edb084a3e554e0b2acf5806982213f0ad516402e4c869c4ff2171e18e3489baa3125d2c3056ebb616296f9b6aa97ef68eeabcdc0b6dde47775004096a241efcf0a90d19b34e898cc7340cdc940f8bdd46e23e352f34bca131d4d67a7c2ddb8d0d68b67f06152a128168e1c341c37e0a66c5018999b7059bcc300beed2c19dd1152d2fe062853293b8f3c8b5" );
1005 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
1008 fct_chk( strncmp( (
char *) hash_str,
"cec3c5e421a7b783aa89cacf78daf6dc", 16 * 2 ) == 0 );
1013 #ifdef POLARSSL_MD4_C
1015 FCT_TEST_BGN(generic_hmac_md4_hash_file_openssl_test_3)
1018 unsigned char src_str[10000];
1019 unsigned char key_str[10000];
1020 unsigned char hash_str[10000];
1021 unsigned char output[100];
1022 int key_len, src_len;
1025 memset(md_name, 0x00, 100);
1026 memset(src_str, 0x00, 10000);
1027 memset(key_str, 0x00, 10000);
1028 memset(hash_str, 0x00, 10000);
1029 memset(output, 0x00, 100);
1031 strncpy( (
char *) md_name,
"md4", 100 );
1033 fct_chk( md_info != NULL );
1035 key_len =
unhexify( key_str,
"61616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161" );
1036 src_len =
unhexify( src_str,
"b91ce5ac77d33c234e61002ed6" );
1038 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
1041 fct_chk( strncmp( (
char *) hash_str,
"ad5f0a04116109b397b57f9cc9b6df4b", 16 * 2 ) == 0 );
1046 #ifdef POLARSSL_MD5_C
1048 FCT_TEST_BGN(generic_hmac_md5_hash_file_openssl_test_1)
1051 unsigned char src_str[10000];
1052 unsigned char key_str[10000];
1053 unsigned char hash_str[10000];
1054 unsigned char output[100];
1055 int key_len, src_len;
1058 memset(md_name, 0x00, 100);
1059 memset(src_str, 0x00, 10000);
1060 memset(key_str, 0x00, 10000);
1061 memset(hash_str, 0x00, 10000);
1062 memset(output, 0x00, 100);
1064 strncpy( (
char *) md_name,
"md5", 100 );
1066 fct_chk( md_info != NULL );
1068 key_len =
unhexify( key_str,
"61616161616161616161616161616161" );
1069 src_len =
unhexify( src_str,
"b91ce5ac77d33c234e61002ed6" );
1071 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
1074 fct_chk( strncmp( (
char *) hash_str,
"42552882f00bd4633ea81135a184b284", 16 * 2 ) == 0 );
1079 #ifdef POLARSSL_MD5_C
1081 FCT_TEST_BGN(generic_hmac_md5_hash_file_openssl_test_2)
1084 unsigned char src_str[10000];
1085 unsigned char key_str[10000];
1086 unsigned char hash_str[10000];
1087 unsigned char output[100];
1088 int key_len, src_len;
1091 memset(md_name, 0x00, 100);
1092 memset(src_str, 0x00, 10000);
1093 memset(key_str, 0x00, 10000);
1094 memset(hash_str, 0x00, 10000);
1095 memset(output, 0x00, 100);
1097 strncpy( (
char *) md_name,
"md5", 100 );
1099 fct_chk( md_info != NULL );
1101 key_len =
unhexify( key_str,
"61616161616161616161616161616161" );
1102 src_len =
unhexify( src_str,
"270fcf11f27c27448457d7049a7edb084a3e554e0b2acf5806982213f0ad516402e4c869c4ff2171e18e3489baa3125d2c3056ebb616296f9b6aa97ef68eeabcdc0b6dde47775004096a241efcf0a90d19b34e898cc7340cdc940f8bdd46e23e352f34bca131d4d67a7c2ddb8d0d68b67f06152a128168e1c341c37e0a66c5018999b7059bcc300beed2c19dd1152d2fe062853293b8f3c8b5" );
1104 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
1107 fct_chk( strncmp( (
char *) hash_str,
"a16a842891786d01fe50ba7731db7464", 16 * 2 ) == 0 );
1112 #ifdef POLARSSL_MD5_C
1114 FCT_TEST_BGN(generic_hmac_md5_hash_file_openssl_test_3)
1117 unsigned char src_str[10000];
1118 unsigned char key_str[10000];
1119 unsigned char hash_str[10000];
1120 unsigned char output[100];
1121 int key_len, src_len;
1124 memset(md_name, 0x00, 100);
1125 memset(src_str, 0x00, 10000);
1126 memset(key_str, 0x00, 10000);
1127 memset(hash_str, 0x00, 10000);
1128 memset(output, 0x00, 100);
1130 strncpy( (
char *) md_name,
"md5", 100 );
1132 fct_chk( md_info != NULL );
1134 key_len =
unhexify( key_str,
"61616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161" );
1135 src_len =
unhexify( src_str,
"b91ce5ac77d33c234e61002ed6" );
1137 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
1140 fct_chk( strncmp( (
char *) hash_str,
"e97f623936f98a7f741c4bd0612fecc2", 16 * 2 ) == 0 );
1145 #ifdef POLARSSL_MD5_C
1147 FCT_TEST_BGN(generic_hmac_md5_test_vector_rfc2202_1)
1150 unsigned char src_str[10000];
1151 unsigned char key_str[10000];
1152 unsigned char hash_str[10000];
1153 unsigned char output[100];
1154 int key_len, src_len;
1157 memset(md_name, 0x00, 100);
1158 memset(src_str, 0x00, 10000);
1159 memset(key_str, 0x00, 10000);
1160 memset(hash_str, 0x00, 10000);
1161 memset(output, 0x00, 100);
1163 strncpy( (
char *) md_name,
"md5", 100 );
1165 fct_chk( md_info != NULL );
1167 key_len =
unhexify( key_str,
"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b" );
1168 src_len =
unhexify( src_str,
"4869205468657265" );
1170 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
1173 fct_chk( strncmp( (
char *) hash_str,
"9294727a3638bb1c13f48ef8158bfc9d", 16 * 2 ) == 0 );
1178 #ifdef POLARSSL_MD5_C
1180 FCT_TEST_BGN(generic_hmac_md5_test_vector_rfc2202_2)
1183 unsigned char src_str[10000];
1184 unsigned char key_str[10000];
1185 unsigned char hash_str[10000];
1186 unsigned char output[100];
1187 int key_len, src_len;
1190 memset(md_name, 0x00, 100);
1191 memset(src_str, 0x00, 10000);
1192 memset(key_str, 0x00, 10000);
1193 memset(hash_str, 0x00, 10000);
1194 memset(output, 0x00, 100);
1196 strncpy( (
char *) md_name,
"md5", 100 );
1198 fct_chk( md_info != NULL );
1200 key_len =
unhexify( key_str,
"4a656665" );
1201 src_len =
unhexify( src_str,
"7768617420646f2079612077616e7420666f72206e6f7468696e673f" );
1203 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
1206 fct_chk( strncmp( (
char *) hash_str,
"750c783e6ab0b503eaa86e310a5db738", 16 * 2 ) == 0 );
1211 #ifdef POLARSSL_MD5_C
1213 FCT_TEST_BGN(generic_hmac_md5_test_vector_rfc2202_3)
1216 unsigned char src_str[10000];
1217 unsigned char key_str[10000];
1218 unsigned char hash_str[10000];
1219 unsigned char output[100];
1220 int key_len, src_len;
1223 memset(md_name, 0x00, 100);
1224 memset(src_str, 0x00, 10000);
1225 memset(key_str, 0x00, 10000);
1226 memset(hash_str, 0x00, 10000);
1227 memset(output, 0x00, 100);
1229 strncpy( (
char *) md_name,
"md5", 100 );
1231 fct_chk( md_info != NULL );
1233 key_len =
unhexify( key_str,
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" );
1234 src_len =
unhexify( src_str,
"dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd" );
1236 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
1239 fct_chk( strncmp( (
char *) hash_str,
"56be34521d144c88dbb8c733f0e8b3f6", 16 * 2 ) == 0 );
1244 #ifdef POLARSSL_MD5_C
1246 FCT_TEST_BGN(generic_hmac_md5_test_vector_rfc2202_4)
1249 unsigned char src_str[10000];
1250 unsigned char key_str[10000];
1251 unsigned char hash_str[10000];
1252 unsigned char output[100];
1253 int key_len, src_len;
1256 memset(md_name, 0x00, 100);
1257 memset(src_str, 0x00, 10000);
1258 memset(key_str, 0x00, 10000);
1259 memset(hash_str, 0x00, 10000);
1260 memset(output, 0x00, 100);
1262 strncpy( (
char *) md_name,
"md5", 100 );
1264 fct_chk( md_info != NULL );
1266 key_len =
unhexify( key_str,
"0102030405060708090a0b0c0d0e0f10111213141516171819" );
1267 src_len =
unhexify( src_str,
"cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd" );
1269 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
1272 fct_chk( strncmp( (
char *) hash_str,
"697eaf0aca3a3aea3a75164746ffaa79", 16 * 2 ) == 0 );
1277 #ifdef POLARSSL_MD5_C
1279 FCT_TEST_BGN(generic_hmac_md5_test_vector_rfc2202_5)
1282 unsigned char src_str[10000];
1283 unsigned char key_str[10000];
1284 unsigned char hash_str[10000];
1285 unsigned char output[100];
1286 int key_len, src_len;
1289 memset(md_name, 0x00, 100);
1290 memset(src_str, 0x00, 10000);
1291 memset(key_str, 0x00, 10000);
1292 memset(hash_str, 0x00, 10000);
1293 memset(output, 0x00, 100);
1295 strncpy( (
char *) md_name,
"md5", 100 );
1297 fct_chk( md_info != NULL );
1299 key_len =
unhexify( key_str,
"0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c" );
1300 src_len =
unhexify( src_str,
"546573742057697468205472756e636174696f6e" );
1302 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
1305 fct_chk( strncmp( (
char *) hash_str,
"56461ef2342edc00f9bab995", 12 * 2 ) == 0 );
1310 #ifdef POLARSSL_MD5_C
1312 FCT_TEST_BGN(generic_hmac_md5_test_vector_rfc2202_6)
1315 unsigned char src_str[10000];
1316 unsigned char key_str[10000];
1317 unsigned char hash_str[10000];
1318 unsigned char output[100];
1319 int key_len, src_len;
1322 memset(md_name, 0x00, 100);
1323 memset(src_str, 0x00, 10000);
1324 memset(key_str, 0x00, 10000);
1325 memset(hash_str, 0x00, 10000);
1326 memset(output, 0x00, 100);
1328 strncpy( (
char *) md_name,
"md5", 100 );
1330 fct_chk( md_info != NULL );
1332 key_len =
unhexify( key_str,
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" );
1333 src_len =
unhexify( src_str,
"54657374205573696e67204c6172676572205468616e20426c6f636b2d53697a65204b6579202d2048617368204b6579204669727374" );
1335 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
1338 fct_chk( strncmp( (
char *) hash_str,
"6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd", 16 * 2 ) == 0 );
1343 #ifdef POLARSSL_MD5_C
1345 FCT_TEST_BGN(generic_hmac_md5_test_vector_rfc2202_7)
1348 unsigned char src_str[10000];
1349 unsigned char key_str[10000];
1350 unsigned char hash_str[10000];
1351 unsigned char output[100];
1352 int key_len, src_len;
1355 memset(md_name, 0x00, 100);
1356 memset(src_str, 0x00, 10000);
1357 memset(key_str, 0x00, 10000);
1358 memset(hash_str, 0x00, 10000);
1359 memset(output, 0x00, 100);
1361 strncpy( (
char *) md_name,
"md5", 100 );
1363 fct_chk( md_info != NULL );
1365 key_len =
unhexify( key_str,
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" );
1366 src_len =
unhexify( src_str,
"54657374205573696e67204c6172676572205468616e20426c6f636b2d53697a65204b657920616e64204c6172676572205468616e204f6e6520426c6f636b2d53697a652044617461" );
1368 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
1371 fct_chk( strncmp( (
char *) hash_str,
"6f630fad67cda0ee1fb1f562db3aa53e", 16 * 2 ) == 0 );
1376 #ifdef POLARSSL_MD_C
1377 #ifdef POLARSSL_MD2_C
1379 FCT_TEST_BGN(generic_multi_step_md2_test_vector_rfc1319_1)
1382 unsigned char src_str[1000];
1383 unsigned char hash_str[1000];
1384 unsigned char output[100];
1389 memset(md_name, 0x00, 100);
1390 memset(src_str, 0x00, 1000);
1391 memset(hash_str, 0x00, 1000);
1392 memset(output, 0x00, 100);
1394 strcpy( (
char *) src_str,
"" );
1396 strncpy( (
char *) md_name,
"md2", 100 );
1398 fct_chk( md_info != NULL );
1402 fct_chk ( ctx.
md_ctx != NULL );
1403 fct_chk ( 0 ==
md_update( &ctx, src_str, strlen( (
char *) src_str ) ) );
1404 fct_chk ( 0 ==
md_finish( &ctx, output ) );
1409 fct_chk( strcmp( (
char *) hash_str,
"8350e5a3e24c153df2275c9f80692773" ) == 0 );
1415 #ifdef POLARSSL_MD2_C
1417 FCT_TEST_BGN(generic_multi_step_md2_test_vector_rfc1319_2)
1420 unsigned char src_str[1000];
1421 unsigned char hash_str[1000];
1422 unsigned char output[100];
1427 memset(md_name, 0x00, 100);
1428 memset(src_str, 0x00, 1000);
1429 memset(hash_str, 0x00, 1000);
1430 memset(output, 0x00, 100);
1432 strcpy( (
char *) src_str,
"a" );
1434 strncpy( (
char *) md_name,
"md2", 100 );
1436 fct_chk( md_info != NULL );
1440 fct_chk ( ctx.
md_ctx != NULL );
1441 fct_chk ( 0 ==
md_update( &ctx, src_str, strlen( (
char *) src_str ) ) );
1442 fct_chk ( 0 ==
md_finish( &ctx, output ) );
1447 fct_chk( strcmp( (
char *) hash_str,
"32ec01ec4a6dac72c0ab96fb34c0b5d1" ) == 0 );
1452 #ifdef POLARSSL_MD2_C
1454 FCT_TEST_BGN(generic_multi_step_md2_test_vector_rfc1319_3)
1457 unsigned char src_str[1000];
1458 unsigned char hash_str[1000];
1459 unsigned char output[100];
1464 memset(md_name, 0x00, 100);
1465 memset(src_str, 0x00, 1000);
1466 memset(hash_str, 0x00, 1000);
1467 memset(output, 0x00, 100);
1469 strcpy( (
char *) src_str,
"abc" );
1471 strncpy( (
char *) md_name,
"md2", 100 );
1473 fct_chk( md_info != NULL );
1477 fct_chk ( ctx.
md_ctx != NULL );
1478 fct_chk ( 0 ==
md_update( &ctx, src_str, strlen( (
char *) src_str ) ) );
1479 fct_chk ( 0 ==
md_finish( &ctx, output ) );
1484 fct_chk( strcmp( (
char *) hash_str,
"da853b0d3f88d99b30283a69e6ded6bb" ) == 0 );
1489 #ifdef POLARSSL_MD2_C
1491 FCT_TEST_BGN(generic_multi_step_md2_test_vector_rfc1319_4)
1494 unsigned char src_str[1000];
1495 unsigned char hash_str[1000];
1496 unsigned char output[100];
1501 memset(md_name, 0x00, 100);
1502 memset(src_str, 0x00, 1000);
1503 memset(hash_str, 0x00, 1000);
1504 memset(output, 0x00, 100);
1506 strcpy( (
char *) src_str,
"message digest" );
1508 strncpy( (
char *) md_name,
"md2", 100 );
1510 fct_chk( md_info != NULL );
1514 fct_chk ( ctx.
md_ctx != NULL );
1515 fct_chk ( 0 ==
md_update( &ctx, src_str, strlen( (
char *) src_str ) ) );
1516 fct_chk ( 0 ==
md_finish( &ctx, output ) );
1521 fct_chk( strcmp( (
char *) hash_str,
"ab4f496bfb2a530b219ff33031fe06b0" ) == 0 );
1526 #ifdef POLARSSL_MD2_C
1528 FCT_TEST_BGN(generic_multi_step_md2_test_vector_rfc1319_5)
1531 unsigned char src_str[1000];
1532 unsigned char hash_str[1000];
1533 unsigned char output[100];
1538 memset(md_name, 0x00, 100);
1539 memset(src_str, 0x00, 1000);
1540 memset(hash_str, 0x00, 1000);
1541 memset(output, 0x00, 100);
1543 strcpy( (
char *) src_str,
"abcdefghijklmnopqrstuvwxyz" );
1545 strncpy( (
char *) md_name,
"md2", 100 );
1547 fct_chk( md_info != NULL );
1551 fct_chk ( ctx.
md_ctx != NULL );
1552 fct_chk ( 0 ==
md_update( &ctx, src_str, strlen( (
char *) src_str ) ) );
1553 fct_chk ( 0 ==
md_finish( &ctx, output ) );
1558 fct_chk( strcmp( (
char *) hash_str,
"4e8ddff3650292ab5a4108c3aa47940b" ) == 0 );
1563 #ifdef POLARSSL_MD2_C
1565 FCT_TEST_BGN(generic_multi_step_md2_test_vector_rfc1319_6)
1568 unsigned char src_str[1000];
1569 unsigned char hash_str[1000];
1570 unsigned char output[100];
1575 memset(md_name, 0x00, 100);
1576 memset(src_str, 0x00, 1000);
1577 memset(hash_str, 0x00, 1000);
1578 memset(output, 0x00, 100);
1580 strcpy( (
char *) src_str,
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" );
1582 strncpy( (
char *) md_name,
"md2", 100 );
1584 fct_chk( md_info != NULL );
1588 fct_chk ( ctx.
md_ctx != NULL );
1589 fct_chk ( 0 ==
md_update( &ctx, src_str, strlen( (
char *) src_str ) ) );
1590 fct_chk ( 0 ==
md_finish( &ctx, output ) );
1595 fct_chk( strcmp( (
char *) hash_str,
"da33def2a42df13975352846c30338cd" ) == 0 );
1600 #ifdef POLARSSL_MD2_C
1602 FCT_TEST_BGN(generic_multi_step_md2_test_vector_rfc1319_7)
1605 unsigned char src_str[1000];
1606 unsigned char hash_str[1000];
1607 unsigned char output[100];
1612 memset(md_name, 0x00, 100);
1613 memset(src_str, 0x00, 1000);
1614 memset(hash_str, 0x00, 1000);
1615 memset(output, 0x00, 100);
1617 strcpy( (
char *) src_str,
"12345678901234567890123456789012345678901234567890123456789012345678901234567890" );
1619 strncpy( (
char *) md_name,
"md2", 100 );
1621 fct_chk( md_info != NULL );
1625 fct_chk ( ctx.
md_ctx != NULL );
1626 fct_chk ( 0 ==
md_update( &ctx, src_str, strlen( (
char *) src_str ) ) );
1627 fct_chk ( 0 ==
md_finish( &ctx, output ) );
1632 fct_chk( strcmp( (
char *) hash_str,
"d5976f79d83d3a0dc9806c3c66f3efd8" ) == 0 );
1637 #ifdef POLARSSL_MD4_C
1639 FCT_TEST_BGN(generic_multi_step_md4_test_vector_rfc1320_1)
1642 unsigned char src_str[1000];
1643 unsigned char hash_str[1000];
1644 unsigned char output[100];
1649 memset(md_name, 0x00, 100);
1650 memset(src_str, 0x00, 1000);
1651 memset(hash_str, 0x00, 1000);
1652 memset(output, 0x00, 100);
1654 strcpy( (
char *) src_str,
"" );
1656 strncpy( (
char *) md_name,
"md4", 100 );
1658 fct_chk( md_info != NULL );
1662 fct_chk ( ctx.
md_ctx != NULL );
1663 fct_chk ( 0 ==
md_update( &ctx, src_str, strlen( (
char *) src_str ) ) );
1664 fct_chk ( 0 ==
md_finish( &ctx, output ) );
1669 fct_chk( strcmp( (
char *) hash_str,
"31d6cfe0d16ae931b73c59d7e0c089c0" ) == 0 );
1674 #ifdef POLARSSL_MD4_C
1676 FCT_TEST_BGN(generic_multi_step_md4_test_vector_rfc1320_2)
1679 unsigned char src_str[1000];
1680 unsigned char hash_str[1000];
1681 unsigned char output[100];
1686 memset(md_name, 0x00, 100);
1687 memset(src_str, 0x00, 1000);
1688 memset(hash_str, 0x00, 1000);
1689 memset(output, 0x00, 100);
1691 strcpy( (
char *) src_str,
"a" );
1693 strncpy( (
char *) md_name,
"md4", 100 );
1695 fct_chk( md_info != NULL );
1699 fct_chk ( ctx.
md_ctx != NULL );
1700 fct_chk ( 0 ==
md_update( &ctx, src_str, strlen( (
char *) src_str ) ) );
1701 fct_chk ( 0 ==
md_finish( &ctx, output ) );
1706 fct_chk( strcmp( (
char *) hash_str,
"bde52cb31de33e46245e05fbdbd6fb24" ) == 0 );
1711 #ifdef POLARSSL_MD4_C
1713 FCT_TEST_BGN(generic_multi_step_md4_test_vector_rfc1320_3)
1716 unsigned char src_str[1000];
1717 unsigned char hash_str[1000];
1718 unsigned char output[100];
1723 memset(md_name, 0x00, 100);
1724 memset(src_str, 0x00, 1000);
1725 memset(hash_str, 0x00, 1000);
1726 memset(output, 0x00, 100);
1728 strcpy( (
char *) src_str,
"abc" );
1730 strncpy( (
char *) md_name,
"md4", 100 );
1732 fct_chk( md_info != NULL );
1736 fct_chk ( ctx.
md_ctx != NULL );
1737 fct_chk ( 0 ==
md_update( &ctx, src_str, strlen( (
char *) src_str ) ) );
1738 fct_chk ( 0 ==
md_finish( &ctx, output ) );
1743 fct_chk( strcmp( (
char *) hash_str,
"a448017aaf21d8525fc10ae87aa6729d" ) == 0 );
1748 #ifdef POLARSSL_MD4_C
1750 FCT_TEST_BGN(generic_multi_step_md4_test_vector_rfc1320_4)
1753 unsigned char src_str[1000];
1754 unsigned char hash_str[1000];
1755 unsigned char output[100];
1760 memset(md_name, 0x00, 100);
1761 memset(src_str, 0x00, 1000);
1762 memset(hash_str, 0x00, 1000);
1763 memset(output, 0x00, 100);
1765 strcpy( (
char *) src_str,
"message digest" );
1767 strncpy( (
char *) md_name,
"md4", 100 );
1769 fct_chk( md_info != NULL );
1773 fct_chk ( ctx.
md_ctx != NULL );
1774 fct_chk ( 0 ==
md_update( &ctx, src_str, strlen( (
char *) src_str ) ) );
1775 fct_chk ( 0 ==
md_finish( &ctx, output ) );
1780 fct_chk( strcmp( (
char *) hash_str,
"d9130a8164549fe818874806e1c7014b" ) == 0 );
1785 #ifdef POLARSSL_MD4_C
1787 FCT_TEST_BGN(generic_multi_step_md4_test_vector_rfc1320_5)
1790 unsigned char src_str[1000];
1791 unsigned char hash_str[1000];
1792 unsigned char output[100];
1797 memset(md_name, 0x00, 100);
1798 memset(src_str, 0x00, 1000);
1799 memset(hash_str, 0x00, 1000);
1800 memset(output, 0x00, 100);
1802 strcpy( (
char *) src_str,
"abcdefghijklmnopqrstuvwxyz" );
1804 strncpy( (
char *) md_name,
"md4", 100 );
1806 fct_chk( md_info != NULL );
1810 fct_chk ( ctx.
md_ctx != NULL );
1811 fct_chk ( 0 ==
md_update( &ctx, src_str, strlen( (
char *) src_str ) ) );
1812 fct_chk ( 0 ==
md_finish( &ctx, output ) );
1817 fct_chk( strcmp( (
char *) hash_str,
"d79e1c308aa5bbcdeea8ed63df412da9" ) == 0 );
1822 #ifdef POLARSSL_MD4_C
1824 FCT_TEST_BGN(generic_multi_step_md4_test_vector_rfc1320_6)
1827 unsigned char src_str[1000];
1828 unsigned char hash_str[1000];
1829 unsigned char output[100];
1834 memset(md_name, 0x00, 100);
1835 memset(src_str, 0x00, 1000);
1836 memset(hash_str, 0x00, 1000);
1837 memset(output, 0x00, 100);
1839 strcpy( (
char *) src_str,
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" );
1841 strncpy( (
char *) md_name,
"md4", 100 );
1843 fct_chk( md_info != NULL );
1847 fct_chk ( ctx.
md_ctx != NULL );
1848 fct_chk ( 0 ==
md_update( &ctx, src_str, strlen( (
char *) src_str ) ) );
1849 fct_chk ( 0 ==
md_finish( &ctx, output ) );
1854 fct_chk( strcmp( (
char *) hash_str,
"043f8582f241db351ce627e153e7f0e4" ) == 0 );
1859 #ifdef POLARSSL_MD4_C
1861 FCT_TEST_BGN(generic_multi_step_md4_test_vector_rfc1320_7)
1864 unsigned char src_str[1000];
1865 unsigned char hash_str[1000];
1866 unsigned char output[100];
1871 memset(md_name, 0x00, 100);
1872 memset(src_str, 0x00, 1000);
1873 memset(hash_str, 0x00, 1000);
1874 memset(output, 0x00, 100);
1876 strcpy( (
char *) src_str,
"12345678901234567890123456789012345678901234567890123456789012345678901234567890" );
1878 strncpy( (
char *) md_name,
"md4", 100 );
1880 fct_chk( md_info != NULL );
1884 fct_chk ( ctx.
md_ctx != NULL );
1885 fct_chk ( 0 ==
md_update( &ctx, src_str, strlen( (
char *) src_str ) ) );
1886 fct_chk ( 0 ==
md_finish( &ctx, output ) );
1891 fct_chk( strcmp( (
char *) hash_str,
"e33b4ddc9c38f2199c3e7b164fcc0536" ) == 0 );
1896 #ifdef POLARSSL_MD5_C
1898 FCT_TEST_BGN(generic_multi_step_md5_test_vector_rfc1321_1)
1901 unsigned char src_str[1000];
1902 unsigned char hash_str[1000];
1903 unsigned char output[100];
1908 memset(md_name, 0x00, 100);
1909 memset(src_str, 0x00, 1000);
1910 memset(hash_str, 0x00, 1000);
1911 memset(output, 0x00, 100);
1913 strcpy( (
char *) src_str,
"" );
1915 strncpy( (
char *) md_name,
"md5", 100 );
1917 fct_chk( md_info != NULL );
1921 fct_chk ( ctx.
md_ctx != NULL );
1922 fct_chk ( 0 ==
md_update( &ctx, src_str, strlen( (
char *) src_str ) ) );
1923 fct_chk ( 0 ==
md_finish( &ctx, output ) );
1928 fct_chk( strcmp( (
char *) hash_str,
"d41d8cd98f00b204e9800998ecf8427e" ) == 0 );
1933 #ifdef POLARSSL_MD5_C
1935 FCT_TEST_BGN(generic_multi_step_md5_test_vector_rfc1321_2)
1938 unsigned char src_str[1000];
1939 unsigned char hash_str[1000];
1940 unsigned char output[100];
1945 memset(md_name, 0x00, 100);
1946 memset(src_str, 0x00, 1000);
1947 memset(hash_str, 0x00, 1000);
1948 memset(output, 0x00, 100);
1950 strcpy( (
char *) src_str,
"a" );
1952 strncpy( (
char *) md_name,
"md5", 100 );
1954 fct_chk( md_info != NULL );
1958 fct_chk ( ctx.
md_ctx != NULL );
1959 fct_chk ( 0 ==
md_update( &ctx, src_str, strlen( (
char *) src_str ) ) );
1960 fct_chk ( 0 ==
md_finish( &ctx, output ) );
1965 fct_chk( strcmp( (
char *) hash_str,
"0cc175b9c0f1b6a831c399e269772661" ) == 0 );
1970 #ifdef POLARSSL_MD5_C
1972 FCT_TEST_BGN(generic_multi_step_md5_test_vector_rfc1321_3)
1975 unsigned char src_str[1000];
1976 unsigned char hash_str[1000];
1977 unsigned char output[100];
1982 memset(md_name, 0x00, 100);
1983 memset(src_str, 0x00, 1000);
1984 memset(hash_str, 0x00, 1000);
1985 memset(output, 0x00, 100);
1987 strcpy( (
char *) src_str,
"abc" );
1989 strncpy( (
char *) md_name,
"md5", 100 );
1991 fct_chk( md_info != NULL );
1995 fct_chk ( ctx.
md_ctx != NULL );
1996 fct_chk ( 0 ==
md_update( &ctx, src_str, strlen( (
char *) src_str ) ) );
1997 fct_chk ( 0 ==
md_finish( &ctx, output ) );
2002 fct_chk( strcmp( (
char *) hash_str,
"900150983cd24fb0d6963f7d28e17f72" ) == 0 );
2007 #ifdef POLARSSL_MD5_C
2009 FCT_TEST_BGN(generic_multi_step_md5_test_vector_rfc1321_4)
2012 unsigned char src_str[1000];
2013 unsigned char hash_str[1000];
2014 unsigned char output[100];
2019 memset(md_name, 0x00, 100);
2020 memset(src_str, 0x00, 1000);
2021 memset(hash_str, 0x00, 1000);
2022 memset(output, 0x00, 100);
2024 strcpy( (
char *) src_str,
"message digest" );
2026 strncpy( (
char *) md_name,
"md5", 100 );
2028 fct_chk( md_info != NULL );
2032 fct_chk ( ctx.
md_ctx != NULL );
2033 fct_chk ( 0 ==
md_update( &ctx, src_str, strlen( (
char *) src_str ) ) );
2034 fct_chk ( 0 ==
md_finish( &ctx, output ) );
2039 fct_chk( strcmp( (
char *) hash_str,
"f96b697d7cb7938d525a2f31aaf161d0" ) == 0 );
2044 #ifdef POLARSSL_MD5_C
2046 FCT_TEST_BGN(generic_multi_step_md5_test_vector_rfc1321_5)
2049 unsigned char src_str[1000];
2050 unsigned char hash_str[1000];
2051 unsigned char output[100];
2056 memset(md_name, 0x00, 100);
2057 memset(src_str, 0x00, 1000);
2058 memset(hash_str, 0x00, 1000);
2059 memset(output, 0x00, 100);
2061 strcpy( (
char *) src_str,
"abcdefghijklmnopqrstuvwxyz" );
2063 strncpy( (
char *) md_name,
"md5", 100 );
2065 fct_chk( md_info != NULL );
2069 fct_chk ( ctx.
md_ctx != NULL );
2070 fct_chk ( 0 ==
md_update( &ctx, src_str, strlen( (
char *) src_str ) ) );
2071 fct_chk ( 0 ==
md_finish( &ctx, output ) );
2076 fct_chk( strcmp( (
char *) hash_str,
"c3fcd3d76192e4007dfb496cca67e13b" ) == 0 );
2081 #ifdef POLARSSL_MD5_C
2083 FCT_TEST_BGN(generic_multi_step_md5_test_vector_rfc1321_6)
2086 unsigned char src_str[1000];
2087 unsigned char hash_str[1000];
2088 unsigned char output[100];
2093 memset(md_name, 0x00, 100);
2094 memset(src_str, 0x00, 1000);
2095 memset(hash_str, 0x00, 1000);
2096 memset(output, 0x00, 100);
2098 strcpy( (
char *) src_str,
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" );
2100 strncpy( (
char *) md_name,
"md5", 100 );
2102 fct_chk( md_info != NULL );
2106 fct_chk ( ctx.
md_ctx != NULL );
2107 fct_chk ( 0 ==
md_update( &ctx, src_str, strlen( (
char *) src_str ) ) );
2108 fct_chk ( 0 ==
md_finish( &ctx, output ) );
2113 fct_chk( strcmp( (
char *) hash_str,
"d174ab98d277d9f5a5611c2c9f419d9f" ) == 0 );
2118 #ifdef POLARSSL_MD5_C
2120 FCT_TEST_BGN(generic_multi_step_md5_test_vector_rfc1321_7)
2123 unsigned char src_str[1000];
2124 unsigned char hash_str[1000];
2125 unsigned char output[100];
2130 memset(md_name, 0x00, 100);
2131 memset(src_str, 0x00, 1000);
2132 memset(hash_str, 0x00, 1000);
2133 memset(output, 0x00, 100);
2135 strcpy( (
char *) src_str,
"12345678901234567890123456789012345678901234567890123456789012345678901234567890" );
2137 strncpy( (
char *) md_name,
"md5", 100 );
2139 fct_chk( md_info != NULL );
2143 fct_chk ( ctx.
md_ctx != NULL );
2144 fct_chk ( 0 ==
md_update( &ctx, src_str, strlen( (
char *) src_str ) ) );
2145 fct_chk ( 0 ==
md_finish( &ctx, output ) );
2150 fct_chk( strcmp( (
char *) hash_str,
"57edf4a22be3c955ac49da2e2107b67a" ) == 0 );
2155 #ifdef POLARSSL_MD2_C
2157 FCT_TEST_BGN(generic_multi_step_hmac_md2_hash_file_openssl_test_1)
2160 unsigned char src_str[10000];
2161 unsigned char key_str[10000];
2162 unsigned char hash_str[10000];
2163 unsigned char output[100];
2164 int key_len, src_len;
2168 memset(md_name, 0x00, 100);
2169 memset(src_str, 0x00, 10000);
2170 memset(key_str, 0x00, 10000);
2171 memset(hash_str, 0x00, 10000);
2172 memset(output, 0x00, 100);
2174 strncpy( (
char *) md_name,
"md2", 100 );
2176 fct_chk( md_info != NULL );
2179 key_len =
unhexify( key_str,
"61616161616161616161616161616161" );
2180 src_len =
unhexify( src_str,
"b91ce5ac77d33c234e61002ed6" );
2183 fct_chk ( ctx.
md_ctx != NULL );
2190 fct_chk( strncmp( (
char *) hash_str,
"d5732582f494f5ddf35efd166c85af9c", 16 * 2 ) == 0 );
2195 #ifdef POLARSSL_MD2_C
2197 FCT_TEST_BGN(generic_multi_step_hmac_md2_hash_file_openssl_test_2)
2200 unsigned char src_str[10000];
2201 unsigned char key_str[10000];
2202 unsigned char hash_str[10000];
2203 unsigned char output[100];
2204 int key_len, src_len;
2208 memset(md_name, 0x00, 100);
2209 memset(src_str, 0x00, 10000);
2210 memset(key_str, 0x00, 10000);
2211 memset(hash_str, 0x00, 10000);
2212 memset(output, 0x00, 100);
2214 strncpy( (
char *) md_name,
"md2", 100 );
2216 fct_chk( md_info != NULL );
2219 key_len =
unhexify( key_str,
"61616161616161616161616161616161" );
2220 src_len =
unhexify( src_str,
"270fcf11f27c27448457d7049a7edb084a3e554e0b2acf5806982213f0ad516402e4c869c4ff2171e18e3489baa3125d2c3056ebb616296f9b6aa97ef68eeabcdc0b6dde47775004096a241efcf0a90d19b34e898cc7340cdc940f8bdd46e23e352f34bca131d4d67a7c2ddb8d0d68b67f06152a128168e1c341c37e0a66c5018999b7059bcc300beed2c19dd1152d2fe062853293b8f3c8b5" );
2223 fct_chk ( ctx.
md_ctx != NULL );
2230 fct_chk( strncmp( (
char *) hash_str,
"54ab68503f7d1b5c7741340dff2722a9", 16 * 2 ) == 0 );
2235 #ifdef POLARSSL_MD2_C
2237 FCT_TEST_BGN(generic_multi_step_hmac_md2_hash_file_openssl_test_3)
2240 unsigned char src_str[10000];
2241 unsigned char key_str[10000];
2242 unsigned char hash_str[10000];
2243 unsigned char output[100];
2244 int key_len, src_len;
2248 memset(md_name, 0x00, 100);
2249 memset(src_str, 0x00, 10000);
2250 memset(key_str, 0x00, 10000);
2251 memset(hash_str, 0x00, 10000);
2252 memset(output, 0x00, 100);
2254 strncpy( (
char *) md_name,
"md2", 100 );
2256 fct_chk( md_info != NULL );
2259 key_len =
unhexify( key_str,
"61616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161" );
2260 src_len =
unhexify( src_str,
"b91ce5ac77d33c234e61002ed6" );
2263 fct_chk ( ctx.
md_ctx != NULL );
2270 fct_chk( strncmp( (
char *) hash_str,
"d850e5f554558cf0fe79a0612e1d0365", 16 * 2 ) == 0 );
2275 #ifdef POLARSSL_MD4_C
2277 FCT_TEST_BGN(generic_multi_step_hmac_md4_hash_file_openssl_test_1)
2280 unsigned char src_str[10000];
2281 unsigned char key_str[10000];
2282 unsigned char hash_str[10000];
2283 unsigned char output[100];
2284 int key_len, src_len;
2288 memset(md_name, 0x00, 100);
2289 memset(src_str, 0x00, 10000);
2290 memset(key_str, 0x00, 10000);
2291 memset(hash_str, 0x00, 10000);
2292 memset(output, 0x00, 100);
2294 strncpy( (
char *) md_name,
"md4", 100 );
2296 fct_chk( md_info != NULL );
2299 key_len =
unhexify( key_str,
"61616161616161616161616161616161" );
2300 src_len =
unhexify( src_str,
"b91ce5ac77d33c234e61002ed6" );
2303 fct_chk ( ctx.
md_ctx != NULL );
2310 fct_chk( strncmp( (
char *) hash_str,
"eabd0fbefb82fb0063a25a6d7b8bdc0f", 16 * 2 ) == 0 );
2315 #ifdef POLARSSL_MD4_C
2317 FCT_TEST_BGN(generic_multi_step_hmac_md4_hash_file_openssl_test_2)
2320 unsigned char src_str[10000];
2321 unsigned char key_str[10000];
2322 unsigned char hash_str[10000];
2323 unsigned char output[100];
2324 int key_len, src_len;
2328 memset(md_name, 0x00, 100);
2329 memset(src_str, 0x00, 10000);
2330 memset(key_str, 0x00, 10000);
2331 memset(hash_str, 0x00, 10000);
2332 memset(output, 0x00, 100);
2334 strncpy( (
char *) md_name,
"md4", 100 );
2336 fct_chk( md_info != NULL );
2339 key_len =
unhexify( key_str,
"61616161616161616161616161616161" );
2340 src_len =
unhexify( src_str,
"270fcf11f27c27448457d7049a7edb084a3e554e0b2acf5806982213f0ad516402e4c869c4ff2171e18e3489baa3125d2c3056ebb616296f9b6aa97ef68eeabcdc0b6dde47775004096a241efcf0a90d19b34e898cc7340cdc940f8bdd46e23e352f34bca131d4d67a7c2ddb8d0d68b67f06152a128168e1c341c37e0a66c5018999b7059bcc300beed2c19dd1152d2fe062853293b8f3c8b5" );
2343 fct_chk ( ctx.
md_ctx != NULL );
2350 fct_chk( strncmp( (
char *) hash_str,
"cec3c5e421a7b783aa89cacf78daf6dc", 16 * 2 ) == 0 );
2355 #ifdef POLARSSL_MD4_C
2357 FCT_TEST_BGN(generic_multi_step_hmac_md4_hash_file_openssl_test_3)
2360 unsigned char src_str[10000];
2361 unsigned char key_str[10000];
2362 unsigned char hash_str[10000];
2363 unsigned char output[100];
2364 int key_len, src_len;
2368 memset(md_name, 0x00, 100);
2369 memset(src_str, 0x00, 10000);
2370 memset(key_str, 0x00, 10000);
2371 memset(hash_str, 0x00, 10000);
2372 memset(output, 0x00, 100);
2374 strncpy( (
char *) md_name,
"md4", 100 );
2376 fct_chk( md_info != NULL );
2379 key_len =
unhexify( key_str,
"61616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161" );
2380 src_len =
unhexify( src_str,
"b91ce5ac77d33c234e61002ed6" );
2383 fct_chk ( ctx.
md_ctx != NULL );
2390 fct_chk( strncmp( (
char *) hash_str,
"ad5f0a04116109b397b57f9cc9b6df4b", 16 * 2 ) == 0 );
2395 #ifdef POLARSSL_MD5_C
2397 FCT_TEST_BGN(generic_multi_step_hmac_md5_hash_file_openssl_test_1)
2400 unsigned char src_str[10000];
2401 unsigned char key_str[10000];
2402 unsigned char hash_str[10000];
2403 unsigned char output[100];
2404 int key_len, src_len;
2408 memset(md_name, 0x00, 100);
2409 memset(src_str, 0x00, 10000);
2410 memset(key_str, 0x00, 10000);
2411 memset(hash_str, 0x00, 10000);
2412 memset(output, 0x00, 100);
2414 strncpy( (
char *) md_name,
"md5", 100 );
2416 fct_chk( md_info != NULL );
2419 key_len =
unhexify( key_str,
"61616161616161616161616161616161" );
2420 src_len =
unhexify( src_str,
"b91ce5ac77d33c234e61002ed6" );
2423 fct_chk ( ctx.
md_ctx != NULL );
2430 fct_chk( strncmp( (
char *) hash_str,
"42552882f00bd4633ea81135a184b284", 16 * 2 ) == 0 );
2435 #ifdef POLARSSL_MD5_C
2437 FCT_TEST_BGN(generic_multi_step_hmac_md5_hash_file_openssl_test_2)
2440 unsigned char src_str[10000];
2441 unsigned char key_str[10000];
2442 unsigned char hash_str[10000];
2443 unsigned char output[100];
2444 int key_len, src_len;
2448 memset(md_name, 0x00, 100);
2449 memset(src_str, 0x00, 10000);
2450 memset(key_str, 0x00, 10000);
2451 memset(hash_str, 0x00, 10000);
2452 memset(output, 0x00, 100);
2454 strncpy( (
char *) md_name,
"md5", 100 );
2456 fct_chk( md_info != NULL );
2459 key_len =
unhexify( key_str,
"61616161616161616161616161616161" );
2460 src_len =
unhexify( src_str,
"270fcf11f27c27448457d7049a7edb084a3e554e0b2acf5806982213f0ad516402e4c869c4ff2171e18e3489baa3125d2c3056ebb616296f9b6aa97ef68eeabcdc0b6dde47775004096a241efcf0a90d19b34e898cc7340cdc940f8bdd46e23e352f34bca131d4d67a7c2ddb8d0d68b67f06152a128168e1c341c37e0a66c5018999b7059bcc300beed2c19dd1152d2fe062853293b8f3c8b5" );
2463 fct_chk ( ctx.
md_ctx != NULL );
2470 fct_chk( strncmp( (
char *) hash_str,
"a16a842891786d01fe50ba7731db7464", 16 * 2 ) == 0 );
2475 #ifdef POLARSSL_MD5_C
2477 FCT_TEST_BGN(generic_multi_step_hmac_md5_hash_file_openssl_test_3)
2480 unsigned char src_str[10000];
2481 unsigned char key_str[10000];
2482 unsigned char hash_str[10000];
2483 unsigned char output[100];
2484 int key_len, src_len;
2488 memset(md_name, 0x00, 100);
2489 memset(src_str, 0x00, 10000);
2490 memset(key_str, 0x00, 10000);
2491 memset(hash_str, 0x00, 10000);
2492 memset(output, 0x00, 100);
2494 strncpy( (
char *) md_name,
"md5", 100 );
2496 fct_chk( md_info != NULL );
2499 key_len =
unhexify( key_str,
"61616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161" );
2500 src_len =
unhexify( src_str,
"b91ce5ac77d33c234e61002ed6" );
2503 fct_chk ( ctx.
md_ctx != NULL );
2510 fct_chk( strncmp( (
char *) hash_str,
"e97f623936f98a7f741c4bd0612fecc2", 16 * 2 ) == 0 );
2515 #ifdef POLARSSL_MD5_C
2517 FCT_TEST_BGN(generic_multi_step_hmac_md5_test_vector_rfc2202_1)
2520 unsigned char src_str[10000];
2521 unsigned char key_str[10000];
2522 unsigned char hash_str[10000];
2523 unsigned char output[100];
2524 int key_len, src_len;
2528 memset(md_name, 0x00, 100);
2529 memset(src_str, 0x00, 10000);
2530 memset(key_str, 0x00, 10000);
2531 memset(hash_str, 0x00, 10000);
2532 memset(output, 0x00, 100);
2534 strncpy( (
char *) md_name,
"md5", 100 );
2536 fct_chk( md_info != NULL );
2539 key_len =
unhexify( key_str,
"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b" );
2540 src_len =
unhexify( src_str,
"4869205468657265" );
2543 fct_chk ( ctx.
md_ctx != NULL );
2550 fct_chk( strncmp( (
char *) hash_str,
"9294727a3638bb1c13f48ef8158bfc9d", 16 * 2 ) == 0 );
2555 #ifdef POLARSSL_MD5_C
2557 FCT_TEST_BGN(generic_multi_step_hmac_md5_test_vector_rfc2202_2)
2560 unsigned char src_str[10000];
2561 unsigned char key_str[10000];
2562 unsigned char hash_str[10000];
2563 unsigned char output[100];
2564 int key_len, src_len;
2568 memset(md_name, 0x00, 100);
2569 memset(src_str, 0x00, 10000);
2570 memset(key_str, 0x00, 10000);
2571 memset(hash_str, 0x00, 10000);
2572 memset(output, 0x00, 100);
2574 strncpy( (
char *) md_name,
"md5", 100 );
2576 fct_chk( md_info != NULL );
2579 key_len =
unhexify( key_str,
"4a656665" );
2580 src_len =
unhexify( src_str,
"7768617420646f2079612077616e7420666f72206e6f7468696e673f" );
2583 fct_chk ( ctx.
md_ctx != NULL );
2590 fct_chk( strncmp( (
char *) hash_str,
"750c783e6ab0b503eaa86e310a5db738", 16 * 2 ) == 0 );
2595 #ifdef POLARSSL_MD5_C
2597 FCT_TEST_BGN(generic_multi_step_hmac_md5_test_vector_rfc2202_3)
2600 unsigned char src_str[10000];
2601 unsigned char key_str[10000];
2602 unsigned char hash_str[10000];
2603 unsigned char output[100];
2604 int key_len, src_len;
2608 memset(md_name, 0x00, 100);
2609 memset(src_str, 0x00, 10000);
2610 memset(key_str, 0x00, 10000);
2611 memset(hash_str, 0x00, 10000);
2612 memset(output, 0x00, 100);
2614 strncpy( (
char *) md_name,
"md5", 100 );
2616 fct_chk( md_info != NULL );
2619 key_len =
unhexify( key_str,
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" );
2620 src_len =
unhexify( src_str,
"dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd" );
2623 fct_chk ( ctx.
md_ctx != NULL );
2630 fct_chk( strncmp( (
char *) hash_str,
"56be34521d144c88dbb8c733f0e8b3f6", 16 * 2 ) == 0 );
2635 #ifdef POLARSSL_MD5_C
2637 FCT_TEST_BGN(generic_multi_step_hmac_md5_test_vector_rfc2202_4)
2640 unsigned char src_str[10000];
2641 unsigned char key_str[10000];
2642 unsigned char hash_str[10000];
2643 unsigned char output[100];
2644 int key_len, src_len;
2648 memset(md_name, 0x00, 100);
2649 memset(src_str, 0x00, 10000);
2650 memset(key_str, 0x00, 10000);
2651 memset(hash_str, 0x00, 10000);
2652 memset(output, 0x00, 100);
2654 strncpy( (
char *) md_name,
"md5", 100 );
2656 fct_chk( md_info != NULL );
2659 key_len =
unhexify( key_str,
"0102030405060708090a0b0c0d0e0f10111213141516171819" );
2660 src_len =
unhexify( src_str,
"cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd" );
2663 fct_chk ( ctx.
md_ctx != NULL );
2670 fct_chk( strncmp( (
char *) hash_str,
"697eaf0aca3a3aea3a75164746ffaa79", 16 * 2 ) == 0 );
2675 #ifdef POLARSSL_MD5_C
2677 FCT_TEST_BGN(generic_multi_step_hmac_md5_test_vector_rfc2202_5)
2680 unsigned char src_str[10000];
2681 unsigned char key_str[10000];
2682 unsigned char hash_str[10000];
2683 unsigned char output[100];
2684 int key_len, src_len;
2688 memset(md_name, 0x00, 100);
2689 memset(src_str, 0x00, 10000);
2690 memset(key_str, 0x00, 10000);
2691 memset(hash_str, 0x00, 10000);
2692 memset(output, 0x00, 100);
2694 strncpy( (
char *) md_name,
"md5", 100 );
2696 fct_chk( md_info != NULL );
2699 key_len =
unhexify( key_str,
"0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c" );
2700 src_len =
unhexify( src_str,
"546573742057697468205472756e636174696f6e" );
2703 fct_chk ( ctx.
md_ctx != NULL );
2710 fct_chk( strncmp( (
char *) hash_str,
"56461ef2342edc00f9bab995", 12 * 2 ) == 0 );
2715 #ifdef POLARSSL_MD5_C
2717 FCT_TEST_BGN(generic_multi_step_hmac_md5_test_vector_rfc2202_6)
2720 unsigned char src_str[10000];
2721 unsigned char key_str[10000];
2722 unsigned char hash_str[10000];
2723 unsigned char output[100];
2724 int key_len, src_len;
2728 memset(md_name, 0x00, 100);
2729 memset(src_str, 0x00, 10000);
2730 memset(key_str, 0x00, 10000);
2731 memset(hash_str, 0x00, 10000);
2732 memset(output, 0x00, 100);
2734 strncpy( (
char *) md_name,
"md5", 100 );
2736 fct_chk( md_info != NULL );
2739 key_len =
unhexify( key_str,
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" );
2740 src_len =
unhexify( src_str,
"54657374205573696e67204c6172676572205468616e20426c6f636b2d53697a65204b6579202d2048617368204b6579204669727374" );
2743 fct_chk ( ctx.
md_ctx != NULL );
2750 fct_chk( strncmp( (
char *) hash_str,
"6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd", 16 * 2 ) == 0 );
2755 #ifdef POLARSSL_MD5_C
2757 FCT_TEST_BGN(generic_multi_step_hmac_md5_test_vector_rfc2202_7)
2760 unsigned char src_str[10000];
2761 unsigned char key_str[10000];
2762 unsigned char hash_str[10000];
2763 unsigned char output[100];
2764 int key_len, src_len;
2768 memset(md_name, 0x00, 100);
2769 memset(src_str, 0x00, 10000);
2770 memset(key_str, 0x00, 10000);
2771 memset(hash_str, 0x00, 10000);
2772 memset(output, 0x00, 100);
2774 strncpy( (
char *) md_name,
"md5", 100 );
2776 fct_chk( md_info != NULL );
2779 key_len =
unhexify( key_str,
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" );
2780 src_len =
unhexify( src_str,
"54657374205573696e67204c6172676572205468616e20426c6f636b2d53697a65204b657920616e64204c6172676572205468616e204f6e6520426c6f636b2d53697a652044617461" );
2783 fct_chk ( ctx.
md_ctx != NULL );
2790 fct_chk( strncmp( (
char *) hash_str,
"6f630fad67cda0ee1fb1f562db3aa53e", 16 * 2 ) == 0 );
2795 #ifdef POLARSSL_MD2_C
2796 #ifdef POLARSSL_FS_IO
2798 FCT_TEST_BGN(generic_md2_hash_file_1)
2801 unsigned char hash_str[1000];
2802 unsigned char output[100];
2805 memset(md_name, 0x00, 100);
2806 memset(hash_str, 0x00, 1000);
2807 memset(output, 0x00, 100);
2809 strncpy( (
char *) md_name,
"md2", 100 );
2811 fct_chk( md_info != NULL );
2813 md_file( md_info,
"data_files/hash_file_1", output);
2816 fct_chk( strcmp( (
char *) hash_str,
"b593c098712d2e21628c8986695451a8" ) == 0 );
2822 #ifdef POLARSSL_MD2_C
2823 #ifdef POLARSSL_FS_IO
2825 FCT_TEST_BGN(generic_md2_hash_file_2)
2828 unsigned char hash_str[1000];
2829 unsigned char output[100];
2832 memset(md_name, 0x00, 100);
2833 memset(hash_str, 0x00, 1000);
2834 memset(output, 0x00, 100);
2836 strncpy( (
char *) md_name,
"md2", 100 );
2838 fct_chk( md_info != NULL );
2840 md_file( md_info,
"data_files/hash_file_2", output);
2843 fct_chk( strcmp( (
char *) hash_str,
"3c027b7409909a4c4b26bbab69ad9f4f" ) == 0 );
2849 #ifdef POLARSSL_MD2_C
2850 #ifdef POLARSSL_FS_IO
2852 FCT_TEST_BGN(generic_md2_hash_file_3)
2855 unsigned char hash_str[1000];
2856 unsigned char output[100];
2859 memset(md_name, 0x00, 100);
2860 memset(hash_str, 0x00, 1000);
2861 memset(output, 0x00, 100);
2863 strncpy( (
char *) md_name,
"md2", 100 );
2865 fct_chk( md_info != NULL );
2867 md_file( md_info,
"data_files/hash_file_3", output);
2870 fct_chk( strcmp( (
char *) hash_str,
"6bb43eb285e81f414083a94cdbe2989d" ) == 0 );
2876 #ifdef POLARSSL_MD2_C
2877 #ifdef POLARSSL_FS_IO
2879 FCT_TEST_BGN(generic_md2_hash_file_4)
2882 unsigned char hash_str[1000];
2883 unsigned char output[100];
2886 memset(md_name, 0x00, 100);
2887 memset(hash_str, 0x00, 1000);
2888 memset(output, 0x00, 100);
2890 strncpy( (
char *) md_name,
"md2", 100 );
2892 fct_chk( md_info != NULL );
2894 md_file( md_info,
"data_files/hash_file_4", output);
2897 fct_chk( strcmp( (
char *) hash_str,
"8350e5a3e24c153df2275c9f80692773" ) == 0 );
2903 #ifdef POLARSSL_MD4_C
2904 #ifdef POLARSSL_FS_IO
2906 FCT_TEST_BGN(generic_md4_hash_file_1)
2909 unsigned char hash_str[1000];
2910 unsigned char output[100];
2913 memset(md_name, 0x00, 100);
2914 memset(hash_str, 0x00, 1000);
2915 memset(output, 0x00, 100);
2917 strncpy( (
char *) md_name,
"md4", 100 );
2919 fct_chk( md_info != NULL );
2921 md_file( md_info,
"data_files/hash_file_1", output);
2924 fct_chk( strcmp( (
char *) hash_str,
"8d19772c176bd27153b9486715e2c0b9" ) == 0 );
2930 #ifdef POLARSSL_MD4_C
2931 #ifdef POLARSSL_FS_IO
2933 FCT_TEST_BGN(generic_md4_hash_file_2)
2936 unsigned char hash_str[1000];
2937 unsigned char output[100];
2940 memset(md_name, 0x00, 100);
2941 memset(hash_str, 0x00, 1000);
2942 memset(output, 0x00, 100);
2944 strncpy( (
char *) md_name,
"md4", 100 );
2946 fct_chk( md_info != NULL );
2948 md_file( md_info,
"data_files/hash_file_2", output);
2951 fct_chk( strcmp( (
char *) hash_str,
"f2ac53b8542882a5a0007c6f84b4d9fd" ) == 0 );
2957 #ifdef POLARSSL_MD4_C
2958 #ifdef POLARSSL_FS_IO
2960 FCT_TEST_BGN(generic_md4_hash_file_3)
2963 unsigned char hash_str[1000];
2964 unsigned char output[100];
2967 memset(md_name, 0x00, 100);
2968 memset(hash_str, 0x00, 1000);
2969 memset(output, 0x00, 100);
2971 strncpy( (
char *) md_name,
"md4", 100 );
2973 fct_chk( md_info != NULL );
2975 md_file( md_info,
"data_files/hash_file_3", output);
2978 fct_chk( strcmp( (
char *) hash_str,
"195c15158e2d07881d9a654095ce4a42" ) == 0 );
2984 #ifdef POLARSSL_MD4_C
2985 #ifdef POLARSSL_FS_IO
2987 FCT_TEST_BGN(generic_md4_hash_file_4)
2990 unsigned char hash_str[1000];
2991 unsigned char output[100];
2994 memset(md_name, 0x00, 100);
2995 memset(hash_str, 0x00, 1000);
2996 memset(output, 0x00, 100);
2998 strncpy( (
char *) md_name,
"md4", 100 );
3000 fct_chk( md_info != NULL );
3002 md_file( md_info,
"data_files/hash_file_4", output);
3005 fct_chk( strcmp( (
char *) hash_str,
"31d6cfe0d16ae931b73c59d7e0c089c0" ) == 0 );
3011 #ifdef POLARSSL_MD5_C
3012 #ifdef POLARSSL_FS_IO
3014 FCT_TEST_BGN(generic_md5_hash_file_1)
3017 unsigned char hash_str[1000];
3018 unsigned char output[100];
3021 memset(md_name, 0x00, 100);
3022 memset(hash_str, 0x00, 1000);
3023 memset(output, 0x00, 100);
3025 strncpy( (
char *) md_name,
"md5", 100 );
3027 fct_chk( md_info != NULL );
3029 md_file( md_info,
"data_files/hash_file_1", output);
3032 fct_chk( strcmp( (
char *) hash_str,
"52bcdc983c9ed64fc148a759b3c7a415" ) == 0 );
3038 #ifdef POLARSSL_MD5_C
3039 #ifdef POLARSSL_FS_IO
3041 FCT_TEST_BGN(generic_md5_hash_file_2)
3044 unsigned char hash_str[1000];
3045 unsigned char output[100];
3048 memset(md_name, 0x00, 100);
3049 memset(hash_str, 0x00, 1000);
3050 memset(output, 0x00, 100);
3052 strncpy( (
char *) md_name,
"md5", 100 );
3054 fct_chk( md_info != NULL );
3056 md_file( md_info,
"data_files/hash_file_2", output);
3059 fct_chk( strcmp( (
char *) hash_str,
"d17d466f15891df10542207ae78277f0" ) == 0 );
3065 #ifdef POLARSSL_MD5_C
3066 #ifdef POLARSSL_FS_IO
3068 FCT_TEST_BGN(generic_md5_hash_file_3)
3071 unsigned char hash_str[1000];
3072 unsigned char output[100];
3075 memset(md_name, 0x00, 100);
3076 memset(hash_str, 0x00, 1000);
3077 memset(output, 0x00, 100);
3079 strncpy( (
char *) md_name,
"md5", 100 );
3081 fct_chk( md_info != NULL );
3083 md_file( md_info,
"data_files/hash_file_3", output);
3086 fct_chk( strcmp( (
char *) hash_str,
"d945bcc6200ea95d061a2a818167d920" ) == 0 );
3092 #ifdef POLARSSL_MD5_C
3093 #ifdef POLARSSL_FS_IO
3095 FCT_TEST_BGN(generic_md5_hash_file_4)
3098 unsigned char hash_str[1000];
3099 unsigned char output[100];
3102 memset(md_name, 0x00, 100);
3103 memset(hash_str, 0x00, 1000);
3104 memset(output, 0x00, 100);
3106 strncpy( (
char *) md_name,
"md5", 100 );
3108 fct_chk( md_info != NULL );
3110 md_file( md_info,
"data_files/hash_file_4", output);
3113 fct_chk( strcmp( (
char *) hash_str,
"d41d8cd98f00b204e9800998ecf8427e" ) == 0 );
3119 #ifdef POLARSSL_SHA1_C
3121 FCT_TEST_BGN(generic_hmac_sha_1_test_vector_fips_198a_1)
3124 unsigned char src_str[10000];
3125 unsigned char key_str[10000];
3126 unsigned char hash_str[10000];
3127 unsigned char output[100];
3128 int key_len, src_len;
3131 memset(md_name, 0x00, 100);
3132 memset(src_str, 0x00, 10000);
3133 memset(key_str, 0x00, 10000);
3134 memset(hash_str, 0x00, 10000);
3135 memset(output, 0x00, 100);
3137 strncpy( (
char *) md_name,
"sha1", 100 );
3139 fct_chk( md_info != NULL );
3141 key_len =
unhexify( key_str,
"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f" );
3142 src_len =
unhexify( src_str,
"53616d706c65202331" );
3144 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3147 fct_chk( strncmp( (
char *) hash_str,
"4f4ca3d5d68ba7cc0a1208c9c61e9c5da0403c0a", 20 * 2 ) == 0 );
3152 #ifdef POLARSSL_SHA1_C
3154 FCT_TEST_BGN(generic_hmac_sha_1_test_vector_fips_198a_2)
3157 unsigned char src_str[10000];
3158 unsigned char key_str[10000];
3159 unsigned char hash_str[10000];
3160 unsigned char output[100];
3161 int key_len, src_len;
3164 memset(md_name, 0x00, 100);
3165 memset(src_str, 0x00, 10000);
3166 memset(key_str, 0x00, 10000);
3167 memset(hash_str, 0x00, 10000);
3168 memset(output, 0x00, 100);
3170 strncpy( (
char *) md_name,
"sha1", 100 );
3172 fct_chk( md_info != NULL );
3174 key_len =
unhexify( key_str,
"303132333435363738393a3b3c3d3e3f40414243" );
3175 src_len =
unhexify( src_str,
"53616d706c65202332" );
3177 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3180 fct_chk( strncmp( (
char *) hash_str,
"0922d3405faa3d194f82a45830737d5cc6c75d24", 20 * 2 ) == 0 );
3185 #ifdef POLARSSL_SHA1_C
3187 FCT_TEST_BGN(generic_hmac_sha_1_test_vector_fips_198a_3)
3190 unsigned char src_str[10000];
3191 unsigned char key_str[10000];
3192 unsigned char hash_str[10000];
3193 unsigned char output[100];
3194 int key_len, src_len;
3197 memset(md_name, 0x00, 100);
3198 memset(src_str, 0x00, 10000);
3199 memset(key_str, 0x00, 10000);
3200 memset(hash_str, 0x00, 10000);
3201 memset(output, 0x00, 100);
3203 strncpy( (
char *) md_name,
"sha1", 100 );
3205 fct_chk( md_info != NULL );
3207 key_len =
unhexify( key_str,
"505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3" );
3208 src_len =
unhexify( src_str,
"53616d706c65202333" );
3210 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3213 fct_chk( strncmp( (
char *) hash_str,
"bcf41eab8bb2d802f3d05caf7cb092ecf8d1a3aa", 20 * 2 ) == 0 );
3218 #ifdef POLARSSL_SHA1_C
3220 FCT_TEST_BGN(generic_hmac_sha_1_test_vector_fips_198a_4)
3223 unsigned char src_str[10000];
3224 unsigned char key_str[10000];
3225 unsigned char hash_str[10000];
3226 unsigned char output[100];
3227 int key_len, src_len;
3230 memset(md_name, 0x00, 100);
3231 memset(src_str, 0x00, 10000);
3232 memset(key_str, 0x00, 10000);
3233 memset(hash_str, 0x00, 10000);
3234 memset(output, 0x00, 100);
3236 strncpy( (
char *) md_name,
"sha1", 100 );
3238 fct_chk( md_info != NULL );
3240 key_len =
unhexify( key_str,
"707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0" );
3241 src_len =
unhexify( src_str,
"53616d706c65202334" );
3243 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3246 fct_chk( strncmp( (
char *) hash_str,
"9ea886efe268dbecce420c75", 12 * 2 ) == 0 );
3251 #ifdef POLARSSL_SHA1_C
3253 FCT_TEST_BGN(generic_hmac_sha_1_test_vector_nist_cavs_1)
3256 unsigned char src_str[10000];
3257 unsigned char key_str[10000];
3258 unsigned char hash_str[10000];
3259 unsigned char output[100];
3260 int key_len, src_len;
3263 memset(md_name, 0x00, 100);
3264 memset(src_str, 0x00, 10000);
3265 memset(key_str, 0x00, 10000);
3266 memset(hash_str, 0x00, 10000);
3267 memset(output, 0x00, 100);
3269 strncpy( (
char *) md_name,
"sha1", 100 );
3271 fct_chk( md_info != NULL );
3273 key_len =
unhexify( key_str,
"7b10f4124b15c82e" );
3274 src_len =
unhexify( src_str,
"27dcb5b1daf60cfd3e2f73d4d64ca9c684f8bf71fc682a46793b1790afa4feb100ca7aaff26f58f0e1d0ed42f1cdad1f474afa2e79d53a0c42892c4d7b327cbe46b295ed8da3b6ecab3d4851687a6f812b79df2f6b20f11f6706f5301790ca99625aad7391d84f78043d2a0a239b1477984c157bbc9276064e7a1a406b0612ca" );
3276 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3279 fct_chk( strncmp( (
char *) hash_str,
"4ead12c2fe3d6ea43acb", 10 * 2 ) == 0 );
3284 #ifdef POLARSSL_SHA1_C
3286 FCT_TEST_BGN(generic_hmac_sha_1_test_vector_nist_cavs_2)
3289 unsigned char src_str[10000];
3290 unsigned char key_str[10000];
3291 unsigned char hash_str[10000];
3292 unsigned char output[100];
3293 int key_len, src_len;
3296 memset(md_name, 0x00, 100);
3297 memset(src_str, 0x00, 10000);
3298 memset(key_str, 0x00, 10000);
3299 memset(hash_str, 0x00, 10000);
3300 memset(output, 0x00, 100);
3302 strncpy( (
char *) md_name,
"sha1", 100 );
3304 fct_chk( md_info != NULL );
3306 key_len =
unhexify( key_str,
"4fe9fb902172a21b" );
3307 src_len =
unhexify( src_str,
"4ceb3a7c13659c22fe51134f03dce4c239d181b63c6b0b59d367157fd05cab98384f92dfa482d2d5e78e72eef1b1838af4696026c54233d484ecbbe87f904df5546419f8567eafd232e6c2fcd3ee2b7682c63000524b078dbb2096f585007deae752562df1fe3b01278089e16f3be46e2d0f7cabac2d8e6cc02a2d0ca953425f" );
3309 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3312 fct_chk( strncmp( (
char *) hash_str,
"564428a67be1924b5793", 10 * 2 ) == 0 );
3317 #ifdef POLARSSL_SHA1_C
3319 FCT_TEST_BGN(generic_hmac_sha_1_test_vector_nist_cavs_3)
3322 unsigned char src_str[10000];
3323 unsigned char key_str[10000];
3324 unsigned char hash_str[10000];
3325 unsigned char output[100];
3326 int key_len, src_len;
3329 memset(md_name, 0x00, 100);
3330 memset(src_str, 0x00, 10000);
3331 memset(key_str, 0x00, 10000);
3332 memset(hash_str, 0x00, 10000);
3333 memset(output, 0x00, 100);
3335 strncpy( (
char *) md_name,
"sha1", 100 );
3337 fct_chk( md_info != NULL );
3339 key_len =
unhexify( key_str,
"d1f01455f78c4fb4" );
3340 src_len =
unhexify( src_str,
"00d40f67b57914bec456a3e3201ef1464be319a8d188c02e157af4b54f9b5a66d67f898a9bdbb19ff63a80aba6f246d013575721d52eb1b47a65def884011c49b257bcc2817fc853f106e8138ce386d7a5ac3103de0a3fa0ed6bb7af9ff66ebd1cc46fb86e4da0013d20a3c2dcd8fb828a4b70f7f104b41bf3f44682a66497ea" );
3342 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3345 fct_chk( strncmp( (
char *) hash_str,
"56a665a7cdfe610f9fc5", 10 * 2 ) == 0 );
3350 #ifdef POLARSSL_SHA1_C
3352 FCT_TEST_BGN(generic_hmac_sha_1_test_vector_nist_cavs_4)
3355 unsigned char src_str[10000];
3356 unsigned char key_str[10000];
3357 unsigned char hash_str[10000];
3358 unsigned char output[100];
3359 int key_len, src_len;
3362 memset(md_name, 0x00, 100);
3363 memset(src_str, 0x00, 10000);
3364 memset(key_str, 0x00, 10000);
3365 memset(hash_str, 0x00, 10000);
3366 memset(output, 0x00, 100);
3368 strncpy( (
char *) md_name,
"sha1", 100 );
3370 fct_chk( md_info != NULL );
3372 key_len =
unhexify( key_str,
"4e5ef77fdf033a5b" );
3373 src_len =
unhexify( src_str,
"e59326464e3201d195e29f2a3446ec1b1c9ff31154e2a4d0e40ed466f1bc855d29f76835624fa0127d29c9b1915939a046f385af7e5d47a23ba91f28bd22f811ea258dbbf3332bcd3543b8285d5df41bd064ffd64a341c22c4edb44f9c8d9e6df0c59dbf4a052a6c83da7478e179a6f3839c6870ff8ca8b9497f9ac1d725fdda" );
3375 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3378 fct_chk( strncmp( (
char *) hash_str,
"981c0a7a8423b63a8fa6", 10 * 2 ) == 0 );
3383 #ifdef POLARSSL_SHA1_C
3385 FCT_TEST_BGN(generic_hmac_sha_1_test_vector_nist_cavs_5)
3388 unsigned char src_str[10000];
3389 unsigned char key_str[10000];
3390 unsigned char hash_str[10000];
3391 unsigned char output[100];
3392 int key_len, src_len;
3395 memset(md_name, 0x00, 100);
3396 memset(src_str, 0x00, 10000);
3397 memset(key_str, 0x00, 10000);
3398 memset(hash_str, 0x00, 10000);
3399 memset(output, 0x00, 100);
3401 strncpy( (
char *) md_name,
"sha1", 100 );
3403 fct_chk( md_info != NULL );
3405 key_len =
unhexify( key_str,
"bcd9ff8aa60be2be" );
3406 src_len =
unhexify( src_str,
"51be4d0eb37bab714f92e19e9d70390655b363e8cd346a748245e731f437759cb8206412c8dab2ef1d4f36f880f41ff69d949da4594fdecb65e23cac1329b59e69e29bf875b38c31df6fa546c595f35cc2192aa750679a8a51a65e00e839d73a8d8c598a610d237fbe78955213589d80efcb73b95b8586f96d17b6f51a71c3b8" );
3408 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3411 fct_chk( strncmp( (
char *) hash_str,
"84633f9f5040c8971478", 10 * 2 ) == 0 );
3416 #ifdef POLARSSL_SHA1_C
3418 FCT_TEST_BGN(generic_hmac_sha_1_test_vector_nist_cavs_6)
3421 unsigned char src_str[10000];
3422 unsigned char key_str[10000];
3423 unsigned char hash_str[10000];
3424 unsigned char output[100];
3425 int key_len, src_len;
3428 memset(md_name, 0x00, 100);
3429 memset(src_str, 0x00, 10000);
3430 memset(key_str, 0x00, 10000);
3431 memset(hash_str, 0x00, 10000);
3432 memset(output, 0x00, 100);
3434 strncpy( (
char *) md_name,
"sha1", 100 );
3436 fct_chk( md_info != NULL );
3438 key_len =
unhexify( key_str,
"4a661bce6ed86d21" );
3439 src_len =
unhexify( src_str,
"5ff6c744f1aab1bc29697d71f67541b8b3cec3c7079183b10a83fb98a9ee251d4bac3e1cb581ca972aaed8efd7c2875a6fb4c991132f67c9742d45e53bc7e8eaa94b35b37a907be61086b426cd11088ac118934e85d968c9667fd69fc6f6ea38c0fe34710b7ece91211b9b7ea00acd31f022aa6726368f9928a1352f122233f1" );
3441 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3444 fct_chk( strncmp( (
char *) hash_str,
"739df59353ac6694e55e", 10 * 2 ) == 0 );
3449 #ifdef POLARSSL_SHA1_C
3451 FCT_TEST_BGN(generic_hmac_sha_1_test_vector_nist_cavs_7)
3454 unsigned char src_str[10000];
3455 unsigned char key_str[10000];
3456 unsigned char hash_str[10000];
3457 unsigned char output[100];
3458 int key_len, src_len;
3461 memset(md_name, 0x00, 100);
3462 memset(src_str, 0x00, 10000);
3463 memset(key_str, 0x00, 10000);
3464 memset(hash_str, 0x00, 10000);
3465 memset(output, 0x00, 100);
3467 strncpy( (
char *) md_name,
"sha1", 100 );
3469 fct_chk( md_info != NULL );
3471 key_len =
unhexify( key_str,
"1287e1565a57b547" );
3472 src_len =
unhexify( src_str,
"390ffdccc6171c11568d85b8f913e019bf4cd982ca9cd21ea730d41bdf3fcc0bc88ff48ba13a8f23deb2d96ec1033e7b2a58ca72b0c1e17bf03330db25d1e360fa6918009c4294bd1215b5ccd159a8f58bc3dc3d490eb7c3b9f887e8c98dbbb274a75373dcb695a59abd0219529d88518a96f92abc0bbcbda985c388f1fbbcc9" );
3474 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3477 fct_chk( strncmp( (
char *) hash_str,
"d78ddf08077c7d9e2ba6", 10 * 2 ) == 0 );
3482 #ifdef POLARSSL_SHA2_C
3484 FCT_TEST_BGN(generic_hmac_sha_224_test_vector_nist_cavs_1)
3487 unsigned char src_str[10000];
3488 unsigned char key_str[10000];
3489 unsigned char hash_str[10000];
3490 unsigned char output[100];
3491 int key_len, src_len;
3494 memset(md_name, 0x00, 100);
3495 memset(src_str, 0x00, 10000);
3496 memset(key_str, 0x00, 10000);
3497 memset(hash_str, 0x00, 10000);
3498 memset(output, 0x00, 100);
3500 strncpy( (
char *) md_name,
"sha224", 100 );
3502 fct_chk( md_info != NULL );
3504 key_len =
unhexify( key_str,
"e055eb756697ee573fd3214811a9f7fa" );
3505 src_len =
unhexify( src_str,
"3875847012ee42fe54a0027bdf38cca7021b83a2ed0503af69ef6c37c637bc1114fba40096c5947d736e19b7af3c68d95a4e3b8b073adbbb80f47e9db8f2d4f0018ddd847fabfdf9dd9b52c93e40458977725f6b7ba15f0816bb895cdf50401268f5d702b7e6a5f9faef57b8768c8a3fc14f9a4b3182b41d940e337d219b29ff" );
3507 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3510 fct_chk( strncmp( (
char *) hash_str,
"40a453133361cc48da11baf616ee", 14 * 2 ) == 0 );
3515 #ifdef POLARSSL_SHA2_C
3517 FCT_TEST_BGN(generic_hmac_sha_224_test_vector_nist_cavs_2)
3520 unsigned char src_str[10000];
3521 unsigned char key_str[10000];
3522 unsigned char hash_str[10000];
3523 unsigned char output[100];
3524 int key_len, src_len;
3527 memset(md_name, 0x00, 100);
3528 memset(src_str, 0x00, 10000);
3529 memset(key_str, 0x00, 10000);
3530 memset(hash_str, 0x00, 10000);
3531 memset(output, 0x00, 100);
3533 strncpy( (
char *) md_name,
"sha224", 100 );
3535 fct_chk( md_info != NULL );
3537 key_len =
unhexify( key_str,
"88e5258b55b1623385eb9632fa7c57d6" );
3538 src_len =
unhexify( src_str,
"ada76bb604be14326551701cf30e48a65eee80b44f0b9d4a07b1844543b7844a621097fdc99de57387458ae9354899b620d0617eabcaefa9eef3d413a33628054335ce656c26fa2986e0f111a6351096b283101ec7868871d770b370973c7405983f9756b3005a3eab492cfd0e7eb42e5c2e15fa6be8718c0a50acc4e5717230" );
3540 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3543 fct_chk( strncmp( (
char *) hash_str,
"81c783af538015cef3c60095df53", 14 * 2 ) == 0 );
3548 #ifdef POLARSSL_SHA2_C
3550 FCT_TEST_BGN(generic_hmac_sha_224_test_vector_nist_cavs_3)
3553 unsigned char src_str[10000];
3554 unsigned char key_str[10000];
3555 unsigned char hash_str[10000];
3556 unsigned char output[100];
3557 int key_len, src_len;
3560 memset(md_name, 0x00, 100);
3561 memset(src_str, 0x00, 10000);
3562 memset(key_str, 0x00, 10000);
3563 memset(hash_str, 0x00, 10000);
3564 memset(output, 0x00, 100);
3566 strncpy( (
char *) md_name,
"sha224", 100 );
3568 fct_chk( md_info != NULL );
3570 key_len =
unhexify( key_str,
"85d402d822114d31abf75526e2538705" );
3571 src_len =
unhexify( src_str,
"8020d8d98cc2e2298b32879c51c751e1dd5558fe2eabb8f158604297d6d072ce2261a1d6830b7cfe2617b57c7126f99c9476211d6161acd75d266da217ec8174b80484c9dc6f0448a0a036a3fc82e8bf54bdb71549368258d5d41f57978a4c266b92e8783ef66350215573d99be4089144b383ad8f3222bae8f3bf80ffb1bb2b" );
3573 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3576 fct_chk( strncmp( (
char *) hash_str,
"2aa0340ac9deafe3be38129daca0", 14 * 2 ) == 0 );
3581 #ifdef POLARSSL_SHA2_C
3583 FCT_TEST_BGN(generic_hmac_sha_224_test_vector_nist_cavs_4)
3586 unsigned char src_str[10000];
3587 unsigned char key_str[10000];
3588 unsigned char hash_str[10000];
3589 unsigned char output[100];
3590 int key_len, src_len;
3593 memset(md_name, 0x00, 100);
3594 memset(src_str, 0x00, 10000);
3595 memset(key_str, 0x00, 10000);
3596 memset(hash_str, 0x00, 10000);
3597 memset(output, 0x00, 100);
3599 strncpy( (
char *) md_name,
"sha224", 100 );
3601 fct_chk( md_info != NULL );
3603 key_len =
unhexify( key_str,
"545c6eecc5ee46fa17c59f91a94f81ae" );
3604 src_len =
unhexify( src_str,
"8fb7f3565593170152ddb2021874784e951977cfdd22f8b72a72a61320a8f2a35697b5e913f717805559b1af1861ee3ed42fb788481e4fd276b17bdbefcae7b4501dc5d20de5b7626dd5efdcd65294db4bdf682c33d9a9255c6435383fa5f1c886326a3acbc6bd50a33ab5b2dbb034ce0112d4e226bbcd57e3731a519aa1d784" );
3606 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3609 fct_chk( strncmp( (
char *) hash_str,
"3eb566eac54c4a3a9ef092469f24", 14 * 2 ) == 0 );
3614 #ifdef POLARSSL_SHA2_C
3616 FCT_TEST_BGN(generic_hmac_sha_224_test_vector_nist_cavs_5)
3619 unsigned char src_str[10000];
3620 unsigned char key_str[10000];
3621 unsigned char hash_str[10000];
3622 unsigned char output[100];
3623 int key_len, src_len;
3626 memset(md_name, 0x00, 100);
3627 memset(src_str, 0x00, 10000);
3628 memset(key_str, 0x00, 10000);
3629 memset(hash_str, 0x00, 10000);
3630 memset(output, 0x00, 100);
3632 strncpy( (
char *) md_name,
"sha224", 100 );
3634 fct_chk( md_info != NULL );
3636 key_len =
unhexify( key_str,
"4466ab4dc438841a9750c7f173dff02e" );
3637 src_len =
unhexify( src_str,
"2534c11c78c99cffaec8f722f04adc7045c7324d58ce98e37cfa94b6ed21ed7f58ce55379ef24b72d6d640ee9154f96c614734be9c408e225d7ba4cecc1179cc9f6e1808e1067aa8f244a99bd0c3267594c1887a40d167f8b7cf78db0d19f97b01fc50b8c86def490dfa7a5135002c33e71d77a8cce8ea0f93e0580439a33733" );
3639 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3642 fct_chk( strncmp( (
char *) hash_str,
"59f44a9bbed4875b892d22d6b5ab", 14 * 2 ) == 0 );
3647 #ifdef POLARSSL_SHA2_C
3649 FCT_TEST_BGN(generic_hmac_sha_224_test_vector_nist_cavs_6)
3652 unsigned char src_str[10000];
3653 unsigned char key_str[10000];
3654 unsigned char hash_str[10000];
3655 unsigned char output[100];
3656 int key_len, src_len;
3659 memset(md_name, 0x00, 100);
3660 memset(src_str, 0x00, 10000);
3661 memset(key_str, 0x00, 10000);
3662 memset(hash_str, 0x00, 10000);
3663 memset(output, 0x00, 100);
3665 strncpy( (
char *) md_name,
"sha224", 100 );
3667 fct_chk( md_info != NULL );
3669 key_len =
unhexify( key_str,
"0e3dd9bb5e4cf0f09a4c11600af56d8d" );
3670 src_len =
unhexify( src_str,
"f4589fa76c328ea25cf8bae582026ba40a59d45a546ff31cf80eb826088f69bb954c452c74586836416dee90a5255bc5d56d3b405b3705a5197045688b32fa984c3a3dfbdc9c2460a0b5e6312a624048bb6f170306535e9b371a3ab134a2642a230ad03d2c688cca80baeaee9a20e1d4c548b1cede29c6a45bf4df2c8c476f1a" );
3672 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3675 fct_chk( strncmp( (
char *) hash_str,
"12175b93e3da4c58217145e4dc0a1cf142fab9319bb501e037b350ba", 28 * 2 ) == 0 );
3680 #ifdef POLARSSL_SHA2_C
3682 FCT_TEST_BGN(generic_hmac_sha_224_test_vector_nist_cavs_7)
3685 unsigned char src_str[10000];
3686 unsigned char key_str[10000];
3687 unsigned char hash_str[10000];
3688 unsigned char output[100];
3689 int key_len, src_len;
3692 memset(md_name, 0x00, 100);
3693 memset(src_str, 0x00, 10000);
3694 memset(key_str, 0x00, 10000);
3695 memset(hash_str, 0x00, 10000);
3696 memset(output, 0x00, 100);
3698 strncpy( (
char *) md_name,
"sha224", 100 );
3700 fct_chk( md_info != NULL );
3702 key_len =
unhexify( key_str,
"cda5187b0c5dcb0f8e5a8beed2306584" );
3703 src_len =
unhexify( src_str,
"9011ae29b44c49b347487ce972965f16ade3c15be0856ce9c853a9739dba07e4f20d594ddc1dfe21560a65a4e458cfa17745575b915a30c7a9412ff8d1d689db9680dd2428c27588bb0dc92d2cd9445fe8f44b840a197c52c3c4333fff45533945134398df6436513cfab06c924046b8c795a5bd92e8d5f2de85bf306f2eed67" );
3705 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3708 fct_chk( strncmp( (
char *) hash_str,
"4aaba92b40e2a600feab176eb9b292d814864195c03342aad6f67f08", 28 * 2 ) == 0 );
3713 #ifdef POLARSSL_SHA2_C
3715 FCT_TEST_BGN(generic_hmac_sha_256_test_vector_nist_cavs_1)
3718 unsigned char src_str[10000];
3719 unsigned char key_str[10000];
3720 unsigned char hash_str[10000];
3721 unsigned char output[100];
3722 int key_len, src_len;
3725 memset(md_name, 0x00, 100);
3726 memset(src_str, 0x00, 10000);
3727 memset(key_str, 0x00, 10000);
3728 memset(hash_str, 0x00, 10000);
3729 memset(output, 0x00, 100);
3731 strncpy( (
char *) md_name,
"sha256", 100 );
3733 fct_chk( md_info != NULL );
3735 key_len =
unhexify( key_str,
"cdffd34e6b16fdc0" );
3736 src_len =
unhexify( src_str,
"d83e78b99ab61709608972b36e76a575603db742269cc5dd4e7d5ca7816e26b65151c92632550cb4c5253c885d5fce53bc47459a1dbd5652786c4aac0145a532f12c05138af04cbb558101a7af5df478834c2146594dd73690d01a4fe72545894335f427ac70204798068cb86c5a600b40b414ede23590b41e1192373df84fe3" );
3738 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3741 fct_chk( strncmp( (
char *) hash_str,
"c6f0dde266cb4a26d41e8259d33499cc", 16 * 2 ) == 0 );
3746 #ifdef POLARSSL_SHA2_C
3748 FCT_TEST_BGN(generic_hmac_sha_256_test_vector_nist_cavs_2)
3751 unsigned char src_str[10000];
3752 unsigned char key_str[10000];
3753 unsigned char hash_str[10000];
3754 unsigned char output[100];
3755 int key_len, src_len;
3758 memset(md_name, 0x00, 100);
3759 memset(src_str, 0x00, 10000);
3760 memset(key_str, 0x00, 10000);
3761 memset(hash_str, 0x00, 10000);
3762 memset(output, 0x00, 100);
3764 strncpy( (
char *) md_name,
"sha256", 100 );
3766 fct_chk( md_info != NULL );
3768 key_len =
unhexify( key_str,
"6d97bb5892245be2" );
3769 src_len =
unhexify( src_str,
"13c2b391d59c0252ca5d2302beaaf88c4bcd779bb505ad9a122003dfae4cc123ad2bd036f225c4f040021a6b9fb8bd6f0281cf2e2631a732bdc71693cc42ef6d52b6c6912a9ef77b3274eb85ad7f965ae6ed44ac1721962a884ec7acfb4534b1488b1c0c45afa4dae8da1eb7b0a88a3240365d7e4e7d826abbde9f9203fd99d7" );
3771 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3774 fct_chk( strncmp( (
char *) hash_str,
"31588e241b015319a5ab8c4527296498", 16 * 2 ) == 0 );
3779 #ifdef POLARSSL_SHA2_C
3781 FCT_TEST_BGN(generic_hmac_sha_256_test_vector_nist_cavs_3)
3784 unsigned char src_str[10000];
3785 unsigned char key_str[10000];
3786 unsigned char hash_str[10000];
3787 unsigned char output[100];
3788 int key_len, src_len;
3791 memset(md_name, 0x00, 100);
3792 memset(src_str, 0x00, 10000);
3793 memset(key_str, 0x00, 10000);
3794 memset(hash_str, 0x00, 10000);
3795 memset(output, 0x00, 100);
3797 strncpy( (
char *) md_name,
"sha256", 100 );
3799 fct_chk( md_info != NULL );
3801 key_len =
unhexify( key_str,
"3c7fc8a70b49007a" );
3802 src_len =
unhexify( src_str,
"60024e428a39c8b8bb2e9591bad9dc2115dfbfd716b6eb7af30a6eb34560caccbbfa47b710fa8d523aca71e9e5ba10fc1feb1a43556d71f07ea4f33496f093044e8caf1d02b79e46eb1288d5964a7a7494f6b92574c35784eece054c6151281d80822f7d47b8231c35d07f5cb5cf4310ddc844845a01c6bfab514c048eccaf9f" );
3804 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3807 fct_chk( strncmp( (
char *) hash_str,
"1c98c94a32bec9f253c21070f82f8438", 16 * 2 ) == 0 );
3812 #ifdef POLARSSL_SHA2_C
3814 FCT_TEST_BGN(generic_hmac_sha_256_test_vector_nist_cavs_4)
3817 unsigned char src_str[10000];
3818 unsigned char key_str[10000];
3819 unsigned char hash_str[10000];
3820 unsigned char output[100];
3821 int key_len, src_len;
3824 memset(md_name, 0x00, 100);
3825 memset(src_str, 0x00, 10000);
3826 memset(key_str, 0x00, 10000);
3827 memset(hash_str, 0x00, 10000);
3828 memset(output, 0x00, 100);
3830 strncpy( (
char *) md_name,
"sha256", 100 );
3832 fct_chk( md_info != NULL );
3834 key_len =
unhexify( key_str,
"369f33f85b927a07" );
3835 src_len =
unhexify( src_str,
"ae8e2a94ca386d448cbacdb0e9040ae3cb297c296363052cc157455da29a0c95897315fc11e3f12b81e2418da1ec280bccbc00e847584ce9d14deeba7b3c9b8dba958b04bba37551f6c9ba9c060be1a4b8cf43aa62e5078b76c6512c5619b71a6a7cf5727180e1ff14f5a1a3c1691bf8b6ebad365c151e58d749d57adb3a4986" );
3837 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3840 fct_chk( strncmp( (
char *) hash_str,
"60b90383286533d309de46593e6ce39fc51fb00a8d88278c", 24 * 2 ) == 0 );
3845 #ifdef POLARSSL_SHA2_C
3847 FCT_TEST_BGN(generic_hmac_sha_256_test_vector_nist_cavs_5)
3850 unsigned char src_str[10000];
3851 unsigned char key_str[10000];
3852 unsigned char hash_str[10000];
3853 unsigned char output[100];
3854 int key_len, src_len;
3857 memset(md_name, 0x00, 100);
3858 memset(src_str, 0x00, 10000);
3859 memset(key_str, 0x00, 10000);
3860 memset(hash_str, 0x00, 10000);
3861 memset(output, 0x00, 100);
3863 strncpy( (
char *) md_name,
"sha256", 100 );
3865 fct_chk( md_info != NULL );
3867 key_len =
unhexify( key_str,
"e5179687582b4dc4" );
3868 src_len =
unhexify( src_str,
"ce103bdacdf32f614f6727bcb31ca1c2824a850d00f5585b016fb234fe1ef2cd687f302d3c6b738ed89a24060d65c36675d0d96307c72ef3e8a83bfa8402e226de9d5d1724ba75c4879bf41a4a465ce61887d9f49a34757849b48bae81c27ebed76faae2ad669bca04747d409148d40812776e0ae2c395b3cb9c89981ce72d5c" );
3870 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3873 fct_chk( strncmp( (
char *) hash_str,
"509581f6816df4b8cc9f2cf42b7cc6e6a5a1e375a16f2412", 24 * 2 ) == 0 );
3878 #ifdef POLARSSL_SHA2_C
3880 FCT_TEST_BGN(generic_hmac_sha_256_test_vector_nist_cavs_6)
3883 unsigned char src_str[10000];
3884 unsigned char key_str[10000];
3885 unsigned char hash_str[10000];
3886 unsigned char output[100];
3887 int key_len, src_len;
3890 memset(md_name, 0x00, 100);
3891 memset(src_str, 0x00, 10000);
3892 memset(key_str, 0x00, 10000);
3893 memset(hash_str, 0x00, 10000);
3894 memset(output, 0x00, 100);
3896 strncpy( (
char *) md_name,
"sha256", 100 );
3898 fct_chk( md_info != NULL );
3900 key_len =
unhexify( key_str,
"63cec6246aeb1b61" );
3901 src_len =
unhexify( src_str,
"c178db908a405fa88aa255b8cad22b4057016585f139ee930388b083d86062fa0b3ea1f23f8a43bd11bee8464bcbd19b5ab9f6a8038d5245516f8274d20c8ee3033a07b908da528fa00343bb595deed500cab9745c4cb6391c23300f0d3584b090b3326c4cfa342620b78f9f5b4f27f7307ed770643ec1764aeae3dcf1a3ec69" );
3903 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3906 fct_chk( strncmp( (
char *) hash_str,
"64f3dd861b7c7d29fce9ae0ce9ed954b5d7141806ee9eec7", 24 * 2 ) == 0 );
3911 #ifdef POLARSSL_SHA4_C
3913 FCT_TEST_BGN(generic_hmac_sha_384_test_vector_nist_cavs_1)
3916 unsigned char src_str[10000];
3917 unsigned char key_str[10000];
3918 unsigned char hash_str[10000];
3919 unsigned char output[100];
3920 int key_len, src_len;
3923 memset(md_name, 0x00, 100);
3924 memset(src_str, 0x00, 10000);
3925 memset(key_str, 0x00, 10000);
3926 memset(hash_str, 0x00, 10000);
3927 memset(output, 0x00, 100);
3929 strncpy( (
char *) md_name,
"sha384", 100 );
3931 fct_chk( md_info != NULL );
3933 key_len =
unhexify( key_str,
"91a7401817386948ca952f9a20ee55dc" );
3934 src_len =
unhexify( src_str,
"2fea5b91035d6d501f3a834fa178bff4e64b99a8450432dafd32e4466b0e1e7781166f8a73f7e036b3b0870920f559f47bd1400a1a906e85e0dcf00a6c26862e9148b23806680f285f1fe4f93cdaf924c181a965465739c14f2268c8be8b471847c74b222577a1310bcdc1a85ef1468aa1a3fd4031213c97324b7509c9050a3d" );
3936 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3939 fct_chk( strncmp( (
char *) hash_str,
"6d7be9490058cf413cc09fd043c224c2ec4fa7859b13783000a9a593c9f75838", 32 * 2 ) == 0 );
3944 #ifdef POLARSSL_SHA4_C
3946 FCT_TEST_BGN(generic_hmac_sha_384_test_vector_nist_cavs_2)
3949 unsigned char src_str[10000];
3950 unsigned char key_str[10000];
3951 unsigned char hash_str[10000];
3952 unsigned char output[100];
3953 int key_len, src_len;
3956 memset(md_name, 0x00, 100);
3957 memset(src_str, 0x00, 10000);
3958 memset(key_str, 0x00, 10000);
3959 memset(hash_str, 0x00, 10000);
3960 memset(output, 0x00, 100);
3962 strncpy( (
char *) md_name,
"sha384", 100 );
3964 fct_chk( md_info != NULL );
3966 key_len =
unhexify( key_str,
"d6cac19657061aa90a6da11cd2e9ea47" );
3967 src_len =
unhexify( src_str,
"9f482e4655173135dfaa22a11bbbe6af263db48716406c5aec162ba3c4b41cad4f5a91558377521191c7343118beee65982929802913d67b6de5c4bdc3d27299bd722219d5ad2efa5bdb9ff7b229fc4bbc3f60719320cf2e7a51cad1133d21bad2d80919b1836ef825308b7c51c6b7677ac782e2bc30007afba065681cbdd215" );
3969 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
3972 fct_chk( strncmp( (
char *) hash_str,
"f3d5f3c008175321aa7b2ea379eaa4f8b9dcc60f895ec8940b8162f80a7dfe9f", 32 * 2 ) == 0 );
3977 #ifdef POLARSSL_SHA4_C
3979 FCT_TEST_BGN(generic_hmac_sha_384_test_vector_nist_cavs_3)
3982 unsigned char src_str[10000];
3983 unsigned char key_str[10000];
3984 unsigned char hash_str[10000];
3985 unsigned char output[100];
3986 int key_len, src_len;
3989 memset(md_name, 0x00, 100);
3990 memset(src_str, 0x00, 10000);
3991 memset(key_str, 0x00, 10000);
3992 memset(hash_str, 0x00, 10000);
3993 memset(output, 0x00, 100);
3995 strncpy( (
char *) md_name,
"sha384", 100 );
3997 fct_chk( md_info != NULL );
3999 key_len =
unhexify( key_str,
"e06366ad149b8442cd4c1abdddd0afde" );
4000 src_len =
unhexify( src_str,
"2d140a194c02a5598f69174834679b8371234a0d505491f1bd03e128dd91a8bca2fb812e9d5da71613b5b00952ea78bf450d5b7547dea79135925085c7d3e6f52009c51ca3d88c6c09e9d074b0ee110736e0ec9b478b93efb34d7bf1c41b54decec43eab077a3aa4998ede53f67b4ea36c266745f9643d5360bdc8337c70dabf" );
4002 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
4005 fct_chk( strncmp( (
char *) hash_str,
"c19c67eda6fe29f3667bee1c897c333ce7683094ae77e84b4c16378d290895a1", 32 * 2 ) == 0 );
4010 #ifdef POLARSSL_SHA4_C
4012 FCT_TEST_BGN(generic_hmac_sha_384_test_vector_nist_cavs_4)
4015 unsigned char src_str[10000];
4016 unsigned char key_str[10000];
4017 unsigned char hash_str[10000];
4018 unsigned char output[100];
4019 int key_len, src_len;
4022 memset(md_name, 0x00, 100);
4023 memset(src_str, 0x00, 10000);
4024 memset(key_str, 0x00, 10000);
4025 memset(hash_str, 0x00, 10000);
4026 memset(output, 0x00, 100);
4028 strncpy( (
char *) md_name,
"sha384", 100 );
4030 fct_chk( md_info != NULL );
4032 key_len =
unhexify( key_str,
"01ac59f42f8bb91d1bd10fe6990d7a87" );
4033 src_len =
unhexify( src_str,
"3caf18c476edd5615f343ac7b7d3a9da9efade755672d5ba4b8ae8a7505539ea2c124ff755ec0457fbe49e43480b3c71e7f4742ec3693aad115d039f90222b030fdc9440313691716d5302005808c07627483b916fdf61983063c2eb1268f2deeef42fc790334456bc6bad256e31fc9066de7cc7e43d1321b1866db45e905622" );
4035 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
4038 fct_chk( strncmp( (
char *) hash_str,
"1985fa2163a5943fc5d92f1fe8831215e7e91f0bff5332bc713a072bdb3a8f9e5c5157463a3bfeb36231416e65973e64", 48 * 2 ) == 0 );
4043 #ifdef POLARSSL_SHA4_C
4045 FCT_TEST_BGN(generic_hmac_sha_384_test_vector_nist_cavs_5)
4048 unsigned char src_str[10000];
4049 unsigned char key_str[10000];
4050 unsigned char hash_str[10000];
4051 unsigned char output[100];
4052 int key_len, src_len;
4055 memset(md_name, 0x00, 100);
4056 memset(src_str, 0x00, 10000);
4057 memset(key_str, 0x00, 10000);
4058 memset(hash_str, 0x00, 10000);
4059 memset(output, 0x00, 100);
4061 strncpy( (
char *) md_name,
"sha384", 100 );
4063 fct_chk( md_info != NULL );
4065 key_len =
unhexify( key_str,
"fd74b9d9e102a3a80df1baf0cb35bace" );
4066 src_len =
unhexify( src_str,
"1a068917584813d1689ccbd0370c2114d537cdc8cc52bf6db16d5535f8f7d1ad0c850a9fa0cf62373ffbf7642b1f1e8164010d350721d798d9f99e9724830399c2fce26377e83d38845675457865c03d4a07d741a505ef028343eb29fd46d0f761f3792886998c1e5c32ac3bc7e6f08faed194b34f06eff4d5d4a5b42c481e0e" );
4068 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
4071 fct_chk( strncmp( (
char *) hash_str,
"a981eaf5de3d78b20ebd4414a4edd0657e3667cd808a0dbc430cf7252f73a5b24efa136039207bd59806897457d74e0c", 48 * 2 ) == 0 );
4076 #ifdef POLARSSL_SHA4_C
4078 FCT_TEST_BGN(generic_hmac_sha_384_test_vector_nist_cavs_5)
4081 unsigned char src_str[10000];
4082 unsigned char key_str[10000];
4083 unsigned char hash_str[10000];
4084 unsigned char output[100];
4085 int key_len, src_len;
4088 memset(md_name, 0x00, 100);
4089 memset(src_str, 0x00, 10000);
4090 memset(key_str, 0x00, 10000);
4091 memset(hash_str, 0x00, 10000);
4092 memset(output, 0x00, 100);
4094 strncpy( (
char *) md_name,
"sha384", 100 );
4096 fct_chk( md_info != NULL );
4098 key_len =
unhexify( key_str,
"9fe794f0e26b669fa5f6883149377c6c" );
4099 src_len =
unhexify( src_str,
"6010c9745e8f1d44cfdc99e7e0fd79bc4271944c2d1d84dba589073dfc4ca5eb98c59356f60cd87bef28aeb83a832bde339b2087daf942aa1f67876c5d5ed33924bed4143bc12a2be532ccaf64daa7e2bc3c8872b9823b0533b6f5159135effe8c61545536975d7c3a61ba7365ec35f165bc92b4d19eb9156ade17dfa1bb4161" );
4101 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
4104 fct_chk( strncmp( (
char *) hash_str,
"915ae61f8754698c2b6ef9629e93441f8541bd4258a5e05372d19136cfaefc0473b48d96119291b38eb1a3cb1982a986", 48 * 2 ) == 0 );
4109 #ifdef POLARSSL_SHA4_C
4111 FCT_TEST_BGN(generic_hmac_sha_512_test_vector_nist_cavs_1)
4114 unsigned char src_str[10000];
4115 unsigned char key_str[10000];
4116 unsigned char hash_str[10000];
4117 unsigned char output[100];
4118 int key_len, src_len;
4121 memset(md_name, 0x00, 100);
4122 memset(src_str, 0x00, 10000);
4123 memset(key_str, 0x00, 10000);
4124 memset(hash_str, 0x00, 10000);
4125 memset(output, 0x00, 100);
4127 strncpy( (
char *) md_name,
"sha512", 100 );
4129 fct_chk( md_info != NULL );
4131 key_len =
unhexify( key_str,
"c95a17c09940a691ed2d621571b0eb844ede55a9" );
4132 src_len =
unhexify( src_str,
"99cd28262e81f34878cdcebf4128e05e2098a7009278a66f4c785784d0e5678f3f2b22f86e982d273b6273a222ec61750b4556d766f1550a7aedfe83faedbc4bdae83fa560d62df17eb914d05fdaa48940551bac81d700f5fca7147295e386e8120d66742ec65c6ee8d89a92217a0f6266d0ddc60bb20ef679ae8299c8502c2f" );
4134 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
4137 fct_chk( strncmp( (
char *) hash_str,
"6bc1379d156559ddee2ed420ea5d5c5ff3e454a1059b7ba72c350e77b6e9333c", 32 * 2 ) == 0 );
4142 #ifdef POLARSSL_SHA4_C
4144 FCT_TEST_BGN(generic_hmac_sha_512_test_vector_nist_cavs_2)
4147 unsigned char src_str[10000];
4148 unsigned char key_str[10000];
4149 unsigned char hash_str[10000];
4150 unsigned char output[100];
4151 int key_len, src_len;
4154 memset(md_name, 0x00, 100);
4155 memset(src_str, 0x00, 10000);
4156 memset(key_str, 0x00, 10000);
4157 memset(hash_str, 0x00, 10000);
4158 memset(output, 0x00, 100);
4160 strncpy( (
char *) md_name,
"sha512", 100 );
4162 fct_chk( md_info != NULL );
4164 key_len =
unhexify( key_str,
"3b10b8fa718840d1dea8e9fc317476bcf55875fd" );
4165 src_len =
unhexify( src_str,
"f04f5b7073d7d0274e8354433b390306c5607632f5f589c12edb62d55673aff2366d2e6b24de731adf92e654baa30b1cfd4a069788f65ec1b99b015d904d8832110dbd74eae35a81562d14ce4136d820ad0a55ff5489ba678fbbc1c27663ec1349d70e740f0e0ec27cfbe8971819f4789e486b50a2d7271d77e2aaea50de62fd" );
4167 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
4170 fct_chk( strncmp( (
char *) hash_str,
"fc3c38c7a17e3ce06db033f1c172866f01a00045db55f2e234f71c82264f2ba2", 32 * 2 ) == 0 );
4175 #ifdef POLARSSL_SHA4_C
4177 FCT_TEST_BGN(generic_hmac_sha_512_test_vector_nist_cavs_3)
4180 unsigned char src_str[10000];
4181 unsigned char key_str[10000];
4182 unsigned char hash_str[10000];
4183 unsigned char output[100];
4184 int key_len, src_len;
4187 memset(md_name, 0x00, 100);
4188 memset(src_str, 0x00, 10000);
4189 memset(key_str, 0x00, 10000);
4190 memset(hash_str, 0x00, 10000);
4191 memset(output, 0x00, 100);
4193 strncpy( (
char *) md_name,
"sha512", 100 );
4195 fct_chk( md_info != NULL );
4197 key_len =
unhexify( key_str,
"4803d311394600dc1e0d8fc8cedeb8bde3fe7c42" );
4198 src_len =
unhexify( src_str,
"a10c125dd702a97153ad923ba5e9889cfac1ba169de370debe51f233735aa6effcc9785c4b5c7e48c477dc5c411ae6a959118584e26adc94b42c2b29b046f3cf01c65b24a24bd2e620bdf650a23bb4a72655b1100d7ce9a4dab697c6379754b4396c825de4b9eb73f2e6a6c0d0353bbdeaf706612800e137b858fdb30f3311c6" );
4200 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
4203 fct_chk( strncmp( (
char *) hash_str,
"7cd8236c55102e6385f52279506df6fcc388ab75092da21395ce14a82b202ffa", 32 * 2 ) == 0 );
4208 #ifdef POLARSSL_SHA4_C
4210 FCT_TEST_BGN(generic_hmac_sha_512_test_vector_nist_cavs_4)
4213 unsigned char src_str[10000];
4214 unsigned char key_str[10000];
4215 unsigned char hash_str[10000];
4216 unsigned char output[100];
4217 int key_len, src_len;
4220 memset(md_name, 0x00, 100);
4221 memset(src_str, 0x00, 10000);
4222 memset(key_str, 0x00, 10000);
4223 memset(hash_str, 0x00, 10000);
4224 memset(output, 0x00, 100);
4226 strncpy( (
char *) md_name,
"sha512", 100 );
4228 fct_chk( md_info != NULL );
4230 key_len =
unhexify( key_str,
"aeb2f3b977fa6c8e71e07c5a5c74ff58166de092" );
4231 src_len =
unhexify( src_str,
"22457355dc76095abd46846b41cfe49a06ce42ac8857b4702fc771508dfb3626e0bfe851df897a07b36811ec433766e4b4166c26301b3493e7440d4554b0ef6ac20f1a530e58fac8aeba4e9ff2d4898d8a28783b49cd269c2965fd7f8e4f2d60cf1e5284f2495145b72382aad90e153a90ecae125ad75336fb128825c23fb8b0" );
4233 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
4236 fct_chk( strncmp( (
char *) hash_str,
"fa39bd8fcc3bfa218f9dea5d3b2ce10a7619e31678a56d8a9d927b1fe703b125af445debe9a89a07db6194d27b44d85a", 48 * 2 ) == 0 );
4241 #ifdef POLARSSL_SHA4_C
4243 FCT_TEST_BGN(generic_hmac_sha_512_test_vector_nist_cavs_5)
4246 unsigned char src_str[10000];
4247 unsigned char key_str[10000];
4248 unsigned char hash_str[10000];
4249 unsigned char output[100];
4250 int key_len, src_len;
4253 memset(md_name, 0x00, 100);
4254 memset(src_str, 0x00, 10000);
4255 memset(key_str, 0x00, 10000);
4256 memset(hash_str, 0x00, 10000);
4257 memset(output, 0x00, 100);
4259 strncpy( (
char *) md_name,
"sha512", 100 );
4261 fct_chk( md_info != NULL );
4263 key_len =
unhexify( key_str,
"4285d3d7744da52775bb44ca436a3154f7980309" );
4264 src_len =
unhexify( src_str,
"208f0b6f2de2e5aa5df11927ddc6df485edc1193181c484d0f0a434a95418803101d4de9fdb798f93516a6916fa38a8207de1666fe50fe3441c03b112eaaae6954ed063f7ac4e3c1e3f73b20d153fe9e4857f5e91430f0a70ee820529adac2467469fd18adf10e2af0fea27c0abc83c5a9af77c364a466cffce8bab4e2b70bc1" );
4266 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
4269 fct_chk( strncmp( (
char *) hash_str,
"fe7603f205b2774fe0f14ecfa3e338e90608a806d11ca459dff5ce36b1b264ecd3af5f0492a7521d8da3102ba20927a5", 48 * 2 ) == 0 );
4274 #ifdef POLARSSL_SHA4_C
4276 FCT_TEST_BGN(generic_hmac_sha_512_test_vector_nist_cavs_6)
4279 unsigned char src_str[10000];
4280 unsigned char key_str[10000];
4281 unsigned char hash_str[10000];
4282 unsigned char output[100];
4283 int key_len, src_len;
4286 memset(md_name, 0x00, 100);
4287 memset(src_str, 0x00, 10000);
4288 memset(key_str, 0x00, 10000);
4289 memset(hash_str, 0x00, 10000);
4290 memset(output, 0x00, 100);
4292 strncpy( (
char *) md_name,
"sha512", 100 );
4294 fct_chk( md_info != NULL );
4296 key_len =
unhexify( key_str,
"8ab783d5acf32efa0d9c0a21abce955e96630d89" );
4297 src_len =
unhexify( src_str,
"17371e013dce839963d54418e97be4bd9fa3cb2a368a5220f5aa1b8aaddfa3bdefc91afe7c717244fd2fb640f5cb9d9bf3e25f7f0c8bc758883b89dcdce6d749d9672fed222277ece3e84b3ec01b96f70c125fcb3cbee6d19b8ef0873f915f173bdb05d81629ba187cc8ac1934b2f75952fb7616ae6bd812946df694bd2763af" );
4299 fct_chk (
md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
4302 fct_chk( strncmp( (
char *) hash_str,
"9ac7ca8d1aefc166b046e4cf7602ebe181a0e5055474bff5b342106731da0d7e48e4d87bc0a6f05871574289a1b099f8", 48 * 2 ) == 0 );
4307 #ifdef POLARSSL_SHA1_C
4309 FCT_TEST_BGN(generic_multi_step_hmac_sha_1_test_vector_fips_198a_1)
4312 unsigned char src_str[10000];
4313 unsigned char key_str[10000];
4314 unsigned char hash_str[10000];
4315 unsigned char output[100];
4316 int key_len, src_len;
4320 memset(md_name, 0x00, 100);
4321 memset(src_str, 0x00, 10000);
4322 memset(key_str, 0x00, 10000);
4323 memset(hash_str, 0x00, 10000);
4324 memset(output, 0x00, 100);
4326 strncpy( (
char *) md_name,
"sha1", 100 );
4328 fct_chk( md_info != NULL );
4331 key_len =
unhexify( key_str,
"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f" );
4332 src_len =
unhexify( src_str,
"53616d706c65202331" );
4335 fct_chk ( ctx.
md_ctx != NULL );
4342 fct_chk( strncmp( (
char *) hash_str,
"4f4ca3d5d68ba7cc0a1208c9c61e9c5da0403c0a", 20 * 2 ) == 0 );
4347 #ifdef POLARSSL_SHA1_C
4349 FCT_TEST_BGN(generic_multi_step_hmac_sha_1_test_vector_fips_198a_2)
4352 unsigned char src_str[10000];
4353 unsigned char key_str[10000];
4354 unsigned char hash_str[10000];
4355 unsigned char output[100];
4356 int key_len, src_len;
4360 memset(md_name, 0x00, 100);
4361 memset(src_str, 0x00, 10000);
4362 memset(key_str, 0x00, 10000);
4363 memset(hash_str, 0x00, 10000);
4364 memset(output, 0x00, 100);
4366 strncpy( (
char *) md_name,
"sha1", 100 );
4368 fct_chk( md_info != NULL );
4371 key_len =
unhexify( key_str,
"303132333435363738393a3b3c3d3e3f40414243" );
4372 src_len =
unhexify( src_str,
"53616d706c65202332" );
4375 fct_chk ( ctx.
md_ctx != NULL );
4382 fct_chk( strncmp( (
char *) hash_str,
"0922d3405faa3d194f82a45830737d5cc6c75d24", 20 * 2 ) == 0 );
4387 #ifdef POLARSSL_SHA1_C
4389 FCT_TEST_BGN(generic_multi_step_hmac_sha_1_test_vector_fips_198a_3)
4392 unsigned char src_str[10000];
4393 unsigned char key_str[10000];
4394 unsigned char hash_str[10000];
4395 unsigned char output[100];
4396 int key_len, src_len;
4400 memset(md_name, 0x00, 100);
4401 memset(src_str, 0x00, 10000);
4402 memset(key_str, 0x00, 10000);
4403 memset(hash_str, 0x00, 10000);
4404 memset(output, 0x00, 100);
4406 strncpy( (
char *) md_name,
"sha1", 100 );
4408 fct_chk( md_info != NULL );
4411 key_len =
unhexify( key_str,
"505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3" );
4412 src_len =
unhexify( src_str,
"53616d706c65202333" );
4415 fct_chk ( ctx.
md_ctx != NULL );
4422 fct_chk( strncmp( (
char *) hash_str,
"bcf41eab8bb2d802f3d05caf7cb092ecf8d1a3aa", 20 * 2 ) == 0 );
4427 #ifdef POLARSSL_SHA1_C
4429 FCT_TEST_BGN(generic_multi_step_hmac_sha_1_test_vector_fips_198a_4)
4432 unsigned char src_str[10000];
4433 unsigned char key_str[10000];
4434 unsigned char hash_str[10000];
4435 unsigned char output[100];
4436 int key_len, src_len;
4440 memset(md_name, 0x00, 100);
4441 memset(src_str, 0x00, 10000);
4442 memset(key_str, 0x00, 10000);
4443 memset(hash_str, 0x00, 10000);
4444 memset(output, 0x00, 100);
4446 strncpy( (
char *) md_name,
"sha1", 100 );
4448 fct_chk( md_info != NULL );
4451 key_len =
unhexify( key_str,
"707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0" );
4452 src_len =
unhexify( src_str,
"53616d706c65202334" );
4455 fct_chk ( ctx.
md_ctx != NULL );
4462 fct_chk( strncmp( (
char *) hash_str,
"9ea886efe268dbecce420c75", 12 * 2 ) == 0 );
4467 #ifdef POLARSSL_SHA1_C
4469 FCT_TEST_BGN(generic_multi_step_hmac_sha_1_test_vector_nist_cavs_1)
4472 unsigned char src_str[10000];
4473 unsigned char key_str[10000];
4474 unsigned char hash_str[10000];
4475 unsigned char output[100];
4476 int key_len, src_len;
4480 memset(md_name, 0x00, 100);
4481 memset(src_str, 0x00, 10000);
4482 memset(key_str, 0x00, 10000);
4483 memset(hash_str, 0x00, 10000);
4484 memset(output, 0x00, 100);
4486 strncpy( (
char *) md_name,
"sha1", 100 );
4488 fct_chk( md_info != NULL );
4491 key_len =
unhexify( key_str,
"7b10f4124b15c82e" );
4492 src_len =
unhexify( src_str,
"27dcb5b1daf60cfd3e2f73d4d64ca9c684f8bf71fc682a46793b1790afa4feb100ca7aaff26f58f0e1d0ed42f1cdad1f474afa2e79d53a0c42892c4d7b327cbe46b295ed8da3b6ecab3d4851687a6f812b79df2f6b20f11f6706f5301790ca99625aad7391d84f78043d2a0a239b1477984c157bbc9276064e7a1a406b0612ca" );
4495 fct_chk ( ctx.
md_ctx != NULL );
4502 fct_chk( strncmp( (
char *) hash_str,
"4ead12c2fe3d6ea43acb", 10 * 2 ) == 0 );
4507 #ifdef POLARSSL_SHA1_C
4509 FCT_TEST_BGN(generic_multi_step_hmac_sha_1_test_vector_nist_cavs_2)
4512 unsigned char src_str[10000];
4513 unsigned char key_str[10000];
4514 unsigned char hash_str[10000];
4515 unsigned char output[100];
4516 int key_len, src_len;
4520 memset(md_name, 0x00, 100);
4521 memset(src_str, 0x00, 10000);
4522 memset(key_str, 0x00, 10000);
4523 memset(hash_str, 0x00, 10000);
4524 memset(output, 0x00, 100);
4526 strncpy( (
char *) md_name,
"sha1", 100 );
4528 fct_chk( md_info != NULL );
4531 key_len =
unhexify( key_str,
"4fe9fb902172a21b" );
4532 src_len =
unhexify( src_str,
"4ceb3a7c13659c22fe51134f03dce4c239d181b63c6b0b59d367157fd05cab98384f92dfa482d2d5e78e72eef1b1838af4696026c54233d484ecbbe87f904df5546419f8567eafd232e6c2fcd3ee2b7682c63000524b078dbb2096f585007deae752562df1fe3b01278089e16f3be46e2d0f7cabac2d8e6cc02a2d0ca953425f" );
4535 fct_chk ( ctx.
md_ctx != NULL );
4542 fct_chk( strncmp( (
char *) hash_str,
"564428a67be1924b5793", 10 * 2 ) == 0 );
4547 #ifdef POLARSSL_SHA1_C
4549 FCT_TEST_BGN(generic_multi_step_hmac_sha_1_test_vector_nist_cavs_3)
4552 unsigned char src_str[10000];
4553 unsigned char key_str[10000];
4554 unsigned char hash_str[10000];
4555 unsigned char output[100];
4556 int key_len, src_len;
4560 memset(md_name, 0x00, 100);
4561 memset(src_str, 0x00, 10000);
4562 memset(key_str, 0x00, 10000);
4563 memset(hash_str, 0x00, 10000);
4564 memset(output, 0x00, 100);
4566 strncpy( (
char *) md_name,
"sha1", 100 );
4568 fct_chk( md_info != NULL );
4571 key_len =
unhexify( key_str,
"d1f01455f78c4fb4" );
4572 src_len =
unhexify( src_str,
"00d40f67b57914bec456a3e3201ef1464be319a8d188c02e157af4b54f9b5a66d67f898a9bdbb19ff63a80aba6f246d013575721d52eb1b47a65def884011c49b257bcc2817fc853f106e8138ce386d7a5ac3103de0a3fa0ed6bb7af9ff66ebd1cc46fb86e4da0013d20a3c2dcd8fb828a4b70f7f104b41bf3f44682a66497ea" );
4575 fct_chk ( ctx.
md_ctx != NULL );
4582 fct_chk( strncmp( (
char *) hash_str,
"56a665a7cdfe610f9fc5", 10 * 2 ) == 0 );
4587 #ifdef POLARSSL_SHA1_C
4589 FCT_TEST_BGN(generic_multi_step_hmac_sha_1_test_vector_nist_cavs_4)
4592 unsigned char src_str[10000];
4593 unsigned char key_str[10000];
4594 unsigned char hash_str[10000];
4595 unsigned char output[100];
4596 int key_len, src_len;
4600 memset(md_name, 0x00, 100);
4601 memset(src_str, 0x00, 10000);
4602 memset(key_str, 0x00, 10000);
4603 memset(hash_str, 0x00, 10000);
4604 memset(output, 0x00, 100);
4606 strncpy( (
char *) md_name,
"sha1", 100 );
4608 fct_chk( md_info != NULL );
4611 key_len =
unhexify( key_str,
"4e5ef77fdf033a5b" );
4612 src_len =
unhexify( src_str,
"e59326464e3201d195e29f2a3446ec1b1c9ff31154e2a4d0e40ed466f1bc855d29f76835624fa0127d29c9b1915939a046f385af7e5d47a23ba91f28bd22f811ea258dbbf3332bcd3543b8285d5df41bd064ffd64a341c22c4edb44f9c8d9e6df0c59dbf4a052a6c83da7478e179a6f3839c6870ff8ca8b9497f9ac1d725fdda" );
4615 fct_chk ( ctx.
md_ctx != NULL );
4622 fct_chk( strncmp( (
char *) hash_str,
"981c0a7a8423b63a8fa6", 10 * 2 ) == 0 );
4627 #ifdef POLARSSL_SHA1_C
4629 FCT_TEST_BGN(generic_multi_step_hmac_sha_1_test_vector_nist_cavs_5)
4632 unsigned char src_str[10000];
4633 unsigned char key_str[10000];
4634 unsigned char hash_str[10000];
4635 unsigned char output[100];
4636 int key_len, src_len;
4640 memset(md_name, 0x00, 100);
4641 memset(src_str, 0x00, 10000);
4642 memset(key_str, 0x00, 10000);
4643 memset(hash_str, 0x00, 10000);
4644 memset(output, 0x00, 100);
4646 strncpy( (
char *) md_name,
"sha1", 100 );
4648 fct_chk( md_info != NULL );
4651 key_len =
unhexify( key_str,
"bcd9ff8aa60be2be" );
4652 src_len =
unhexify( src_str,
"51be4d0eb37bab714f92e19e9d70390655b363e8cd346a748245e731f437759cb8206412c8dab2ef1d4f36f880f41ff69d949da4594fdecb65e23cac1329b59e69e29bf875b38c31df6fa546c595f35cc2192aa750679a8a51a65e00e839d73a8d8c598a610d237fbe78955213589d80efcb73b95b8586f96d17b6f51a71c3b8" );
4655 fct_chk ( ctx.
md_ctx != NULL );
4662 fct_chk( strncmp( (
char *) hash_str,
"84633f9f5040c8971478", 10 * 2 ) == 0 );
4667 #ifdef POLARSSL_SHA1_C
4669 FCT_TEST_BGN(generic_multi_step_hmac_sha_1_test_vector_nist_cavs_6)
4672 unsigned char src_str[10000];
4673 unsigned char key_str[10000];
4674 unsigned char hash_str[10000];
4675 unsigned char output[100];
4676 int key_len, src_len;
4680 memset(md_name, 0x00, 100);
4681 memset(src_str, 0x00, 10000);
4682 memset(key_str, 0x00, 10000);
4683 memset(hash_str, 0x00, 10000);
4684 memset(output, 0x00, 100);
4686 strncpy( (
char *) md_name,
"sha1", 100 );
4688 fct_chk( md_info != NULL );
4691 key_len =
unhexify( key_str,
"4a661bce6ed86d21" );
4692 src_len =
unhexify( src_str,
"5ff6c744f1aab1bc29697d71f67541b8b3cec3c7079183b10a83fb98a9ee251d4bac3e1cb581ca972aaed8efd7c2875a6fb4c991132f67c9742d45e53bc7e8eaa94b35b37a907be61086b426cd11088ac118934e85d968c9667fd69fc6f6ea38c0fe34710b7ece91211b9b7ea00acd31f022aa6726368f9928a1352f122233f1" );
4695 fct_chk ( ctx.
md_ctx != NULL );
4702 fct_chk( strncmp( (
char *) hash_str,
"739df59353ac6694e55e", 10 * 2 ) == 0 );
4707 #ifdef POLARSSL_SHA1_C
4709 FCT_TEST_BGN(generic_multi_step_hmac_sha_1_test_vector_nist_cavs_7)
4712 unsigned char src_str[10000];
4713 unsigned char key_str[10000];
4714 unsigned char hash_str[10000];
4715 unsigned char output[100];
4716 int key_len, src_len;
4720 memset(md_name, 0x00, 100);
4721 memset(src_str, 0x00, 10000);
4722 memset(key_str, 0x00, 10000);
4723 memset(hash_str, 0x00, 10000);
4724 memset(output, 0x00, 100);
4726 strncpy( (
char *) md_name,
"sha1", 100 );
4728 fct_chk( md_info != NULL );
4731 key_len =
unhexify( key_str,
"1287e1565a57b547" );
4732 src_len =
unhexify( src_str,
"390ffdccc6171c11568d85b8f913e019bf4cd982ca9cd21ea730d41bdf3fcc0bc88ff48ba13a8f23deb2d96ec1033e7b2a58ca72b0c1e17bf03330db25d1e360fa6918009c4294bd1215b5ccd159a8f58bc3dc3d490eb7c3b9f887e8c98dbbb274a75373dcb695a59abd0219529d88518a96f92abc0bbcbda985c388f1fbbcc9" );
4735 fct_chk ( ctx.
md_ctx != NULL );
4742 fct_chk( strncmp( (
char *) hash_str,
"d78ddf08077c7d9e2ba6", 10 * 2 ) == 0 );
4747 #ifdef POLARSSL_SHA2_C
4749 FCT_TEST_BGN(generic_multi_step_hmac_sha_224_test_vector_nist_cavs_1)
4752 unsigned char src_str[10000];
4753 unsigned char key_str[10000];
4754 unsigned char hash_str[10000];
4755 unsigned char output[100];
4756 int key_len, src_len;
4760 memset(md_name, 0x00, 100);
4761 memset(src_str, 0x00, 10000);
4762 memset(key_str, 0x00, 10000);
4763 memset(hash_str, 0x00, 10000);
4764 memset(output, 0x00, 100);
4766 strncpy( (
char *) md_name,
"sha224", 100 );
4768 fct_chk( md_info != NULL );
4771 key_len =
unhexify( key_str,
"e055eb756697ee573fd3214811a9f7fa" );
4772 src_len =
unhexify( src_str,
"3875847012ee42fe54a0027bdf38cca7021b83a2ed0503af69ef6c37c637bc1114fba40096c5947d736e19b7af3c68d95a4e3b8b073adbbb80f47e9db8f2d4f0018ddd847fabfdf9dd9b52c93e40458977725f6b7ba15f0816bb895cdf50401268f5d702b7e6a5f9faef57b8768c8a3fc14f9a4b3182b41d940e337d219b29ff" );
4775 fct_chk ( ctx.
md_ctx != NULL );
4782 fct_chk( strncmp( (
char *) hash_str,
"40a453133361cc48da11baf616ee", 14 * 2 ) == 0 );
4787 #ifdef POLARSSL_SHA2_C
4789 FCT_TEST_BGN(generic_multi_step_hmac_sha_224_test_vector_nist_cavs_2)
4792 unsigned char src_str[10000];
4793 unsigned char key_str[10000];
4794 unsigned char hash_str[10000];
4795 unsigned char output[100];
4796 int key_len, src_len;
4800 memset(md_name, 0x00, 100);
4801 memset(src_str, 0x00, 10000);
4802 memset(key_str, 0x00, 10000);
4803 memset(hash_str, 0x00, 10000);
4804 memset(output, 0x00, 100);
4806 strncpy( (
char *) md_name,
"sha224", 100 );
4808 fct_chk( md_info != NULL );
4811 key_len =
unhexify( key_str,
"88e5258b55b1623385eb9632fa7c57d6" );
4812 src_len =
unhexify( src_str,
"ada76bb604be14326551701cf30e48a65eee80b44f0b9d4a07b1844543b7844a621097fdc99de57387458ae9354899b620d0617eabcaefa9eef3d413a33628054335ce656c26fa2986e0f111a6351096b283101ec7868871d770b370973c7405983f9756b3005a3eab492cfd0e7eb42e5c2e15fa6be8718c0a50acc4e5717230" );
4815 fct_chk ( ctx.
md_ctx != NULL );
4822 fct_chk( strncmp( (
char *) hash_str,
"81c783af538015cef3c60095df53", 14 * 2 ) == 0 );
4827 #ifdef POLARSSL_SHA2_C
4829 FCT_TEST_BGN(generic_multi_step_hmac_sha_224_test_vector_nist_cavs_3)
4832 unsigned char src_str[10000];
4833 unsigned char key_str[10000];
4834 unsigned char hash_str[10000];
4835 unsigned char output[100];
4836 int key_len, src_len;
4840 memset(md_name, 0x00, 100);
4841 memset(src_str, 0x00, 10000);
4842 memset(key_str, 0x00, 10000);
4843 memset(hash_str, 0x00, 10000);
4844 memset(output, 0x00, 100);
4846 strncpy( (
char *) md_name,
"sha224", 100 );
4848 fct_chk( md_info != NULL );
4851 key_len =
unhexify( key_str,
"85d402d822114d31abf75526e2538705" );
4852 src_len =
unhexify( src_str,
"8020d8d98cc2e2298b32879c51c751e1dd5558fe2eabb8f158604297d6d072ce2261a1d6830b7cfe2617b57c7126f99c9476211d6161acd75d266da217ec8174b80484c9dc6f0448a0a036a3fc82e8bf54bdb71549368258d5d41f57978a4c266b92e8783ef66350215573d99be4089144b383ad8f3222bae8f3bf80ffb1bb2b" );
4855 fct_chk ( ctx.
md_ctx != NULL );
4862 fct_chk( strncmp( (
char *) hash_str,
"2aa0340ac9deafe3be38129daca0", 14 * 2 ) == 0 );
4867 #ifdef POLARSSL_SHA2_C
4869 FCT_TEST_BGN(generic_multi_step_hmac_sha_224_test_vector_nist_cavs_4)
4872 unsigned char src_str[10000];
4873 unsigned char key_str[10000];
4874 unsigned char hash_str[10000];
4875 unsigned char output[100];
4876 int key_len, src_len;
4880 memset(md_name, 0x00, 100);
4881 memset(src_str, 0x00, 10000);
4882 memset(key_str, 0x00, 10000);
4883 memset(hash_str, 0x00, 10000);
4884 memset(output, 0x00, 100);
4886 strncpy( (
char *) md_name,
"sha224", 100 );
4888 fct_chk( md_info != NULL );
4891 key_len =
unhexify( key_str,
"545c6eecc5ee46fa17c59f91a94f81ae" );
4892 src_len =
unhexify( src_str,
"8fb7f3565593170152ddb2021874784e951977cfdd22f8b72a72a61320a8f2a35697b5e913f717805559b1af1861ee3ed42fb788481e4fd276b17bdbefcae7b4501dc5d20de5b7626dd5efdcd65294db4bdf682c33d9a9255c6435383fa5f1c886326a3acbc6bd50a33ab5b2dbb034ce0112d4e226bbcd57e3731a519aa1d784" );
4895 fct_chk ( ctx.
md_ctx != NULL );
4902 fct_chk( strncmp( (
char *) hash_str,
"3eb566eac54c4a3a9ef092469f24", 14 * 2 ) == 0 );
4907 #ifdef POLARSSL_SHA2_C
4909 FCT_TEST_BGN(generic_multi_step_hmac_sha_224_test_vector_nist_cavs_5)
4912 unsigned char src_str[10000];
4913 unsigned char key_str[10000];
4914 unsigned char hash_str[10000];
4915 unsigned char output[100];
4916 int key_len, src_len;
4920 memset(md_name, 0x00, 100);
4921 memset(src_str, 0x00, 10000);
4922 memset(key_str, 0x00, 10000);
4923 memset(hash_str, 0x00, 10000);
4924 memset(output, 0x00, 100);
4926 strncpy( (
char *) md_name,
"sha224", 100 );
4928 fct_chk( md_info != NULL );
4931 key_len =
unhexify( key_str,
"4466ab4dc438841a9750c7f173dff02e" );
4932 src_len =
unhexify( src_str,
"2534c11c78c99cffaec8f722f04adc7045c7324d58ce98e37cfa94b6ed21ed7f58ce55379ef24b72d6d640ee9154f96c614734be9c408e225d7ba4cecc1179cc9f6e1808e1067aa8f244a99bd0c3267594c1887a40d167f8b7cf78db0d19f97b01fc50b8c86def490dfa7a5135002c33e71d77a8cce8ea0f93e0580439a33733" );
4935 fct_chk ( ctx.
md_ctx != NULL );
4942 fct_chk( strncmp( (
char *) hash_str,
"59f44a9bbed4875b892d22d6b5ab", 14 * 2 ) == 0 );
4947 #ifdef POLARSSL_SHA2_C
4949 FCT_TEST_BGN(generic_multi_step_hmac_sha_224_test_vector_nist_cavs_6)
4952 unsigned char src_str[10000];
4953 unsigned char key_str[10000];
4954 unsigned char hash_str[10000];
4955 unsigned char output[100];
4956 int key_len, src_len;
4960 memset(md_name, 0x00, 100);
4961 memset(src_str, 0x00, 10000);
4962 memset(key_str, 0x00, 10000);
4963 memset(hash_str, 0x00, 10000);
4964 memset(output, 0x00, 100);
4966 strncpy( (
char *) md_name,
"sha224", 100 );
4968 fct_chk( md_info != NULL );
4971 key_len =
unhexify( key_str,
"0e3dd9bb5e4cf0f09a4c11600af56d8d" );
4972 src_len =
unhexify( src_str,
"f4589fa76c328ea25cf8bae582026ba40a59d45a546ff31cf80eb826088f69bb954c452c74586836416dee90a5255bc5d56d3b405b3705a5197045688b32fa984c3a3dfbdc9c2460a0b5e6312a624048bb6f170306535e9b371a3ab134a2642a230ad03d2c688cca80baeaee9a20e1d4c548b1cede29c6a45bf4df2c8c476f1a" );
4975 fct_chk ( ctx.
md_ctx != NULL );
4982 fct_chk( strncmp( (
char *) hash_str,
"12175b93e3da4c58217145e4dc0a1cf142fab9319bb501e037b350ba", 28 * 2 ) == 0 );
4987 #ifdef POLARSSL_SHA2_C
4989 FCT_TEST_BGN(generic_multi_step_hmac_sha_224_test_vector_nist_cavs_7)
4992 unsigned char src_str[10000];
4993 unsigned char key_str[10000];
4994 unsigned char hash_str[10000];
4995 unsigned char output[100];
4996 int key_len, src_len;
5000 memset(md_name, 0x00, 100);
5001 memset(src_str, 0x00, 10000);
5002 memset(key_str, 0x00, 10000);
5003 memset(hash_str, 0x00, 10000);
5004 memset(output, 0x00, 100);
5006 strncpy( (
char *) md_name,
"sha224", 100 );
5008 fct_chk( md_info != NULL );
5011 key_len =
unhexify( key_str,
"cda5187b0c5dcb0f8e5a8beed2306584" );
5012 src_len =
unhexify( src_str,
"9011ae29b44c49b347487ce972965f16ade3c15be0856ce9c853a9739dba07e4f20d594ddc1dfe21560a65a4e458cfa17745575b915a30c7a9412ff8d1d689db9680dd2428c27588bb0dc92d2cd9445fe8f44b840a197c52c3c4333fff45533945134398df6436513cfab06c924046b8c795a5bd92e8d5f2de85bf306f2eed67" );
5015 fct_chk ( ctx.
md_ctx != NULL );
5022 fct_chk( strncmp( (
char *) hash_str,
"4aaba92b40e2a600feab176eb9b292d814864195c03342aad6f67f08", 28 * 2 ) == 0 );
5027 #ifdef POLARSSL_SHA2_C
5029 FCT_TEST_BGN(generic_multi_step_hmac_sha_256_test_vector_nist_cavs_1)
5032 unsigned char src_str[10000];
5033 unsigned char key_str[10000];
5034 unsigned char hash_str[10000];
5035 unsigned char output[100];
5036 int key_len, src_len;
5040 memset(md_name, 0x00, 100);
5041 memset(src_str, 0x00, 10000);
5042 memset(key_str, 0x00, 10000);
5043 memset(hash_str, 0x00, 10000);
5044 memset(output, 0x00, 100);
5046 strncpy( (
char *) md_name,
"sha256", 100 );
5048 fct_chk( md_info != NULL );
5051 key_len =
unhexify( key_str,
"cdffd34e6b16fdc0" );
5052 src_len =
unhexify( src_str,
"d83e78b99ab61709608972b36e76a575603db742269cc5dd4e7d5ca7816e26b65151c92632550cb4c5253c885d5fce53bc47459a1dbd5652786c4aac0145a532f12c05138af04cbb558101a7af5df478834c2146594dd73690d01a4fe72545894335f427ac70204798068cb86c5a600b40b414ede23590b41e1192373df84fe3" );
5055 fct_chk ( ctx.
md_ctx != NULL );
5062 fct_chk( strncmp( (
char *) hash_str,
"c6f0dde266cb4a26d41e8259d33499cc", 16 * 2 ) == 0 );
5067 #ifdef POLARSSL_SHA2_C
5069 FCT_TEST_BGN(generic_multi_step_hmac_sha_256_test_vector_nist_cavs_2)
5072 unsigned char src_str[10000];
5073 unsigned char key_str[10000];
5074 unsigned char hash_str[10000];
5075 unsigned char output[100];
5076 int key_len, src_len;
5080 memset(md_name, 0x00, 100);
5081 memset(src_str, 0x00, 10000);
5082 memset(key_str, 0x00, 10000);
5083 memset(hash_str, 0x00, 10000);
5084 memset(output, 0x00, 100);
5086 strncpy( (
char *) md_name,
"sha256", 100 );
5088 fct_chk( md_info != NULL );
5091 key_len =
unhexify( key_str,
"6d97bb5892245be2" );
5092 src_len =
unhexify( src_str,
"13c2b391d59c0252ca5d2302beaaf88c4bcd779bb505ad9a122003dfae4cc123ad2bd036f225c4f040021a6b9fb8bd6f0281cf2e2631a732bdc71693cc42ef6d52b6c6912a9ef77b3274eb85ad7f965ae6ed44ac1721962a884ec7acfb4534b1488b1c0c45afa4dae8da1eb7b0a88a3240365d7e4e7d826abbde9f9203fd99d7" );
5095 fct_chk ( ctx.
md_ctx != NULL );
5102 fct_chk( strncmp( (
char *) hash_str,
"31588e241b015319a5ab8c4527296498", 16 * 2 ) == 0 );
5107 #ifdef POLARSSL_SHA2_C
5109 FCT_TEST_BGN(generic_multi_step_hmac_sha_256_test_vector_nist_cavs_3)
5112 unsigned char src_str[10000];
5113 unsigned char key_str[10000];
5114 unsigned char hash_str[10000];
5115 unsigned char output[100];
5116 int key_len, src_len;
5120 memset(md_name, 0x00, 100);
5121 memset(src_str, 0x00, 10000);
5122 memset(key_str, 0x00, 10000);
5123 memset(hash_str, 0x00, 10000);
5124 memset(output, 0x00, 100);
5126 strncpy( (
char *) md_name,
"sha256", 100 );
5128 fct_chk( md_info != NULL );
5131 key_len =
unhexify( key_str,
"3c7fc8a70b49007a" );
5132 src_len =
unhexify( src_str,
"60024e428a39c8b8bb2e9591bad9dc2115dfbfd716b6eb7af30a6eb34560caccbbfa47b710fa8d523aca71e9e5ba10fc1feb1a43556d71f07ea4f33496f093044e8caf1d02b79e46eb1288d5964a7a7494f6b92574c35784eece054c6151281d80822f7d47b8231c35d07f5cb5cf4310ddc844845a01c6bfab514c048eccaf9f" );
5135 fct_chk ( ctx.
md_ctx != NULL );
5142 fct_chk( strncmp( (
char *) hash_str,
"1c98c94a32bec9f253c21070f82f8438", 16 * 2 ) == 0 );
5147 #ifdef POLARSSL_SHA2_C
5149 FCT_TEST_BGN(generic_multi_step_hmac_sha_256_test_vector_nist_cavs_4)
5152 unsigned char src_str[10000];
5153 unsigned char key_str[10000];
5154 unsigned char hash_str[10000];
5155 unsigned char output[100];
5156 int key_len, src_len;
5160 memset(md_name, 0x00, 100);
5161 memset(src_str, 0x00, 10000);
5162 memset(key_str, 0x00, 10000);
5163 memset(hash_str, 0x00, 10000);
5164 memset(output, 0x00, 100);
5166 strncpy( (
char *) md_name,
"sha256", 100 );
5168 fct_chk( md_info != NULL );
5171 key_len =
unhexify( key_str,
"369f33f85b927a07" );
5172 src_len =
unhexify( src_str,
"ae8e2a94ca386d448cbacdb0e9040ae3cb297c296363052cc157455da29a0c95897315fc11e3f12b81e2418da1ec280bccbc00e847584ce9d14deeba7b3c9b8dba958b04bba37551f6c9ba9c060be1a4b8cf43aa62e5078b76c6512c5619b71a6a7cf5727180e1ff14f5a1a3c1691bf8b6ebad365c151e58d749d57adb3a4986" );
5175 fct_chk ( ctx.
md_ctx != NULL );
5182 fct_chk( strncmp( (
char *) hash_str,
"60b90383286533d309de46593e6ce39fc51fb00a8d88278c", 24 * 2 ) == 0 );
5187 #ifdef POLARSSL_SHA2_C
5189 FCT_TEST_BGN(generic_multi_step_hmac_sha_256_test_vector_nist_cavs_5)
5192 unsigned char src_str[10000];
5193 unsigned char key_str[10000];
5194 unsigned char hash_str[10000];
5195 unsigned char output[100];
5196 int key_len, src_len;
5200 memset(md_name, 0x00, 100);
5201 memset(src_str, 0x00, 10000);
5202 memset(key_str, 0x00, 10000);
5203 memset(hash_str, 0x00, 10000);
5204 memset(output, 0x00, 100);
5206 strncpy( (
char *) md_name,
"sha256", 100 );
5208 fct_chk( md_info != NULL );
5211 key_len =
unhexify( key_str,
"e5179687582b4dc4" );
5212 src_len =
unhexify( src_str,
"ce103bdacdf32f614f6727bcb31ca1c2824a850d00f5585b016fb234fe1ef2cd687f302d3c6b738ed89a24060d65c36675d0d96307c72ef3e8a83bfa8402e226de9d5d1724ba75c4879bf41a4a465ce61887d9f49a34757849b48bae81c27ebed76faae2ad669bca04747d409148d40812776e0ae2c395b3cb9c89981ce72d5c" );
5215 fct_chk ( ctx.
md_ctx != NULL );
5222 fct_chk( strncmp( (
char *) hash_str,
"509581f6816df4b8cc9f2cf42b7cc6e6a5a1e375a16f2412", 24 * 2 ) == 0 );
5227 #ifdef POLARSSL_SHA2_C
5229 FCT_TEST_BGN(generic_multi_step_hmac_sha_256_test_vector_nist_cavs_6)
5232 unsigned char src_str[10000];
5233 unsigned char key_str[10000];
5234 unsigned char hash_str[10000];
5235 unsigned char output[100];
5236 int key_len, src_len;
5240 memset(md_name, 0x00, 100);
5241 memset(src_str, 0x00, 10000);
5242 memset(key_str, 0x00, 10000);
5243 memset(hash_str, 0x00, 10000);
5244 memset(output, 0x00, 100);
5246 strncpy( (
char *) md_name,
"sha256", 100 );
5248 fct_chk( md_info != NULL );
5251 key_len =
unhexify( key_str,
"63cec6246aeb1b61" );
5252 src_len =
unhexify( src_str,
"c178db908a405fa88aa255b8cad22b4057016585f139ee930388b083d86062fa0b3ea1f23f8a43bd11bee8464bcbd19b5ab9f6a8038d5245516f8274d20c8ee3033a07b908da528fa00343bb595deed500cab9745c4cb6391c23300f0d3584b090b3326c4cfa342620b78f9f5b4f27f7307ed770643ec1764aeae3dcf1a3ec69" );
5255 fct_chk ( ctx.
md_ctx != NULL );
5262 fct_chk( strncmp( (
char *) hash_str,
"64f3dd861b7c7d29fce9ae0ce9ed954b5d7141806ee9eec7", 24 * 2 ) == 0 );
5267 #ifdef POLARSSL_SHA4_C
5269 FCT_TEST_BGN(generic_multi_step_hmac_sha_384_test_vector_nist_cavs_1)
5272 unsigned char src_str[10000];
5273 unsigned char key_str[10000];
5274 unsigned char hash_str[10000];
5275 unsigned char output[100];
5276 int key_len, src_len;
5280 memset(md_name, 0x00, 100);
5281 memset(src_str, 0x00, 10000);
5282 memset(key_str, 0x00, 10000);
5283 memset(hash_str, 0x00, 10000);
5284 memset(output, 0x00, 100);
5286 strncpy( (
char *) md_name,
"sha384", 100 );
5288 fct_chk( md_info != NULL );
5291 key_len =
unhexify( key_str,
"91a7401817386948ca952f9a20ee55dc" );
5292 src_len =
unhexify( src_str,
"2fea5b91035d6d501f3a834fa178bff4e64b99a8450432dafd32e4466b0e1e7781166f8a73f7e036b3b0870920f559f47bd1400a1a906e85e0dcf00a6c26862e9148b23806680f285f1fe4f93cdaf924c181a965465739c14f2268c8be8b471847c74b222577a1310bcdc1a85ef1468aa1a3fd4031213c97324b7509c9050a3d" );
5295 fct_chk ( ctx.
md_ctx != NULL );
5302 fct_chk( strncmp( (
char *) hash_str,
"6d7be9490058cf413cc09fd043c224c2ec4fa7859b13783000a9a593c9f75838", 32 * 2 ) == 0 );
5307 #ifdef POLARSSL_SHA4_C
5309 FCT_TEST_BGN(generic_multi_step_hmac_sha_384_test_vector_nist_cavs_2)
5312 unsigned char src_str[10000];
5313 unsigned char key_str[10000];
5314 unsigned char hash_str[10000];
5315 unsigned char output[100];
5316 int key_len, src_len;
5320 memset(md_name, 0x00, 100);
5321 memset(src_str, 0x00, 10000);
5322 memset(key_str, 0x00, 10000);
5323 memset(hash_str, 0x00, 10000);
5324 memset(output, 0x00, 100);
5326 strncpy( (
char *) md_name,
"sha384", 100 );
5328 fct_chk( md_info != NULL );
5331 key_len =
unhexify( key_str,
"d6cac19657061aa90a6da11cd2e9ea47" );
5332 src_len =
unhexify( src_str,
"9f482e4655173135dfaa22a11bbbe6af263db48716406c5aec162ba3c4b41cad4f5a91558377521191c7343118beee65982929802913d67b6de5c4bdc3d27299bd722219d5ad2efa5bdb9ff7b229fc4bbc3f60719320cf2e7a51cad1133d21bad2d80919b1836ef825308b7c51c6b7677ac782e2bc30007afba065681cbdd215" );
5335 fct_chk ( ctx.
md_ctx != NULL );
5342 fct_chk( strncmp( (
char *) hash_str,
"f3d5f3c008175321aa7b2ea379eaa4f8b9dcc60f895ec8940b8162f80a7dfe9f", 32 * 2 ) == 0 );
5347 #ifdef POLARSSL_SHA4_C
5349 FCT_TEST_BGN(generic_multi_step_hmac_sha_384_test_vector_nist_cavs_3)
5352 unsigned char src_str[10000];
5353 unsigned char key_str[10000];
5354 unsigned char hash_str[10000];
5355 unsigned char output[100];
5356 int key_len, src_len;
5360 memset(md_name, 0x00, 100);
5361 memset(src_str, 0x00, 10000);
5362 memset(key_str, 0x00, 10000);
5363 memset(hash_str, 0x00, 10000);
5364 memset(output, 0x00, 100);
5366 strncpy( (
char *) md_name,
"sha384", 100 );
5368 fct_chk( md_info != NULL );
5371 key_len =
unhexify( key_str,
"e06366ad149b8442cd4c1abdddd0afde" );
5372 src_len =
unhexify( src_str,
"2d140a194c02a5598f69174834679b8371234a0d505491f1bd03e128dd91a8bca2fb812e9d5da71613b5b00952ea78bf450d5b7547dea79135925085c7d3e6f52009c51ca3d88c6c09e9d074b0ee110736e0ec9b478b93efb34d7bf1c41b54decec43eab077a3aa4998ede53f67b4ea36c266745f9643d5360bdc8337c70dabf" );
5375 fct_chk ( ctx.
md_ctx != NULL );
5382 fct_chk( strncmp( (
char *) hash_str,
"c19c67eda6fe29f3667bee1c897c333ce7683094ae77e84b4c16378d290895a1", 32 * 2 ) == 0 );
5387 #ifdef POLARSSL_SHA4_C
5389 FCT_TEST_BGN(generic_multi_step_hmac_sha_384_test_vector_nist_cavs_4)
5392 unsigned char src_str[10000];
5393 unsigned char key_str[10000];
5394 unsigned char hash_str[10000];
5395 unsigned char output[100];
5396 int key_len, src_len;
5400 memset(md_name, 0x00, 100);
5401 memset(src_str, 0x00, 10000);
5402 memset(key_str, 0x00, 10000);
5403 memset(hash_str, 0x00, 10000);
5404 memset(output, 0x00, 100);
5406 strncpy( (
char *) md_name,
"sha384", 100 );
5408 fct_chk( md_info != NULL );
5411 key_len =
unhexify( key_str,
"01ac59f42f8bb91d1bd10fe6990d7a87" );
5412 src_len =
unhexify( src_str,
"3caf18c476edd5615f343ac7b7d3a9da9efade755672d5ba4b8ae8a7505539ea2c124ff755ec0457fbe49e43480b3c71e7f4742ec3693aad115d039f90222b030fdc9440313691716d5302005808c07627483b916fdf61983063c2eb1268f2deeef42fc790334456bc6bad256e31fc9066de7cc7e43d1321b1866db45e905622" );
5415 fct_chk ( ctx.
md_ctx != NULL );
5422 fct_chk( strncmp( (
char *) hash_str,
"1985fa2163a5943fc5d92f1fe8831215e7e91f0bff5332bc713a072bdb3a8f9e5c5157463a3bfeb36231416e65973e64", 48 * 2 ) == 0 );
5427 #ifdef POLARSSL_SHA4_C
5429 FCT_TEST_BGN(generic_multi_step_hmac_sha_384_test_vector_nist_cavs_5)
5432 unsigned char src_str[10000];
5433 unsigned char key_str[10000];
5434 unsigned char hash_str[10000];
5435 unsigned char output[100];
5436 int key_len, src_len;
5440 memset(md_name, 0x00, 100);
5441 memset(src_str, 0x00, 10000);
5442 memset(key_str, 0x00, 10000);
5443 memset(hash_str, 0x00, 10000);
5444 memset(output, 0x00, 100);
5446 strncpy( (
char *) md_name,
"sha384", 100 );
5448 fct_chk( md_info != NULL );
5451 key_len =
unhexify( key_str,
"fd74b9d9e102a3a80df1baf0cb35bace" );
5452 src_len =
unhexify( src_str,
"1a068917584813d1689ccbd0370c2114d537cdc8cc52bf6db16d5535f8f7d1ad0c850a9fa0cf62373ffbf7642b1f1e8164010d350721d798d9f99e9724830399c2fce26377e83d38845675457865c03d4a07d741a505ef028343eb29fd46d0f761f3792886998c1e5c32ac3bc7e6f08faed194b34f06eff4d5d4a5b42c481e0e" );
5455 fct_chk ( ctx.
md_ctx != NULL );
5462 fct_chk( strncmp( (
char *) hash_str,
"a981eaf5de3d78b20ebd4414a4edd0657e3667cd808a0dbc430cf7252f73a5b24efa136039207bd59806897457d74e0c", 48 * 2 ) == 0 );
5467 #ifdef POLARSSL_SHA4_C
5469 FCT_TEST_BGN(generic_multi_step_hmac_sha_384_test_vector_nist_cavs_5)
5472 unsigned char src_str[10000];
5473 unsigned char key_str[10000];
5474 unsigned char hash_str[10000];
5475 unsigned char output[100];
5476 int key_len, src_len;
5480 memset(md_name, 0x00, 100);
5481 memset(src_str, 0x00, 10000);
5482 memset(key_str, 0x00, 10000);
5483 memset(hash_str, 0x00, 10000);
5484 memset(output, 0x00, 100);
5486 strncpy( (
char *) md_name,
"sha384", 100 );
5488 fct_chk( md_info != NULL );
5491 key_len =
unhexify( key_str,
"9fe794f0e26b669fa5f6883149377c6c" );
5492 src_len =
unhexify( src_str,
"6010c9745e8f1d44cfdc99e7e0fd79bc4271944c2d1d84dba589073dfc4ca5eb98c59356f60cd87bef28aeb83a832bde339b2087daf942aa1f67876c5d5ed33924bed4143bc12a2be532ccaf64daa7e2bc3c8872b9823b0533b6f5159135effe8c61545536975d7c3a61ba7365ec35f165bc92b4d19eb9156ade17dfa1bb4161" );
5495 fct_chk ( ctx.
md_ctx != NULL );
5502 fct_chk( strncmp( (
char *) hash_str,
"915ae61f8754698c2b6ef9629e93441f8541bd4258a5e05372d19136cfaefc0473b48d96119291b38eb1a3cb1982a986", 48 * 2 ) == 0 );
5507 #ifdef POLARSSL_SHA4_C
5509 FCT_TEST_BGN(generic_multi_step_hmac_sha_512_test_vector_nist_cavs_1)
5512 unsigned char src_str[10000];
5513 unsigned char key_str[10000];
5514 unsigned char hash_str[10000];
5515 unsigned char output[100];
5516 int key_len, src_len;
5520 memset(md_name, 0x00, 100);
5521 memset(src_str, 0x00, 10000);
5522 memset(key_str, 0x00, 10000);
5523 memset(hash_str, 0x00, 10000);
5524 memset(output, 0x00, 100);
5526 strncpy( (
char *) md_name,
"sha512", 100 );
5528 fct_chk( md_info != NULL );
5531 key_len =
unhexify( key_str,
"c95a17c09940a691ed2d621571b0eb844ede55a9" );
5532 src_len =
unhexify( src_str,
"99cd28262e81f34878cdcebf4128e05e2098a7009278a66f4c785784d0e5678f3f2b22f86e982d273b6273a222ec61750b4556d766f1550a7aedfe83faedbc4bdae83fa560d62df17eb914d05fdaa48940551bac81d700f5fca7147295e386e8120d66742ec65c6ee8d89a92217a0f6266d0ddc60bb20ef679ae8299c8502c2f" );
5535 fct_chk ( ctx.
md_ctx != NULL );
5542 fct_chk( strncmp( (
char *) hash_str,
"6bc1379d156559ddee2ed420ea5d5c5ff3e454a1059b7ba72c350e77b6e9333c", 32 * 2 ) == 0 );
5547 #ifdef POLARSSL_SHA4_C
5549 FCT_TEST_BGN(generic_multi_step_hmac_sha_512_test_vector_nist_cavs_2)
5552 unsigned char src_str[10000];
5553 unsigned char key_str[10000];
5554 unsigned char hash_str[10000];
5555 unsigned char output[100];
5556 int key_len, src_len;
5560 memset(md_name, 0x00, 100);
5561 memset(src_str, 0x00, 10000);
5562 memset(key_str, 0x00, 10000);
5563 memset(hash_str, 0x00, 10000);
5564 memset(output, 0x00, 100);
5566 strncpy( (
char *) md_name,
"sha512", 100 );
5568 fct_chk( md_info != NULL );
5571 key_len =
unhexify( key_str,
"3b10b8fa718840d1dea8e9fc317476bcf55875fd" );
5572 src_len =
unhexify( src_str,
"f04f5b7073d7d0274e8354433b390306c5607632f5f589c12edb62d55673aff2366d2e6b24de731adf92e654baa30b1cfd4a069788f65ec1b99b015d904d8832110dbd74eae35a81562d14ce4136d820ad0a55ff5489ba678fbbc1c27663ec1349d70e740f0e0ec27cfbe8971819f4789e486b50a2d7271d77e2aaea50de62fd" );
5575 fct_chk ( ctx.
md_ctx != NULL );
5582 fct_chk( strncmp( (
char *) hash_str,
"fc3c38c7a17e3ce06db033f1c172866f01a00045db55f2e234f71c82264f2ba2", 32 * 2 ) == 0 );
5587 #ifdef POLARSSL_SHA4_C
5589 FCT_TEST_BGN(generic_multi_step_hmac_sha_512_test_vector_nist_cavs_3)
5592 unsigned char src_str[10000];
5593 unsigned char key_str[10000];
5594 unsigned char hash_str[10000];
5595 unsigned char output[100];
5596 int key_len, src_len;
5600 memset(md_name, 0x00, 100);
5601 memset(src_str, 0x00, 10000);
5602 memset(key_str, 0x00, 10000);
5603 memset(hash_str, 0x00, 10000);
5604 memset(output, 0x00, 100);
5606 strncpy( (
char *) md_name,
"sha512", 100 );
5608 fct_chk( md_info != NULL );
5611 key_len =
unhexify( key_str,
"4803d311394600dc1e0d8fc8cedeb8bde3fe7c42" );
5612 src_len =
unhexify( src_str,
"a10c125dd702a97153ad923ba5e9889cfac1ba169de370debe51f233735aa6effcc9785c4b5c7e48c477dc5c411ae6a959118584e26adc94b42c2b29b046f3cf01c65b24a24bd2e620bdf650a23bb4a72655b1100d7ce9a4dab697c6379754b4396c825de4b9eb73f2e6a6c0d0353bbdeaf706612800e137b858fdb30f3311c6" );
5615 fct_chk ( ctx.
md_ctx != NULL );
5622 fct_chk( strncmp( (
char *) hash_str,
"7cd8236c55102e6385f52279506df6fcc388ab75092da21395ce14a82b202ffa", 32 * 2 ) == 0 );
5627 #ifdef POLARSSL_SHA4_C
5629 FCT_TEST_BGN(generic_multi_step_hmac_sha_512_test_vector_nist_cavs_4)
5632 unsigned char src_str[10000];
5633 unsigned char key_str[10000];
5634 unsigned char hash_str[10000];
5635 unsigned char output[100];
5636 int key_len, src_len;
5640 memset(md_name, 0x00, 100);
5641 memset(src_str, 0x00, 10000);
5642 memset(key_str, 0x00, 10000);
5643 memset(hash_str, 0x00, 10000);
5644 memset(output, 0x00, 100);
5646 strncpy( (
char *) md_name,
"sha512", 100 );
5648 fct_chk( md_info != NULL );
5651 key_len =
unhexify( key_str,
"aeb2f3b977fa6c8e71e07c5a5c74ff58166de092" );
5652 src_len =
unhexify( src_str,
"22457355dc76095abd46846b41cfe49a06ce42ac8857b4702fc771508dfb3626e0bfe851df897a07b36811ec433766e4b4166c26301b3493e7440d4554b0ef6ac20f1a530e58fac8aeba4e9ff2d4898d8a28783b49cd269c2965fd7f8e4f2d60cf1e5284f2495145b72382aad90e153a90ecae125ad75336fb128825c23fb8b0" );
5655 fct_chk ( ctx.
md_ctx != NULL );
5662 fct_chk( strncmp( (
char *) hash_str,
"fa39bd8fcc3bfa218f9dea5d3b2ce10a7619e31678a56d8a9d927b1fe703b125af445debe9a89a07db6194d27b44d85a", 48 * 2 ) == 0 );
5667 #ifdef POLARSSL_SHA4_C
5669 FCT_TEST_BGN(generic_multi_step_hmac_sha_512_test_vector_nist_cavs_5)
5672 unsigned char src_str[10000];
5673 unsigned char key_str[10000];
5674 unsigned char hash_str[10000];
5675 unsigned char output[100];
5676 int key_len, src_len;
5680 memset(md_name, 0x00, 100);
5681 memset(src_str, 0x00, 10000);
5682 memset(key_str, 0x00, 10000);
5683 memset(hash_str, 0x00, 10000);
5684 memset(output, 0x00, 100);
5686 strncpy( (
char *) md_name,
"sha512", 100 );
5688 fct_chk( md_info != NULL );
5691 key_len =
unhexify( key_str,
"4285d3d7744da52775bb44ca436a3154f7980309" );
5692 src_len =
unhexify( src_str,
"208f0b6f2de2e5aa5df11927ddc6df485edc1193181c484d0f0a434a95418803101d4de9fdb798f93516a6916fa38a8207de1666fe50fe3441c03b112eaaae6954ed063f7ac4e3c1e3f73b20d153fe9e4857f5e91430f0a70ee820529adac2467469fd18adf10e2af0fea27c0abc83c5a9af77c364a466cffce8bab4e2b70bc1" );
5695 fct_chk ( ctx.
md_ctx != NULL );
5702 fct_chk( strncmp( (
char *) hash_str,
"fe7603f205b2774fe0f14ecfa3e338e90608a806d11ca459dff5ce36b1b264ecd3af5f0492a7521d8da3102ba20927a5", 48 * 2 ) == 0 );
5707 #ifdef POLARSSL_SHA4_C
5709 FCT_TEST_BGN(generic_multi_step_hmac_sha_512_test_vector_nist_cavs_6)
5712 unsigned char src_str[10000];
5713 unsigned char key_str[10000];
5714 unsigned char hash_str[10000];
5715 unsigned char output[100];
5716 int key_len, src_len;
5720 memset(md_name, 0x00, 100);
5721 memset(src_str, 0x00, 10000);
5722 memset(key_str, 0x00, 10000);
5723 memset(hash_str, 0x00, 10000);
5724 memset(output, 0x00, 100);
5726 strncpy( (
char *) md_name,
"sha512", 100 );
5728 fct_chk( md_info != NULL );
5731 key_len =
unhexify( key_str,
"8ab783d5acf32efa0d9c0a21abce955e96630d89" );
5732 src_len =
unhexify( src_str,
"17371e013dce839963d54418e97be4bd9fa3cb2a368a5220f5aa1b8aaddfa3bdefc91afe7c717244fd2fb640f5cb9d9bf3e25f7f0c8bc758883b89dcdce6d749d9672fed222277ece3e84b3ec01b96f70c125fcb3cbee6d19b8ef0873f915f173bdb05d81629ba187cc8ac1934b2f75952fb7616ae6bd812946df694bd2763af" );
5735 fct_chk ( ctx.
md_ctx != NULL );
5742 fct_chk( strncmp( (
char *) hash_str,
"9ac7ca8d1aefc166b046e4cf7602ebe181a0e5055474bff5b342106731da0d7e48e4d87bc0a6f05871574289a1b099f8", 48 * 2 ) == 0 );
5747 #ifdef POLARSSL_SHA1_C
5749 FCT_TEST_BGN(generic_sha_1_test_vector_nist_cavs_1)
5752 unsigned char src_str[10000];
5753 unsigned char hash_str[10000];
5754 unsigned char output[100];
5758 memset(md_name, 0x00, 100);
5759 memset(src_str, 0x00, 10000);
5760 memset(hash_str, 0x00, 10000);
5761 memset(output, 0x00, 100);
5763 strncpy( (
char *) md_name,
"sha1", 100 );
5765 fct_chk( md_info != NULL );
5768 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
5772 fct_chk( strcmp( (
char *) hash_str,
"da39a3ee5e6b4b0d3255bfef95601890afd80709" ) == 0 );
5777 #ifdef POLARSSL_SHA1_C
5779 FCT_TEST_BGN(generic_sha_1_test_vector_nist_cavs_2)
5782 unsigned char src_str[10000];
5783 unsigned char hash_str[10000];
5784 unsigned char output[100];
5788 memset(md_name, 0x00, 100);
5789 memset(src_str, 0x00, 10000);
5790 memset(hash_str, 0x00, 10000);
5791 memset(output, 0x00, 100);
5793 strncpy( (
char *) md_name,
"sha1", 100 );
5795 fct_chk( md_info != NULL );
5797 src_len =
unhexify( src_str,
"a8" );
5798 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
5802 fct_chk( strcmp( (
char *) hash_str,
"99f2aa95e36f95c2acb0eaf23998f030638f3f15" ) == 0 );
5807 #ifdef POLARSSL_SHA1_C
5809 FCT_TEST_BGN(generic_sha_1_test_vector_nist_cavs_3)
5812 unsigned char src_str[10000];
5813 unsigned char hash_str[10000];
5814 unsigned char output[100];
5818 memset(md_name, 0x00, 100);
5819 memset(src_str, 0x00, 10000);
5820 memset(hash_str, 0x00, 10000);
5821 memset(output, 0x00, 100);
5823 strncpy( (
char *) md_name,
"sha1", 100 );
5825 fct_chk( md_info != NULL );
5827 src_len =
unhexify( src_str,
"3000" );
5828 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
5832 fct_chk( strcmp( (
char *) hash_str,
"f944dcd635f9801f7ac90a407fbc479964dec024" ) == 0 );
5837 #ifdef POLARSSL_SHA1_C
5839 FCT_TEST_BGN(generic_sha_1_test_vector_nist_cavs_4)
5842 unsigned char src_str[10000];
5843 unsigned char hash_str[10000];
5844 unsigned char output[100];
5848 memset(md_name, 0x00, 100);
5849 memset(src_str, 0x00, 10000);
5850 memset(hash_str, 0x00, 10000);
5851 memset(output, 0x00, 100);
5853 strncpy( (
char *) md_name,
"sha1", 100 );
5855 fct_chk( md_info != NULL );
5857 src_len =
unhexify( src_str,
"42749e" );
5858 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
5862 fct_chk( strcmp( (
char *) hash_str,
"a444319e9b6cc1e8464c511ec0969c37d6bb2619" ) == 0 );
5867 #ifdef POLARSSL_SHA1_C
5869 FCT_TEST_BGN(generic_sha_1_test_vector_nist_cavs_5)
5872 unsigned char src_str[10000];
5873 unsigned char hash_str[10000];
5874 unsigned char output[100];
5878 memset(md_name, 0x00, 100);
5879 memset(src_str, 0x00, 10000);
5880 memset(hash_str, 0x00, 10000);
5881 memset(output, 0x00, 100);
5883 strncpy( (
char *) md_name,
"sha1", 100 );
5885 fct_chk( md_info != NULL );
5887 src_len =
unhexify( src_str,
"9fc3fe08" );
5888 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
5892 fct_chk( strcmp( (
char *) hash_str,
"16a0ff84fcc156fd5d3ca3a744f20a232d172253" ) == 0 );
5897 #ifdef POLARSSL_SHA1_C
5899 FCT_TEST_BGN(generic_sha_1_test_vector_nist_cavs_6)
5902 unsigned char src_str[10000];
5903 unsigned char hash_str[10000];
5904 unsigned char output[100];
5908 memset(md_name, 0x00, 100);
5909 memset(src_str, 0x00, 10000);
5910 memset(hash_str, 0x00, 10000);
5911 memset(output, 0x00, 100);
5913 strncpy( (
char *) md_name,
"sha1", 100 );
5915 fct_chk( md_info != NULL );
5917 src_len =
unhexify( src_str,
"b5c1c6f1af" );
5918 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
5922 fct_chk( strcmp( (
char *) hash_str,
"fec9deebfcdedaf66dda525e1be43597a73a1f93" ) == 0 );
5927 #ifdef POLARSSL_SHA1_C
5929 FCT_TEST_BGN(generic_sha_1_test_vector_nist_cavs_7)
5932 unsigned char src_str[10000];
5933 unsigned char hash_str[10000];
5934 unsigned char output[100];
5938 memset(md_name, 0x00, 100);
5939 memset(src_str, 0x00, 10000);
5940 memset(hash_str, 0x00, 10000);
5941 memset(output, 0x00, 100);
5943 strncpy( (
char *) md_name,
"sha1", 100 );
5945 fct_chk( md_info != NULL );
5947 src_len =
unhexify( src_str,
"ec29561244ede706b6eb30a1c371d74450a105c3f9735f7fa9fe38cf67f304a5736a106e92e17139a6813b1c81a4f3d3fb9546ab4296fa9f722826c066869edacd73b2548035185813e22634a9da44000d95a281ff9f264ecce0a931222162d021cca28db5f3c2aa24945ab1e31cb413ae29810fd794cad5dfaf29ec43cb38d198fe4ae1da2359780221405bd6712a5305da4b1b737fce7cd21c0eb7728d08235a9011" );
5948 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
5952 fct_chk( strcmp( (
char *) hash_str,
"970111c4e77bcc88cc20459c02b69b4aa8f58217" ) == 0 );
5957 #ifdef POLARSSL_SHA1_C
5959 FCT_TEST_BGN(generic_sha_1_test_vector_nist_cavs_8)
5962 unsigned char src_str[10000];
5963 unsigned char hash_str[10000];
5964 unsigned char output[100];
5968 memset(md_name, 0x00, 100);
5969 memset(src_str, 0x00, 10000);
5970 memset(hash_str, 0x00, 10000);
5971 memset(output, 0x00, 100);
5973 strncpy( (
char *) md_name,
"sha1", 100 );
5975 fct_chk( md_info != NULL );
5977 src_len =
unhexify( src_str,
"5fc2c3f6a7e79dc94be526e5166a238899d54927ce470018fbfd668fd9dd97cbf64e2c91584d01da63be3cc9fdff8adfefc3ac728e1e335b9cdc87f069172e323d094b47fa1e652afe4d6aa147a9f46fda33cacb65f3aa12234746b9007a8c85fe982afed7815221e43dba553d8fe8a022cdac1b99eeeea359e5a9d2e72e382dffa6d19f359f4f27dc3434cd27daeeda8e38594873398678065fbb23665aba9309d946135da0e4a4afdadff14db18e85e71dd93c3bf9faf7f25c8194c4269b1ee3d9934097ab990025d9c3aaf63d5109f52335dd3959d38ae485050e4bbb6235574fc0102be8f7a306d6e8de6ba6becf80f37415b57f9898a5824e77414197422be3d36a6080" );
5978 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
5982 fct_chk( strcmp( (
char *) hash_str,
"0423dc76a8791107d14e13f5265b343f24cc0f19" ) == 0 );
5987 #ifdef POLARSSL_SHA1_C
5989 FCT_TEST_BGN(generic_sha_1_test_vector_nist_cavs_9)
5992 unsigned char src_str[10000];
5993 unsigned char hash_str[10000];
5994 unsigned char output[100];
5998 memset(md_name, 0x00, 100);
5999 memset(src_str, 0x00, 10000);
6000 memset(hash_str, 0x00, 10000);
6001 memset(output, 0x00, 100);
6003 strncpy( (
char *) md_name,
"sha1", 100 );
6005 fct_chk( md_info != NULL );
6007 src_len =
unhexify( src_str,
"0f865f46a8f3aed2da18482aa09a8f390dc9da07d51d1bd10fe0bf5f3928d5927d08733d32075535a6d1c8ac1b2dc6ba0f2f633dc1af68e3f0fa3d85e6c60cb7b56c239dc1519a007ea536a07b518ecca02a6c31b46b76f021620ef3fc6976804018380e5ab9c558ebfc5cb1c9ed2d974722bf8ab6398f1f2b82fa5083f85c16a5767a3a07271d67743f00850ce8ec428c7f22f1cf01f99895c0c844845b06a06cecb0c6cf83eb55a1d4ebc44c2c13f6f7aa5e0e08abfd84e7864279057abc471ee4a45dbbb5774afa24e51791a0eada11093b88681fe30baa3b2e94113dc63342c51ca5d1a6096d0897b626e42cb91761058008f746f35465465540ad8c6b8b60f7e1461b3ce9e6529625984cb8c7d46f07f735be067588a0117f23e34ff57800e2bbe9a1605fde6087fb15d22c5d3ac47566b8c448b0cee40373e5ba6eaa21abee71366afbb27dbbd300477d70c371e7b8963812f5ed4fb784fb2f3bd1d3afe883cdd47ef32beaea" );
6008 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6012 fct_chk( strcmp( (
char *) hash_str,
"6692a71d73e00f27df976bc56df4970650d90e45" ) == 0 );
6017 #ifdef POLARSSL_SHA1_C
6019 FCT_TEST_BGN(generic_sha_1_test_vector_nist_cavs_10)
6022 unsigned char src_str[10000];
6023 unsigned char hash_str[10000];
6024 unsigned char output[100];
6028 memset(md_name, 0x00, 100);
6029 memset(src_str, 0x00, 10000);
6030 memset(hash_str, 0x00, 10000);
6031 memset(output, 0x00, 100);
6033 strncpy( (
char *) md_name,
"sha1", 100 );
6035 fct_chk( md_info != NULL );
6037 src_len =
unhexify( src_str,
"8236153781bd2f1b81ffe0def1beb46f5a70191142926651503f1b3bb1016acdb9e7f7acced8dd168226f118ff664a01a8800116fd023587bfba52a2558393476f5fc69ce9c65001f23e70476d2cc81c97ea19caeb194e224339bcb23f77a83feac5096f9b3090c51a6ee6d204b735aa71d7e996d380b80822e4dfd43683af9c7442498cacbea64842dfda238cb099927c6efae07fdf7b23a4e4456e0152b24853fe0d5de4179974b2b9d4a1cdbefcbc01d8d311b5dda059136176ea698ab82acf20dd490be47130b1235cb48f8a6710473cfc923e222d94b582f9ae36d4ca2a32d141b8e8cc36638845fbc499bce17698c3fecae2572dbbd470552430d7ef30c238c2124478f1f780483839b4fb73d63a9460206824a5b6b65315b21e3c2f24c97ee7c0e78faad3df549c7ca8ef241876d9aafe9a309f6da352bec2caaa92ee8dca392899ba67dfed90aef33d41fc2494b765cb3e2422c8e595dabbfaca217757453fb322a13203f425f6073a9903e2dc5818ee1da737afc345f0057744e3a56e1681c949eb12273a3bfc20699e423b96e44bd1ff62e50a848a890809bfe1611c6787d3d741103308f849a790f9c015098286dbacfc34c1718b2c2b77e32194a75dda37954a320fa68764027852855a7e5b5274eb1e2cbcd27161d98b59ad245822015f48af82a45c0ed59be94f9af03d9736048570d6e3ef63b1770bc98dfb77de84b1bb1708d872b625d9ab9b06c18e5dbbf34399391f0f8aa26ec0dac7ff4cb8ec97b52bcb942fa6db2385dcd1b3b9d567aaeb425d567b0ebe267235651a1ed9bf78fd93d3c1dd077fe340bb04b00529c58f45124b717c168d07e9826e33376988bc5cf62845c2009980a4dfa69fbc7e5a0b1bb20a5958ca967aec68eb31dd8fccca9afcd30a26bab26279f1bf6724ff" );
6038 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6042 fct_chk( strcmp( (
char *) hash_str,
"11863b483809ef88413ca9b0084ac4a5390640af" ) == 0 );
6047 #ifdef POLARSSL_SHA2_C
6049 FCT_TEST_BGN(generic_sha_224_test_vector_nist_cavs_1)
6052 unsigned char src_str[10000];
6053 unsigned char hash_str[10000];
6054 unsigned char output[100];
6058 memset(md_name, 0x00, 100);
6059 memset(src_str, 0x00, 10000);
6060 memset(hash_str, 0x00, 10000);
6061 memset(output, 0x00, 100);
6063 strncpy( (
char *) md_name,
"sha224", 100 );
6065 fct_chk( md_info != NULL );
6068 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6072 fct_chk( strcmp( (
char *) hash_str,
"d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f" ) == 0 );
6077 #ifdef POLARSSL_SHA2_C
6079 FCT_TEST_BGN(generic_sha_224_test_vector_nist_cavs_2)
6082 unsigned char src_str[10000];
6083 unsigned char hash_str[10000];
6084 unsigned char output[100];
6088 memset(md_name, 0x00, 100);
6089 memset(src_str, 0x00, 10000);
6090 memset(hash_str, 0x00, 10000);
6091 memset(output, 0x00, 100);
6093 strncpy( (
char *) md_name,
"sha224", 100 );
6095 fct_chk( md_info != NULL );
6097 src_len =
unhexify( src_str,
"ff" );
6098 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6102 fct_chk( strcmp( (
char *) hash_str,
"e33f9d75e6ae1369dbabf81b96b4591ae46bba30b591a6b6c62542b5" ) == 0 );
6107 #ifdef POLARSSL_SHA2_C
6109 FCT_TEST_BGN(generic_sha_224_test_vector_nist_cavs_3)
6112 unsigned char src_str[10000];
6113 unsigned char hash_str[10000];
6114 unsigned char output[100];
6118 memset(md_name, 0x00, 100);
6119 memset(src_str, 0x00, 10000);
6120 memset(hash_str, 0x00, 10000);
6121 memset(output, 0x00, 100);
6123 strncpy( (
char *) md_name,
"sha224", 100 );
6125 fct_chk( md_info != NULL );
6127 src_len =
unhexify( src_str,
"984c" );
6128 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6132 fct_chk( strcmp( (
char *) hash_str,
"2fa9df9157d9e027cfbc4c6a9df32e1adc0cbe2328ec2a63c5ae934e" ) == 0 );
6137 #ifdef POLARSSL_SHA2_C
6139 FCT_TEST_BGN(generic_sha_224_test_vector_nist_cavs_4)
6142 unsigned char src_str[10000];
6143 unsigned char hash_str[10000];
6144 unsigned char output[100];
6148 memset(md_name, 0x00, 100);
6149 memset(src_str, 0x00, 10000);
6150 memset(hash_str, 0x00, 10000);
6151 memset(output, 0x00, 100);
6153 strncpy( (
char *) md_name,
"sha224", 100 );
6155 fct_chk( md_info != NULL );
6157 src_len =
unhexify( src_str,
"50efd0" );
6158 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6162 fct_chk( strcmp( (
char *) hash_str,
"b5a9820413c2bf8211fbbf5df1337043b32fa4eafaf61a0c8e9ccede" ) == 0 );
6167 #ifdef POLARSSL_SHA2_C
6169 FCT_TEST_BGN(generic_sha_224_test_vector_nist_cavs_5)
6172 unsigned char src_str[10000];
6173 unsigned char hash_str[10000];
6174 unsigned char output[100];
6178 memset(md_name, 0x00, 100);
6179 memset(src_str, 0x00, 10000);
6180 memset(hash_str, 0x00, 10000);
6181 memset(output, 0x00, 100);
6183 strncpy( (
char *) md_name,
"sha224", 100 );
6185 fct_chk( md_info != NULL );
6187 src_len =
unhexify( src_str,
"e5e09924" );
6188 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6192 fct_chk( strcmp( (
char *) hash_str,
"fd19e74690d291467ce59f077df311638f1c3a46e510d0e49a67062d" ) == 0 );
6197 #ifdef POLARSSL_SHA2_C
6199 FCT_TEST_BGN(generic_sha_224_test_vector_nist_cavs_6)
6202 unsigned char src_str[10000];
6203 unsigned char hash_str[10000];
6204 unsigned char output[100];
6208 memset(md_name, 0x00, 100);
6209 memset(src_str, 0x00, 10000);
6210 memset(hash_str, 0x00, 10000);
6211 memset(output, 0x00, 100);
6213 strncpy( (
char *) md_name,
"sha224", 100 );
6215 fct_chk( md_info != NULL );
6217 src_len =
unhexify( src_str,
"21ebecb914" );
6218 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6222 fct_chk( strcmp( (
char *) hash_str,
"78f4a71c21c694499ce1c7866611b14ace70d905012c356323c7c713" ) == 0 );
6227 #ifdef POLARSSL_SHA2_C
6229 FCT_TEST_BGN(generic_sha_224_test_vector_nist_cavs_7)
6232 unsigned char src_str[10000];
6233 unsigned char hash_str[10000];
6234 unsigned char output[100];
6238 memset(md_name, 0x00, 100);
6239 memset(src_str, 0x00, 10000);
6240 memset(hash_str, 0x00, 10000);
6241 memset(output, 0x00, 100);
6243 strncpy( (
char *) md_name,
"sha224", 100 );
6245 fct_chk( md_info != NULL );
6247 src_len =
unhexify( src_str,
"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" );
6248 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6252 fct_chk( strcmp( (
char *) hash_str,
"1302149d1e197c41813b054c942329d420e366530f5517b470e964fe" ) == 0 );
6257 #ifdef POLARSSL_SHA2_C
6259 FCT_TEST_BGN(generic_sha_256_test_vector_nist_cavs_1)
6262 unsigned char src_str[10000];
6263 unsigned char hash_str[10000];
6264 unsigned char output[100];
6268 memset(md_name, 0x00, 100);
6269 memset(src_str, 0x00, 10000);
6270 memset(hash_str, 0x00, 10000);
6271 memset(output, 0x00, 100);
6273 strncpy( (
char *) md_name,
"sha256", 100 );
6275 fct_chk( md_info != NULL );
6278 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6282 fct_chk( strcmp( (
char *) hash_str,
"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" ) == 0 );
6287 #ifdef POLARSSL_SHA2_C
6289 FCT_TEST_BGN(generic_sha_256_test_vector_nist_cavs_2)
6292 unsigned char src_str[10000];
6293 unsigned char hash_str[10000];
6294 unsigned char output[100];
6298 memset(md_name, 0x00, 100);
6299 memset(src_str, 0x00, 10000);
6300 memset(hash_str, 0x00, 10000);
6301 memset(output, 0x00, 100);
6303 strncpy( (
char *) md_name,
"sha256", 100 );
6305 fct_chk( md_info != NULL );
6307 src_len =
unhexify( src_str,
"bd" );
6308 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6312 fct_chk( strcmp( (
char *) hash_str,
"68325720aabd7c82f30f554b313d0570c95accbb7dc4b5aae11204c08ffe732b" ) == 0 );
6317 #ifdef POLARSSL_SHA2_C
6319 FCT_TEST_BGN(generic_sha_256_test_vector_nist_cavs_3)
6322 unsigned char src_str[10000];
6323 unsigned char hash_str[10000];
6324 unsigned char output[100];
6328 memset(md_name, 0x00, 100);
6329 memset(src_str, 0x00, 10000);
6330 memset(hash_str, 0x00, 10000);
6331 memset(output, 0x00, 100);
6333 strncpy( (
char *) md_name,
"sha256", 100 );
6335 fct_chk( md_info != NULL );
6337 src_len =
unhexify( src_str,
"5fd4" );
6338 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6342 fct_chk( strcmp( (
char *) hash_str,
"7c4fbf484498d21b487b9d61de8914b2eadaf2698712936d47c3ada2558f6788" ) == 0 );
6347 #ifdef POLARSSL_SHA2_C
6349 FCT_TEST_BGN(generic_sha_256_test_vector_nist_cavs_4)
6352 unsigned char src_str[10000];
6353 unsigned char hash_str[10000];
6354 unsigned char output[100];
6358 memset(md_name, 0x00, 100);
6359 memset(src_str, 0x00, 10000);
6360 memset(hash_str, 0x00, 10000);
6361 memset(output, 0x00, 100);
6363 strncpy( (
char *) md_name,
"sha256", 100 );
6365 fct_chk( md_info != NULL );
6367 src_len =
unhexify( src_str,
"b0bd69" );
6368 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6372 fct_chk( strcmp( (
char *) hash_str,
"4096804221093ddccfbf46831490ea63e9e99414858f8d75ff7f642c7ca61803" ) == 0 );
6377 #ifdef POLARSSL_SHA2_C
6379 FCT_TEST_BGN(generic_sha_256_test_vector_nist_cavs_5)
6382 unsigned char src_str[10000];
6383 unsigned char hash_str[10000];
6384 unsigned char output[100];
6388 memset(md_name, 0x00, 100);
6389 memset(src_str, 0x00, 10000);
6390 memset(hash_str, 0x00, 10000);
6391 memset(output, 0x00, 100);
6393 strncpy( (
char *) md_name,
"sha256", 100 );
6395 fct_chk( md_info != NULL );
6397 src_len =
unhexify( src_str,
"c98c8e55" );
6398 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6402 fct_chk( strcmp( (
char *) hash_str,
"7abc22c0ae5af26ce93dbb94433a0e0b2e119d014f8e7f65bd56c61ccccd9504" ) == 0 );
6407 #ifdef POLARSSL_SHA2_C
6409 FCT_TEST_BGN(generic_sha_256_test_vector_nist_cavs_6)
6412 unsigned char src_str[10000];
6413 unsigned char hash_str[10000];
6414 unsigned char output[100];
6418 memset(md_name, 0x00, 100);
6419 memset(src_str, 0x00, 10000);
6420 memset(hash_str, 0x00, 10000);
6421 memset(output, 0x00, 100);
6423 strncpy( (
char *) md_name,
"sha256", 100 );
6425 fct_chk( md_info != NULL );
6427 src_len =
unhexify( src_str,
"81a723d966" );
6428 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6432 fct_chk( strcmp( (
char *) hash_str,
"7516fb8bb11350df2bf386bc3c33bd0f52cb4c67c6e4745e0488e62c2aea2605" ) == 0 );
6437 #ifdef POLARSSL_SHA2_C
6439 FCT_TEST_BGN(generic_sha_256_test_vector_nist_cavs_7)
6442 unsigned char src_str[10000];
6443 unsigned char hash_str[10000];
6444 unsigned char output[100];
6448 memset(md_name, 0x00, 100);
6449 memset(src_str, 0x00, 10000);
6450 memset(hash_str, 0x00, 10000);
6451 memset(output, 0x00, 100);
6453 strncpy( (
char *) md_name,
"sha256", 100 );
6455 fct_chk( md_info != NULL );
6457 src_len =
unhexify( src_str,
"8390cf0be07661cc7669aac54ce09a37733a629d45f5d983ef201f9b2d13800e555d9b1097fec3b783d7a50dcb5e2b644b96a1e9463f177cf34906bf388f366db5c2deee04a30e283f764a97c3b377a034fefc22c259214faa99babaff160ab0aaa7e2ccb0ce09c6b32fe08cbc474694375aba703fadbfa31cf685b30a11c57f3cf4edd321e57d3ae6ebb1133c8260e75b9224fa47a2bb205249add2e2e62f817491482ae152322be0900355cdcc8d42a98f82e961a0dc6f537b7b410eff105f59673bfb787bf042aa071f7af68d944d27371c64160fe9382772372516c230c1f45c0d6b6cca7f274b394da9402d3eafdf733994ec58ab22d71829a98399574d4b5908a447a5a681cb0dd50a31145311d92c22a16de1ead66a5499f2dceb4cae694772ce90762ef8336afec653aa9b1a1c4820b221136dfce80dce2ba920d88a530c9410d0a4e0358a3a11052e58dd73b0b179ef8f56fe3b5a2d117a73a0c38a1392b6938e9782e0d86456ee4884e3c39d4d75813f13633bc79baa07c0d2d555afbf207f52b7dca126d015aa2b9873b3eb065e90b9b065a5373fe1fb1b20d594327d19fba56cb81e7b6696605ffa56eba3c27a438697cc21b201fd7e09f18deea1b3ea2f0d1edc02df0e20396a145412cd6b13c32d2e605641c948b714aec30c0649dc44143511f35ab0fd5dd64c34d06fe86f3836dfe9edeb7f08cfc3bd40956826356242191f99f53473f32b0cc0cf9321d6c92a112e8db90b86ee9e87cc32d0343db01e32ce9eb782cb24efbbbeb440fe929e8f2bf8dfb1550a3a2e742e8b455a3e5730e9e6a7a9824d17acc0f72a7f67eae0f0970f8bde46dcdefaed3047cf807e7f00a42e5fd11d40f5e98533d7574425b7d2bc3b3845c443008b58980e768e464e17cc6f6b3939eee52f713963d07d8c4abf02448ef0b889c9671e2f8a436ddeeffcca7176e9bf9d1005ecd377f2fa67c23ed1f137e60bf46018a8bd613d038e883704fc26e798969df35ec7bbc6a4fe46d8910bd82fa3cded265d0a3b6d399e4251e4d8233daa21b5812fded6536198ff13aa5a1cd46a5b9a17a4ddc1d9f85544d1d1cc16f3df858038c8e071a11a7e157a85a6a8dc47e88d75e7009a8b26fdb73f33a2a70f1e0c259f8f9533b9b8f9af9288b7274f21baeec78d396f8bacdcc22471207d9b4efccd3fedc5c5a2214ff5e51c553f35e21ae696fe51e8df733a8e06f50f419e599e9f9e4b37ce643fc810faaa47989771509d69a110ac916261427026369a21263ac4460fb4f708f8ae28599856db7cb6a43ac8e03d64a9609807e76c5f312b9d1863bfa304e8953647648b4f4ab0ed995e" );
6458 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6462 fct_chk( strcmp( (
char *) hash_str,
"4109cdbec3240ad74cc6c37f39300f70fede16e21efc77f7865998714aad0b5e" ) == 0 );
6467 #ifdef POLARSSL_SHA4_C
6469 FCT_TEST_BGN(generic_sha_384_test_vector_nist_cavs_1)
6472 unsigned char src_str[10000];
6473 unsigned char hash_str[10000];
6474 unsigned char output[100];
6478 memset(md_name, 0x00, 100);
6479 memset(src_str, 0x00, 10000);
6480 memset(hash_str, 0x00, 10000);
6481 memset(output, 0x00, 100);
6483 strncpy( (
char *) md_name,
"sha384", 100 );
6485 fct_chk( md_info != NULL );
6488 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6492 fct_chk( strcmp( (
char *) hash_str,
"38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b" ) == 0 );
6497 #ifdef POLARSSL_SHA4_C
6499 FCT_TEST_BGN(generic_sha_384_test_vector_nist_cavs_2)
6502 unsigned char src_str[10000];
6503 unsigned char hash_str[10000];
6504 unsigned char output[100];
6508 memset(md_name, 0x00, 100);
6509 memset(src_str, 0x00, 10000);
6510 memset(hash_str, 0x00, 10000);
6511 memset(output, 0x00, 100);
6513 strncpy( (
char *) md_name,
"sha384", 100 );
6515 fct_chk( md_info != NULL );
6517 src_len =
unhexify( src_str,
"ab" );
6518 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6522 fct_chk( strcmp( (
char *) hash_str,
"fb94d5be118865f6fcbc978b825da82cff188faec2f66cb84b2537d74b4938469854b0ca89e66fa2e182834736629f3d" ) == 0 );
6527 #ifdef POLARSSL_SHA4_C
6529 FCT_TEST_BGN(generic_sha_384_test_vector_nist_cavs_3)
6532 unsigned char src_str[10000];
6533 unsigned char hash_str[10000];
6534 unsigned char output[100];
6538 memset(md_name, 0x00, 100);
6539 memset(src_str, 0x00, 10000);
6540 memset(hash_str, 0x00, 10000);
6541 memset(output, 0x00, 100);
6543 strncpy( (
char *) md_name,
"sha384", 100 );
6545 fct_chk( md_info != NULL );
6547 src_len =
unhexify( src_str,
"7c27" );
6548 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6552 fct_chk( strcmp( (
char *) hash_str,
"3d80be467df86d63abb9ea1d3f9cb39cd19890e7f2c53a6200bedc5006842b35e820dc4e0ca90ca9b97ab23ef07080fc" ) == 0 );
6557 #ifdef POLARSSL_SHA4_C
6559 FCT_TEST_BGN(generic_sha_384_test_vector_nist_cavs_4)
6562 unsigned char src_str[10000];
6563 unsigned char hash_str[10000];
6564 unsigned char output[100];
6568 memset(md_name, 0x00, 100);
6569 memset(src_str, 0x00, 10000);
6570 memset(hash_str, 0x00, 10000);
6571 memset(output, 0x00, 100);
6573 strncpy( (
char *) md_name,
"sha384", 100 );
6575 fct_chk( md_info != NULL );
6577 src_len =
unhexify( src_str,
"31f5ca" );
6578 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6582 fct_chk( strcmp( (
char *) hash_str,
"78d54b943421fdf7ba90a7fb9637c2073aa480454bd841d39ff72f4511fc21fb67797b652c0c823229342873d3bef955" ) == 0 );
6587 #ifdef POLARSSL_SHA4_C
6589 FCT_TEST_BGN(generic_sha_384_test_vector_nist_cavs_5)
6592 unsigned char src_str[10000];
6593 unsigned char hash_str[10000];
6594 unsigned char output[100];
6598 memset(md_name, 0x00, 100);
6599 memset(src_str, 0x00, 10000);
6600 memset(hash_str, 0x00, 10000);
6601 memset(output, 0x00, 100);
6603 strncpy( (
char *) md_name,
"sha384", 100 );
6605 fct_chk( md_info != NULL );
6607 src_len =
unhexify( src_str,
"7bdee3f8" );
6608 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6612 fct_chk( strcmp( (
char *) hash_str,
"8bdafba0777ee446c3431c2d7b1fbb631089f71d2ca417abc1d230e1aba64ec2f1c187474a6f4077d372c14ad407f99a" ) == 0 );
6617 #ifdef POLARSSL_SHA4_C
6619 FCT_TEST_BGN(generic_sha_384_test_vector_nist_cavs_6)
6622 unsigned char src_str[10000];
6623 unsigned char hash_str[10000];
6624 unsigned char output[100];
6628 memset(md_name, 0x00, 100);
6629 memset(src_str, 0x00, 10000);
6630 memset(hash_str, 0x00, 10000);
6631 memset(output, 0x00, 100);
6633 strncpy( (
char *) md_name,
"sha384", 100 );
6635 fct_chk( md_info != NULL );
6637 src_len =
unhexify( src_str,
"8f05604915" );
6638 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6642 fct_chk( strcmp( (
char *) hash_str,
"504e414bf1db1060f14c8c799e25b1e0c4dcf1504ebbd129998f0ae283e6de86e0d3c7e879c73ec3b1836c3ee89c2649" ) == 0 );
6647 #ifdef POLARSSL_SHA4_C
6649 FCT_TEST_BGN(generic_sha_384_test_vector_nist_cavs_7)
6652 unsigned char src_str[10000];
6653 unsigned char hash_str[10000];
6654 unsigned char output[100];
6658 memset(md_name, 0x00, 100);
6659 memset(src_str, 0x00, 10000);
6660 memset(hash_str, 0x00, 10000);
6661 memset(output, 0x00, 100);
6663 strncpy( (
char *) md_name,
"sha384", 100 );
6665 fct_chk( md_info != NULL );
6667 src_len =
unhexify( src_str,
"665da6eda214" );
6668 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6672 fct_chk( strcmp( (
char *) hash_str,
"4c022f112010908848312f8b8f1072625fd5c105399d562ea1d56130619a7eac8dfc3748fd05ee37e4b690be9daa9980" ) == 0 );
6677 #ifdef POLARSSL_SHA4_C
6679 FCT_TEST_BGN(generic_sha_384_test_vector_nist_cavs_8)
6682 unsigned char src_str[10000];
6683 unsigned char hash_str[10000];
6684 unsigned char output[100];
6688 memset(md_name, 0x00, 100);
6689 memset(src_str, 0x00, 10000);
6690 memset(hash_str, 0x00, 10000);
6691 memset(output, 0x00, 100);
6693 strncpy( (
char *) md_name,
"sha384", 100 );
6695 fct_chk( md_info != NULL );
6697 src_len =
unhexify( src_str,
"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" );
6698 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6702 fct_chk( strcmp( (
char *) hash_str,
"cba9e3eb12a6f83db11e8a6ff40d1049854ee094416bc527fea931d8585428a8ed6242ce81f6769b36e2123a5c23483e" ) == 0 );
6707 #ifdef POLARSSL_SHA4_C
6709 FCT_TEST_BGN(generic_sha_512_test_vector_nist_cavs_1)
6712 unsigned char src_str[10000];
6713 unsigned char hash_str[10000];
6714 unsigned char output[100];
6718 memset(md_name, 0x00, 100);
6719 memset(src_str, 0x00, 10000);
6720 memset(hash_str, 0x00, 10000);
6721 memset(output, 0x00, 100);
6723 strncpy( (
char *) md_name,
"sha512", 100 );
6725 fct_chk( md_info != NULL );
6728 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6732 fct_chk( strcmp( (
char *) hash_str,
"cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e" ) == 0 );
6737 #ifdef POLARSSL_SHA4_C
6739 FCT_TEST_BGN(generic_sha_512_test_vector_nist_cavs_2)
6742 unsigned char src_str[10000];
6743 unsigned char hash_str[10000];
6744 unsigned char output[100];
6748 memset(md_name, 0x00, 100);
6749 memset(src_str, 0x00, 10000);
6750 memset(hash_str, 0x00, 10000);
6751 memset(output, 0x00, 100);
6753 strncpy( (
char *) md_name,
"sha512", 100 );
6755 fct_chk( md_info != NULL );
6757 src_len =
unhexify( src_str,
"8f" );
6758 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6762 fct_chk( strcmp( (
char *) hash_str,
"e4cd2d19931b5aad9c920f45f56f6ce34e3d38c6d319a6e11d0588ab8b838576d6ce6d68eea7c830de66e2bd96458bfa7aafbcbec981d4ed040498c3dd95f22a" ) == 0 );
6767 #ifdef POLARSSL_SHA4_C
6769 FCT_TEST_BGN(generic_sha_512_test_vector_nist_cavs_3)
6772 unsigned char src_str[10000];
6773 unsigned char hash_str[10000];
6774 unsigned char output[100];
6778 memset(md_name, 0x00, 100);
6779 memset(src_str, 0x00, 10000);
6780 memset(hash_str, 0x00, 10000);
6781 memset(output, 0x00, 100);
6783 strncpy( (
char *) md_name,
"sha512", 100 );
6785 fct_chk( md_info != NULL );
6787 src_len =
unhexify( src_str,
"e724" );
6788 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6792 fct_chk( strcmp( (
char *) hash_str,
"7dbb520221a70287b23dbcf62bfc1b73136d858e86266732a7fffa875ecaa2c1b8f673b5c065d360c563a7b9539349f5f59bef8c0c593f9587e3cd50bb26a231" ) == 0 );
6797 #ifdef POLARSSL_SHA4_C
6799 FCT_TEST_BGN(generic_sha_512_test_vector_nist_cavs_4)
6802 unsigned char src_str[10000];
6803 unsigned char hash_str[10000];
6804 unsigned char output[100];
6808 memset(md_name, 0x00, 100);
6809 memset(src_str, 0x00, 10000);
6810 memset(hash_str, 0x00, 10000);
6811 memset(output, 0x00, 100);
6813 strncpy( (
char *) md_name,
"sha512", 100 );
6815 fct_chk( md_info != NULL );
6817 src_len =
unhexify( src_str,
"de4c90" );
6818 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6822 fct_chk( strcmp( (
char *) hash_str,
"33ce98281045a5c4c9df0363d8196f1d7dfcd5ee46ac89776fd8a4344c12f123a66788af5bd41ceff1941aa5637654b4064c88c14e00465ab79a2fc6c97e1014" ) == 0 );
6827 #ifdef POLARSSL_SHA4_C
6829 FCT_TEST_BGN(generic_sha_512_test_vector_nist_cavs_5)
6832 unsigned char src_str[10000];
6833 unsigned char hash_str[10000];
6834 unsigned char output[100];
6838 memset(md_name, 0x00, 100);
6839 memset(src_str, 0x00, 10000);
6840 memset(hash_str, 0x00, 10000);
6841 memset(output, 0x00, 100);
6843 strncpy( (
char *) md_name,
"sha512", 100 );
6845 fct_chk( md_info != NULL );
6847 src_len =
unhexify( src_str,
"a801e94b" );
6848 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6852 fct_chk( strcmp( (
char *) hash_str,
"dadb1b5a27f9fece8d86adb2a51879beb1787ff28f4e8ce162cad7fee0f942efcabbf738bc6f797fc7cc79a3a75048cd4c82ca0757a324695bfb19a557e56e2f" ) == 0 );
6857 #ifdef POLARSSL_SHA4_C
6859 FCT_TEST_BGN(generic_sha_512_test_vector_nist_cavs_6)
6862 unsigned char src_str[10000];
6863 unsigned char hash_str[10000];
6864 unsigned char output[100];
6868 memset(md_name, 0x00, 100);
6869 memset(src_str, 0x00, 10000);
6870 memset(hash_str, 0x00, 10000);
6871 memset(output, 0x00, 100);
6873 strncpy( (
char *) md_name,
"sha512", 100 );
6875 fct_chk( md_info != NULL );
6877 src_len =
unhexify( src_str,
"94390d3502" );
6878 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6882 fct_chk( strcmp( (
char *) hash_str,
"b6175c4c4cccf69e0ce5f0312010886ea6b34d43673f942ae42483f9cbb7da817de4e11b5d58e25a3d9bd721a22cdffe1c40411cc45df1911fa5506129b69297" ) == 0 );
6887 #ifdef POLARSSL_SHA4_C
6889 FCT_TEST_BGN(generic_sha_512_test_vector_nist_cavs_7)
6892 unsigned char src_str[10000];
6893 unsigned char hash_str[10000];
6894 unsigned char output[100];
6898 memset(md_name, 0x00, 100);
6899 memset(src_str, 0x00, 10000);
6900 memset(hash_str, 0x00, 10000);
6901 memset(output, 0x00, 100);
6903 strncpy( (
char *) md_name,
"sha512", 100 );
6905 fct_chk( md_info != NULL );
6907 src_len =
unhexify( src_str,
"49297dd63e5f" );
6908 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6912 fct_chk( strcmp( (
char *) hash_str,
"1fcc1e6f6870859d11649f5e5336a9cd16329c029baf04d5a6edf257889a2e9522b497dd656bb402da461307c4ee382e2e89380c8e6e6e7697f1e439f650fa94" ) == 0 );
6917 #ifdef POLARSSL_SHA4_C
6919 FCT_TEST_BGN(generic_sha_512_test_vector_nist_cavs_8)
6922 unsigned char src_str[10000];
6923 unsigned char hash_str[10000];
6924 unsigned char output[100];
6928 memset(md_name, 0x00, 100);
6929 memset(src_str, 0x00, 10000);
6930 memset(hash_str, 0x00, 10000);
6931 memset(output, 0x00, 100);
6933 strncpy( (
char *) md_name,
"sha512", 100 );
6935 fct_chk( md_info != NULL );
6937 src_len =
unhexify( src_str,
"990d1ae71a62d7bda9bfdaa1762a68d296eee72a4cd946f287a898fbabc002ea941fd8d4d991030b4d27a637cce501a834bb95eab1b7889a3e784c7968e67cbf552006b206b68f76d9191327524fcc251aeb56af483d10b4e0c6c5e599ee8c0fe4faeca8293844a8547c6a9a90d093f2526873a19ad4a5e776794c68c742fb834793d2dfcb7fea46c63af4b70fd11cb6e41834e72ee40edb067b292a794990c288d5007e73f349fb383af6a756b8301ad6e5e0aa8cd614399bb3a452376b1575afa6bdaeaafc286cb064bb91edef97c632b6c1113d107fa93a0905098a105043c2f05397f702514439a08a9e5ddc196100721d45c8fc17d2ed659376f8a00bd5cb9a0860e26d8a29d8d6aaf52de97e9346033d6db501a35dbbaf97c20b830cd2d18c2532f3a59cc497ee64c0e57d8d060e5069b28d86edf1adcf59144b221ce3ddaef134b3124fbc7dd000240eff0f5f5f41e83cd7f5bb37c9ae21953fe302b0f6e8b68fa91c6ab99265c64b2fd9cd4942be04321bb5d6d71932376c6f2f88e02422ba6a5e2cb765df93fd5dd0728c6abdaf03bce22e0678a544e2c3636f741b6f4447ee58a8fc656b43ef817932176adbfc2e04b2c812c273cd6cbfa4098f0be036a34221fa02643f5ee2e0b38135f2a18ecd2f16ebc45f8eb31b8ab967a1567ee016904188910861ca1fa205c7adaa194b286893ffe2f4fbe0384c2aef72a4522aeafd3ebc71f9db71eeeef86c48394a1c86d5b36c352cc33a0a2c800bc99e62fd65b3a2fd69e0b53996ec13d8ce483ce9319efd9a85acefabdb5342226febb83fd1daf4b24265f50c61c6de74077ef89b6fecf9f29a1f871af1e9f89b2d345cda7499bd45c42fa5d195a1e1a6ba84851889e730da3b2b916e96152ae0c92154b49719841db7e7cc707ba8a5d7b101eb4ac7b629bb327817910fff61580b59aab78182d1a2e33473d05b00b170b29e331870826cfe45af206aa7d0246bbd8566ca7cfb2d3c10bfa1db7dd48dd786036469ce7282093d78b5e1a5b0fc81a54c8ed4ceac1e5305305e78284ac276f5d7862727aff246e17addde50c670028d572cbfc0be2e4f8b2eb28fa68ad7b4c6c2a239c460441bfb5ea049f23b08563b4e47729a59e5986a61a6093dbd54f8c36ebe87edae01f251cb060ad1364ce677d7e8d5a4a4ca966a7241cc360bc2acb280e5f9e9c1b032ad6a180a35e0c5180b9d16d026c865b252098cc1d99ba7375ca31c7702c0d943d5e3dd2f6861fa55bd46d94b67ed3e52eccd8dd06d968e01897d6de97ed3058d91dd" );
6938 fct_chk ( 0 ==
md( md_info, src_str, src_len, output ) );
6942 fct_chk( strcmp( (
char *) hash_str,
"8e4bc6f8b8c60fe4d68c61d9b159c8693c3151c46749af58da228442d927f23359bd6ccd6c2ec8fa3f00a86cecbfa728e1ad60b821ed22fcd309ba91a4138bc9" ) == 0 );
6947 #ifdef POLARSSL_SHA1_C
6949 FCT_TEST_BGN(generic_multi_step_sha_1_test_vector_nist_cavs_1)
6952 unsigned char src_str[10000];
6953 unsigned char hash_str[10000];
6954 unsigned char output[100];
6959 memset(md_name, 0x00, 100);
6960 memset(src_str, 0x00, 10000);
6961 memset(hash_str, 0x00, 10000);
6962 memset(output, 0x00, 100);
6964 strncpy( (
char *) md_name,
"sha1", 100 );
6966 fct_chk( md_info != NULL );
6972 fct_chk ( ctx.
md_ctx != NULL );
6973 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
6974 fct_chk ( 0 ==
md_finish( &ctx, output ) );
6979 fct_chk( strcmp( (
char *) hash_str,
"da39a3ee5e6b4b0d3255bfef95601890afd80709" ) == 0 );
6984 #ifdef POLARSSL_SHA1_C
6986 FCT_TEST_BGN(generic_multi_step_sha_1_test_vector_nist_cavs_2)
6989 unsigned char src_str[10000];
6990 unsigned char hash_str[10000];
6991 unsigned char output[100];
6996 memset(md_name, 0x00, 100);
6997 memset(src_str, 0x00, 10000);
6998 memset(hash_str, 0x00, 10000);
6999 memset(output, 0x00, 100);
7001 strncpy( (
char *) md_name,
"sha1", 100 );
7003 fct_chk( md_info != NULL );
7006 src_len =
unhexify( src_str,
"a8" );
7009 fct_chk ( ctx.
md_ctx != NULL );
7010 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7011 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7016 fct_chk( strcmp( (
char *) hash_str,
"99f2aa95e36f95c2acb0eaf23998f030638f3f15" ) == 0 );
7021 #ifdef POLARSSL_SHA1_C
7023 FCT_TEST_BGN(generic_multi_step_sha_1_test_vector_nist_cavs_3)
7026 unsigned char src_str[10000];
7027 unsigned char hash_str[10000];
7028 unsigned char output[100];
7033 memset(md_name, 0x00, 100);
7034 memset(src_str, 0x00, 10000);
7035 memset(hash_str, 0x00, 10000);
7036 memset(output, 0x00, 100);
7038 strncpy( (
char *) md_name,
"sha1", 100 );
7040 fct_chk( md_info != NULL );
7043 src_len =
unhexify( src_str,
"3000" );
7046 fct_chk ( ctx.
md_ctx != NULL );
7047 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7048 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7053 fct_chk( strcmp( (
char *) hash_str,
"f944dcd635f9801f7ac90a407fbc479964dec024" ) == 0 );
7058 #ifdef POLARSSL_SHA1_C
7060 FCT_TEST_BGN(generic_multi_step_sha_1_test_vector_nist_cavs_4)
7063 unsigned char src_str[10000];
7064 unsigned char hash_str[10000];
7065 unsigned char output[100];
7070 memset(md_name, 0x00, 100);
7071 memset(src_str, 0x00, 10000);
7072 memset(hash_str, 0x00, 10000);
7073 memset(output, 0x00, 100);
7075 strncpy( (
char *) md_name,
"sha1", 100 );
7077 fct_chk( md_info != NULL );
7080 src_len =
unhexify( src_str,
"42749e" );
7083 fct_chk ( ctx.
md_ctx != NULL );
7084 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7085 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7090 fct_chk( strcmp( (
char *) hash_str,
"a444319e9b6cc1e8464c511ec0969c37d6bb2619" ) == 0 );
7095 #ifdef POLARSSL_SHA1_C
7097 FCT_TEST_BGN(generic_multi_step_sha_1_test_vector_nist_cavs_5)
7100 unsigned char src_str[10000];
7101 unsigned char hash_str[10000];
7102 unsigned char output[100];
7107 memset(md_name, 0x00, 100);
7108 memset(src_str, 0x00, 10000);
7109 memset(hash_str, 0x00, 10000);
7110 memset(output, 0x00, 100);
7112 strncpy( (
char *) md_name,
"sha1", 100 );
7114 fct_chk( md_info != NULL );
7117 src_len =
unhexify( src_str,
"9fc3fe08" );
7120 fct_chk ( ctx.
md_ctx != NULL );
7121 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7122 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7127 fct_chk( strcmp( (
char *) hash_str,
"16a0ff84fcc156fd5d3ca3a744f20a232d172253" ) == 0 );
7132 #ifdef POLARSSL_SHA1_C
7134 FCT_TEST_BGN(generic_multi_step_sha_1_test_vector_nist_cavs_6)
7137 unsigned char src_str[10000];
7138 unsigned char hash_str[10000];
7139 unsigned char output[100];
7144 memset(md_name, 0x00, 100);
7145 memset(src_str, 0x00, 10000);
7146 memset(hash_str, 0x00, 10000);
7147 memset(output, 0x00, 100);
7149 strncpy( (
char *) md_name,
"sha1", 100 );
7151 fct_chk( md_info != NULL );
7154 src_len =
unhexify( src_str,
"b5c1c6f1af" );
7157 fct_chk ( ctx.
md_ctx != NULL );
7158 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7159 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7164 fct_chk( strcmp( (
char *) hash_str,
"fec9deebfcdedaf66dda525e1be43597a73a1f93" ) == 0 );
7169 #ifdef POLARSSL_SHA1_C
7171 FCT_TEST_BGN(generic_multi_step_sha_1_test_vector_nist_cavs_7)
7174 unsigned char src_str[10000];
7175 unsigned char hash_str[10000];
7176 unsigned char output[100];
7181 memset(md_name, 0x00, 100);
7182 memset(src_str, 0x00, 10000);
7183 memset(hash_str, 0x00, 10000);
7184 memset(output, 0x00, 100);
7186 strncpy( (
char *) md_name,
"sha1", 100 );
7188 fct_chk( md_info != NULL );
7191 src_len =
unhexify( src_str,
"ec29561244ede706b6eb30a1c371d74450a105c3f9735f7fa9fe38cf67f304a5736a106e92e17139a6813b1c81a4f3d3fb9546ab4296fa9f722826c066869edacd73b2548035185813e22634a9da44000d95a281ff9f264ecce0a931222162d021cca28db5f3c2aa24945ab1e31cb413ae29810fd794cad5dfaf29ec43cb38d198fe4ae1da2359780221405bd6712a5305da4b1b737fce7cd21c0eb7728d08235a9011" );
7194 fct_chk ( ctx.
md_ctx != NULL );
7195 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7196 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7201 fct_chk( strcmp( (
char *) hash_str,
"970111c4e77bcc88cc20459c02b69b4aa8f58217" ) == 0 );
7206 #ifdef POLARSSL_SHA1_C
7208 FCT_TEST_BGN(generic_multi_step_sha_1_test_vector_nist_cavs_8)
7211 unsigned char src_str[10000];
7212 unsigned char hash_str[10000];
7213 unsigned char output[100];
7218 memset(md_name, 0x00, 100);
7219 memset(src_str, 0x00, 10000);
7220 memset(hash_str, 0x00, 10000);
7221 memset(output, 0x00, 100);
7223 strncpy( (
char *) md_name,
"sha1", 100 );
7225 fct_chk( md_info != NULL );
7228 src_len =
unhexify( src_str,
"5fc2c3f6a7e79dc94be526e5166a238899d54927ce470018fbfd668fd9dd97cbf64e2c91584d01da63be3cc9fdff8adfefc3ac728e1e335b9cdc87f069172e323d094b47fa1e652afe4d6aa147a9f46fda33cacb65f3aa12234746b9007a8c85fe982afed7815221e43dba553d8fe8a022cdac1b99eeeea359e5a9d2e72e382dffa6d19f359f4f27dc3434cd27daeeda8e38594873398678065fbb23665aba9309d946135da0e4a4afdadff14db18e85e71dd93c3bf9faf7f25c8194c4269b1ee3d9934097ab990025d9c3aaf63d5109f52335dd3959d38ae485050e4bbb6235574fc0102be8f7a306d6e8de6ba6becf80f37415b57f9898a5824e77414197422be3d36a6080" );
7231 fct_chk ( ctx.
md_ctx != NULL );
7232 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7233 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7238 fct_chk( strcmp( (
char *) hash_str,
"0423dc76a8791107d14e13f5265b343f24cc0f19" ) == 0 );
7243 #ifdef POLARSSL_SHA1_C
7245 FCT_TEST_BGN(generic_multi_step_sha_1_test_vector_nist_cavs_9)
7248 unsigned char src_str[10000];
7249 unsigned char hash_str[10000];
7250 unsigned char output[100];
7255 memset(md_name, 0x00, 100);
7256 memset(src_str, 0x00, 10000);
7257 memset(hash_str, 0x00, 10000);
7258 memset(output, 0x00, 100);
7260 strncpy( (
char *) md_name,
"sha1", 100 );
7262 fct_chk( md_info != NULL );
7265 src_len =
unhexify( src_str,
"0f865f46a8f3aed2da18482aa09a8f390dc9da07d51d1bd10fe0bf5f3928d5927d08733d32075535a6d1c8ac1b2dc6ba0f2f633dc1af68e3f0fa3d85e6c60cb7b56c239dc1519a007ea536a07b518ecca02a6c31b46b76f021620ef3fc6976804018380e5ab9c558ebfc5cb1c9ed2d974722bf8ab6398f1f2b82fa5083f85c16a5767a3a07271d67743f00850ce8ec428c7f22f1cf01f99895c0c844845b06a06cecb0c6cf83eb55a1d4ebc44c2c13f6f7aa5e0e08abfd84e7864279057abc471ee4a45dbbb5774afa24e51791a0eada11093b88681fe30baa3b2e94113dc63342c51ca5d1a6096d0897b626e42cb91761058008f746f35465465540ad8c6b8b60f7e1461b3ce9e6529625984cb8c7d46f07f735be067588a0117f23e34ff57800e2bbe9a1605fde6087fb15d22c5d3ac47566b8c448b0cee40373e5ba6eaa21abee71366afbb27dbbd300477d70c371e7b8963812f5ed4fb784fb2f3bd1d3afe883cdd47ef32beaea" );
7268 fct_chk ( ctx.
md_ctx != NULL );
7269 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7270 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7275 fct_chk( strcmp( (
char *) hash_str,
"6692a71d73e00f27df976bc56df4970650d90e45" ) == 0 );
7280 #ifdef POLARSSL_SHA1_C
7282 FCT_TEST_BGN(generic_multi_step_sha_1_test_vector_nist_cavs_10)
7285 unsigned char src_str[10000];
7286 unsigned char hash_str[10000];
7287 unsigned char output[100];
7292 memset(md_name, 0x00, 100);
7293 memset(src_str, 0x00, 10000);
7294 memset(hash_str, 0x00, 10000);
7295 memset(output, 0x00, 100);
7297 strncpy( (
char *) md_name,
"sha1", 100 );
7299 fct_chk( md_info != NULL );
7302 src_len =
unhexify( src_str,
"8236153781bd2f1b81ffe0def1beb46f5a70191142926651503f1b3bb1016acdb9e7f7acced8dd168226f118ff664a01a8800116fd023587bfba52a2558393476f5fc69ce9c65001f23e70476d2cc81c97ea19caeb194e224339bcb23f77a83feac5096f9b3090c51a6ee6d204b735aa71d7e996d380b80822e4dfd43683af9c7442498cacbea64842dfda238cb099927c6efae07fdf7b23a4e4456e0152b24853fe0d5de4179974b2b9d4a1cdbefcbc01d8d311b5dda059136176ea698ab82acf20dd490be47130b1235cb48f8a6710473cfc923e222d94b582f9ae36d4ca2a32d141b8e8cc36638845fbc499bce17698c3fecae2572dbbd470552430d7ef30c238c2124478f1f780483839b4fb73d63a9460206824a5b6b65315b21e3c2f24c97ee7c0e78faad3df549c7ca8ef241876d9aafe9a309f6da352bec2caaa92ee8dca392899ba67dfed90aef33d41fc2494b765cb3e2422c8e595dabbfaca217757453fb322a13203f425f6073a9903e2dc5818ee1da737afc345f0057744e3a56e1681c949eb12273a3bfc20699e423b96e44bd1ff62e50a848a890809bfe1611c6787d3d741103308f849a790f9c015098286dbacfc34c1718b2c2b77e32194a75dda37954a320fa68764027852855a7e5b5274eb1e2cbcd27161d98b59ad245822015f48af82a45c0ed59be94f9af03d9736048570d6e3ef63b1770bc98dfb77de84b1bb1708d872b625d9ab9b06c18e5dbbf34399391f0f8aa26ec0dac7ff4cb8ec97b52bcb942fa6db2385dcd1b3b9d567aaeb425d567b0ebe267235651a1ed9bf78fd93d3c1dd077fe340bb04b00529c58f45124b717c168d07e9826e33376988bc5cf62845c2009980a4dfa69fbc7e5a0b1bb20a5958ca967aec68eb31dd8fccca9afcd30a26bab26279f1bf6724ff" );
7305 fct_chk ( ctx.
md_ctx != NULL );
7306 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7307 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7312 fct_chk( strcmp( (
char *) hash_str,
"11863b483809ef88413ca9b0084ac4a5390640af" ) == 0 );
7317 #ifdef POLARSSL_SHA2_C
7319 FCT_TEST_BGN(generic_multi_step_sha_224_test_vector_nist_cavs_1)
7322 unsigned char src_str[10000];
7323 unsigned char hash_str[10000];
7324 unsigned char output[100];
7329 memset(md_name, 0x00, 100);
7330 memset(src_str, 0x00, 10000);
7331 memset(hash_str, 0x00, 10000);
7332 memset(output, 0x00, 100);
7334 strncpy( (
char *) md_name,
"sha224", 100 );
7336 fct_chk( md_info != NULL );
7342 fct_chk ( ctx.
md_ctx != NULL );
7343 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7344 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7349 fct_chk( strcmp( (
char *) hash_str,
"d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f" ) == 0 );
7354 #ifdef POLARSSL_SHA2_C
7356 FCT_TEST_BGN(generic_multi_step_sha_224_test_vector_nist_cavs_2)
7359 unsigned char src_str[10000];
7360 unsigned char hash_str[10000];
7361 unsigned char output[100];
7366 memset(md_name, 0x00, 100);
7367 memset(src_str, 0x00, 10000);
7368 memset(hash_str, 0x00, 10000);
7369 memset(output, 0x00, 100);
7371 strncpy( (
char *) md_name,
"sha224", 100 );
7373 fct_chk( md_info != NULL );
7376 src_len =
unhexify( src_str,
"ff" );
7379 fct_chk ( ctx.
md_ctx != NULL );
7380 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7381 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7386 fct_chk( strcmp( (
char *) hash_str,
"e33f9d75e6ae1369dbabf81b96b4591ae46bba30b591a6b6c62542b5" ) == 0 );
7391 #ifdef POLARSSL_SHA2_C
7393 FCT_TEST_BGN(generic_multi_step_sha_224_test_vector_nist_cavs_3)
7396 unsigned char src_str[10000];
7397 unsigned char hash_str[10000];
7398 unsigned char output[100];
7403 memset(md_name, 0x00, 100);
7404 memset(src_str, 0x00, 10000);
7405 memset(hash_str, 0x00, 10000);
7406 memset(output, 0x00, 100);
7408 strncpy( (
char *) md_name,
"sha224", 100 );
7410 fct_chk( md_info != NULL );
7413 src_len =
unhexify( src_str,
"984c" );
7416 fct_chk ( ctx.
md_ctx != NULL );
7417 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7418 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7423 fct_chk( strcmp( (
char *) hash_str,
"2fa9df9157d9e027cfbc4c6a9df32e1adc0cbe2328ec2a63c5ae934e" ) == 0 );
7428 #ifdef POLARSSL_SHA2_C
7430 FCT_TEST_BGN(generic_multi_step_sha_224_test_vector_nist_cavs_4)
7433 unsigned char src_str[10000];
7434 unsigned char hash_str[10000];
7435 unsigned char output[100];
7440 memset(md_name, 0x00, 100);
7441 memset(src_str, 0x00, 10000);
7442 memset(hash_str, 0x00, 10000);
7443 memset(output, 0x00, 100);
7445 strncpy( (
char *) md_name,
"sha224", 100 );
7447 fct_chk( md_info != NULL );
7450 src_len =
unhexify( src_str,
"50efd0" );
7453 fct_chk ( ctx.
md_ctx != NULL );
7454 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7455 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7460 fct_chk( strcmp( (
char *) hash_str,
"b5a9820413c2bf8211fbbf5df1337043b32fa4eafaf61a0c8e9ccede" ) == 0 );
7465 #ifdef POLARSSL_SHA2_C
7467 FCT_TEST_BGN(generic_multi_step_sha_224_test_vector_nist_cavs_5)
7470 unsigned char src_str[10000];
7471 unsigned char hash_str[10000];
7472 unsigned char output[100];
7477 memset(md_name, 0x00, 100);
7478 memset(src_str, 0x00, 10000);
7479 memset(hash_str, 0x00, 10000);
7480 memset(output, 0x00, 100);
7482 strncpy( (
char *) md_name,
"sha224", 100 );
7484 fct_chk( md_info != NULL );
7487 src_len =
unhexify( src_str,
"e5e09924" );
7490 fct_chk ( ctx.
md_ctx != NULL );
7491 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7492 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7497 fct_chk( strcmp( (
char *) hash_str,
"fd19e74690d291467ce59f077df311638f1c3a46e510d0e49a67062d" ) == 0 );
7502 #ifdef POLARSSL_SHA2_C
7504 FCT_TEST_BGN(generic_multi_step_sha_224_test_vector_nist_cavs_6)
7507 unsigned char src_str[10000];
7508 unsigned char hash_str[10000];
7509 unsigned char output[100];
7514 memset(md_name, 0x00, 100);
7515 memset(src_str, 0x00, 10000);
7516 memset(hash_str, 0x00, 10000);
7517 memset(output, 0x00, 100);
7519 strncpy( (
char *) md_name,
"sha224", 100 );
7521 fct_chk( md_info != NULL );
7524 src_len =
unhexify( src_str,
"21ebecb914" );
7527 fct_chk ( ctx.
md_ctx != NULL );
7528 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7529 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7534 fct_chk( strcmp( (
char *) hash_str,
"78f4a71c21c694499ce1c7866611b14ace70d905012c356323c7c713" ) == 0 );
7539 #ifdef POLARSSL_SHA2_C
7541 FCT_TEST_BGN(generic_multi_step_sha_224_test_vector_nist_cavs_7)
7544 unsigned char src_str[10000];
7545 unsigned char hash_str[10000];
7546 unsigned char output[100];
7551 memset(md_name, 0x00, 100);
7552 memset(src_str, 0x00, 10000);
7553 memset(hash_str, 0x00, 10000);
7554 memset(output, 0x00, 100);
7556 strncpy( (
char *) md_name,
"sha224", 100 );
7558 fct_chk( md_info != NULL );
7561 src_len =
unhexify( src_str,
"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" );
7564 fct_chk ( ctx.
md_ctx != NULL );
7565 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7566 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7571 fct_chk( strcmp( (
char *) hash_str,
"1302149d1e197c41813b054c942329d420e366530f5517b470e964fe" ) == 0 );
7576 #ifdef POLARSSL_SHA2_C
7578 FCT_TEST_BGN(generic_multi_step_sha_256_test_vector_nist_cavs_1)
7581 unsigned char src_str[10000];
7582 unsigned char hash_str[10000];
7583 unsigned char output[100];
7588 memset(md_name, 0x00, 100);
7589 memset(src_str, 0x00, 10000);
7590 memset(hash_str, 0x00, 10000);
7591 memset(output, 0x00, 100);
7593 strncpy( (
char *) md_name,
"sha256", 100 );
7595 fct_chk( md_info != NULL );
7601 fct_chk ( ctx.
md_ctx != NULL );
7602 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7603 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7608 fct_chk( strcmp( (
char *) hash_str,
"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" ) == 0 );
7613 #ifdef POLARSSL_SHA2_C
7615 FCT_TEST_BGN(generic_multi_step_sha_256_test_vector_nist_cavs_2)
7618 unsigned char src_str[10000];
7619 unsigned char hash_str[10000];
7620 unsigned char output[100];
7625 memset(md_name, 0x00, 100);
7626 memset(src_str, 0x00, 10000);
7627 memset(hash_str, 0x00, 10000);
7628 memset(output, 0x00, 100);
7630 strncpy( (
char *) md_name,
"sha256", 100 );
7632 fct_chk( md_info != NULL );
7635 src_len =
unhexify( src_str,
"bd" );
7638 fct_chk ( ctx.
md_ctx != NULL );
7639 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7640 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7645 fct_chk( strcmp( (
char *) hash_str,
"68325720aabd7c82f30f554b313d0570c95accbb7dc4b5aae11204c08ffe732b" ) == 0 );
7650 #ifdef POLARSSL_SHA2_C
7652 FCT_TEST_BGN(generic_multi_step_sha_256_test_vector_nist_cavs_3)
7655 unsigned char src_str[10000];
7656 unsigned char hash_str[10000];
7657 unsigned char output[100];
7662 memset(md_name, 0x00, 100);
7663 memset(src_str, 0x00, 10000);
7664 memset(hash_str, 0x00, 10000);
7665 memset(output, 0x00, 100);
7667 strncpy( (
char *) md_name,
"sha256", 100 );
7669 fct_chk( md_info != NULL );
7672 src_len =
unhexify( src_str,
"5fd4" );
7675 fct_chk ( ctx.
md_ctx != NULL );
7676 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7677 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7682 fct_chk( strcmp( (
char *) hash_str,
"7c4fbf484498d21b487b9d61de8914b2eadaf2698712936d47c3ada2558f6788" ) == 0 );
7687 #ifdef POLARSSL_SHA2_C
7689 FCT_TEST_BGN(generic_multi_step_sha_256_test_vector_nist_cavs_4)
7692 unsigned char src_str[10000];
7693 unsigned char hash_str[10000];
7694 unsigned char output[100];
7699 memset(md_name, 0x00, 100);
7700 memset(src_str, 0x00, 10000);
7701 memset(hash_str, 0x00, 10000);
7702 memset(output, 0x00, 100);
7704 strncpy( (
char *) md_name,
"sha256", 100 );
7706 fct_chk( md_info != NULL );
7709 src_len =
unhexify( src_str,
"b0bd69" );
7712 fct_chk ( ctx.
md_ctx != NULL );
7713 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7714 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7719 fct_chk( strcmp( (
char *) hash_str,
"4096804221093ddccfbf46831490ea63e9e99414858f8d75ff7f642c7ca61803" ) == 0 );
7724 #ifdef POLARSSL_SHA2_C
7726 FCT_TEST_BGN(generic_multi_step_sha_256_test_vector_nist_cavs_5)
7729 unsigned char src_str[10000];
7730 unsigned char hash_str[10000];
7731 unsigned char output[100];
7736 memset(md_name, 0x00, 100);
7737 memset(src_str, 0x00, 10000);
7738 memset(hash_str, 0x00, 10000);
7739 memset(output, 0x00, 100);
7741 strncpy( (
char *) md_name,
"sha256", 100 );
7743 fct_chk( md_info != NULL );
7746 src_len =
unhexify( src_str,
"c98c8e55" );
7749 fct_chk ( ctx.
md_ctx != NULL );
7750 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7751 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7756 fct_chk( strcmp( (
char *) hash_str,
"7abc22c0ae5af26ce93dbb94433a0e0b2e119d014f8e7f65bd56c61ccccd9504" ) == 0 );
7761 #ifdef POLARSSL_SHA2_C
7763 FCT_TEST_BGN(generic_multi_step_sha_256_test_vector_nist_cavs_6)
7766 unsigned char src_str[10000];
7767 unsigned char hash_str[10000];
7768 unsigned char output[100];
7773 memset(md_name, 0x00, 100);
7774 memset(src_str, 0x00, 10000);
7775 memset(hash_str, 0x00, 10000);
7776 memset(output, 0x00, 100);
7778 strncpy( (
char *) md_name,
"sha256", 100 );
7780 fct_chk( md_info != NULL );
7783 src_len =
unhexify( src_str,
"81a723d966" );
7786 fct_chk ( ctx.
md_ctx != NULL );
7787 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7788 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7793 fct_chk( strcmp( (
char *) hash_str,
"7516fb8bb11350df2bf386bc3c33bd0f52cb4c67c6e4745e0488e62c2aea2605" ) == 0 );
7798 #ifdef POLARSSL_SHA2_C
7800 FCT_TEST_BGN(generic_multi_step_sha_256_test_vector_nist_cavs_7)
7803 unsigned char src_str[10000];
7804 unsigned char hash_str[10000];
7805 unsigned char output[100];
7810 memset(md_name, 0x00, 100);
7811 memset(src_str, 0x00, 10000);
7812 memset(hash_str, 0x00, 10000);
7813 memset(output, 0x00, 100);
7815 strncpy( (
char *) md_name,
"sha256", 100 );
7817 fct_chk( md_info != NULL );
7820 src_len =
unhexify( src_str,
"8390cf0be07661cc7669aac54ce09a37733a629d45f5d983ef201f9b2d13800e555d9b1097fec3b783d7a50dcb5e2b644b96a1e9463f177cf34906bf388f366db5c2deee04a30e283f764a97c3b377a034fefc22c259214faa99babaff160ab0aaa7e2ccb0ce09c6b32fe08cbc474694375aba703fadbfa31cf685b30a11c57f3cf4edd321e57d3ae6ebb1133c8260e75b9224fa47a2bb205249add2e2e62f817491482ae152322be0900355cdcc8d42a98f82e961a0dc6f537b7b410eff105f59673bfb787bf042aa071f7af68d944d27371c64160fe9382772372516c230c1f45c0d6b6cca7f274b394da9402d3eafdf733994ec58ab22d71829a98399574d4b5908a447a5a681cb0dd50a31145311d92c22a16de1ead66a5499f2dceb4cae694772ce90762ef8336afec653aa9b1a1c4820b221136dfce80dce2ba920d88a530c9410d0a4e0358a3a11052e58dd73b0b179ef8f56fe3b5a2d117a73a0c38a1392b6938e9782e0d86456ee4884e3c39d4d75813f13633bc79baa07c0d2d555afbf207f52b7dca126d015aa2b9873b3eb065e90b9b065a5373fe1fb1b20d594327d19fba56cb81e7b6696605ffa56eba3c27a438697cc21b201fd7e09f18deea1b3ea2f0d1edc02df0e20396a145412cd6b13c32d2e605641c948b714aec30c0649dc44143511f35ab0fd5dd64c34d06fe86f3836dfe9edeb7f08cfc3bd40956826356242191f99f53473f32b0cc0cf9321d6c92a112e8db90b86ee9e87cc32d0343db01e32ce9eb782cb24efbbbeb440fe929e8f2bf8dfb1550a3a2e742e8b455a3e5730e9e6a7a9824d17acc0f72a7f67eae0f0970f8bde46dcdefaed3047cf807e7f00a42e5fd11d40f5e98533d7574425b7d2bc3b3845c443008b58980e768e464e17cc6f6b3939eee52f713963d07d8c4abf02448ef0b889c9671e2f8a436ddeeffcca7176e9bf9d1005ecd377f2fa67c23ed1f137e60bf46018a8bd613d038e883704fc26e798969df35ec7bbc6a4fe46d8910bd82fa3cded265d0a3b6d399e4251e4d8233daa21b5812fded6536198ff13aa5a1cd46a5b9a17a4ddc1d9f85544d1d1cc16f3df858038c8e071a11a7e157a85a6a8dc47e88d75e7009a8b26fdb73f33a2a70f1e0c259f8f9533b9b8f9af9288b7274f21baeec78d396f8bacdcc22471207d9b4efccd3fedc5c5a2214ff5e51c553f35e21ae696fe51e8df733a8e06f50f419e599e9f9e4b37ce643fc810faaa47989771509d69a110ac916261427026369a21263ac4460fb4f708f8ae28599856db7cb6a43ac8e03d64a9609807e76c5f312b9d1863bfa304e8953647648b4f4ab0ed995e" );
7823 fct_chk ( ctx.
md_ctx != NULL );
7824 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7825 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7830 fct_chk( strcmp( (
char *) hash_str,
"4109cdbec3240ad74cc6c37f39300f70fede16e21efc77f7865998714aad0b5e" ) == 0 );
7835 #ifdef POLARSSL_SHA4_C
7837 FCT_TEST_BGN(generic_multi_step_sha_384_test_vector_nist_cavs_1)
7840 unsigned char src_str[10000];
7841 unsigned char hash_str[10000];
7842 unsigned char output[100];
7847 memset(md_name, 0x00, 100);
7848 memset(src_str, 0x00, 10000);
7849 memset(hash_str, 0x00, 10000);
7850 memset(output, 0x00, 100);
7852 strncpy( (
char *) md_name,
"sha384", 100 );
7854 fct_chk( md_info != NULL );
7860 fct_chk ( ctx.
md_ctx != NULL );
7861 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7862 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7867 fct_chk( strcmp( (
char *) hash_str,
"38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b" ) == 0 );
7872 #ifdef POLARSSL_SHA4_C
7874 FCT_TEST_BGN(generic_multi_step_sha_384_test_vector_nist_cavs_2)
7877 unsigned char src_str[10000];
7878 unsigned char hash_str[10000];
7879 unsigned char output[100];
7884 memset(md_name, 0x00, 100);
7885 memset(src_str, 0x00, 10000);
7886 memset(hash_str, 0x00, 10000);
7887 memset(output, 0x00, 100);
7889 strncpy( (
char *) md_name,
"sha384", 100 );
7891 fct_chk( md_info != NULL );
7894 src_len =
unhexify( src_str,
"ab" );
7897 fct_chk ( ctx.
md_ctx != NULL );
7898 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7899 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7904 fct_chk( strcmp( (
char *) hash_str,
"fb94d5be118865f6fcbc978b825da82cff188faec2f66cb84b2537d74b4938469854b0ca89e66fa2e182834736629f3d" ) == 0 );
7909 #ifdef POLARSSL_SHA4_C
7911 FCT_TEST_BGN(generic_multi_step_sha_384_test_vector_nist_cavs_3)
7914 unsigned char src_str[10000];
7915 unsigned char hash_str[10000];
7916 unsigned char output[100];
7921 memset(md_name, 0x00, 100);
7922 memset(src_str, 0x00, 10000);
7923 memset(hash_str, 0x00, 10000);
7924 memset(output, 0x00, 100);
7926 strncpy( (
char *) md_name,
"sha384", 100 );
7928 fct_chk( md_info != NULL );
7931 src_len =
unhexify( src_str,
"7c27" );
7934 fct_chk ( ctx.
md_ctx != NULL );
7935 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7936 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7941 fct_chk( strcmp( (
char *) hash_str,
"3d80be467df86d63abb9ea1d3f9cb39cd19890e7f2c53a6200bedc5006842b35e820dc4e0ca90ca9b97ab23ef07080fc" ) == 0 );
7946 #ifdef POLARSSL_SHA4_C
7948 FCT_TEST_BGN(generic_multi_step_sha_384_test_vector_nist_cavs_4)
7951 unsigned char src_str[10000];
7952 unsigned char hash_str[10000];
7953 unsigned char output[100];
7958 memset(md_name, 0x00, 100);
7959 memset(src_str, 0x00, 10000);
7960 memset(hash_str, 0x00, 10000);
7961 memset(output, 0x00, 100);
7963 strncpy( (
char *) md_name,
"sha384", 100 );
7965 fct_chk( md_info != NULL );
7968 src_len =
unhexify( src_str,
"31f5ca" );
7971 fct_chk ( ctx.
md_ctx != NULL );
7972 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
7973 fct_chk ( 0 ==
md_finish( &ctx, output ) );
7978 fct_chk( strcmp( (
char *) hash_str,
"78d54b943421fdf7ba90a7fb9637c2073aa480454bd841d39ff72f4511fc21fb67797b652c0c823229342873d3bef955" ) == 0 );
7983 #ifdef POLARSSL_SHA4_C
7985 FCT_TEST_BGN(generic_multi_step_sha_384_test_vector_nist_cavs_5)
7988 unsigned char src_str[10000];
7989 unsigned char hash_str[10000];
7990 unsigned char output[100];
7995 memset(md_name, 0x00, 100);
7996 memset(src_str, 0x00, 10000);
7997 memset(hash_str, 0x00, 10000);
7998 memset(output, 0x00, 100);
8000 strncpy( (
char *) md_name,
"sha384", 100 );
8002 fct_chk( md_info != NULL );
8005 src_len =
unhexify( src_str,
"7bdee3f8" );
8008 fct_chk ( ctx.
md_ctx != NULL );
8009 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
8010 fct_chk ( 0 ==
md_finish( &ctx, output ) );
8015 fct_chk( strcmp( (
char *) hash_str,
"8bdafba0777ee446c3431c2d7b1fbb631089f71d2ca417abc1d230e1aba64ec2f1c187474a6f4077d372c14ad407f99a" ) == 0 );
8020 #ifdef POLARSSL_SHA4_C
8022 FCT_TEST_BGN(generic_multi_step_sha_384_test_vector_nist_cavs_6)
8025 unsigned char src_str[10000];
8026 unsigned char hash_str[10000];
8027 unsigned char output[100];
8032 memset(md_name, 0x00, 100);
8033 memset(src_str, 0x00, 10000);
8034 memset(hash_str, 0x00, 10000);
8035 memset(output, 0x00, 100);
8037 strncpy( (
char *) md_name,
"sha384", 100 );
8039 fct_chk( md_info != NULL );
8042 src_len =
unhexify( src_str,
"8f05604915" );
8045 fct_chk ( ctx.
md_ctx != NULL );
8046 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
8047 fct_chk ( 0 ==
md_finish( &ctx, output ) );
8052 fct_chk( strcmp( (
char *) hash_str,
"504e414bf1db1060f14c8c799e25b1e0c4dcf1504ebbd129998f0ae283e6de86e0d3c7e879c73ec3b1836c3ee89c2649" ) == 0 );
8057 #ifdef POLARSSL_SHA4_C
8059 FCT_TEST_BGN(generic_multi_step_sha_384_test_vector_nist_cavs_7)
8062 unsigned char src_str[10000];
8063 unsigned char hash_str[10000];
8064 unsigned char output[100];
8069 memset(md_name, 0x00, 100);
8070 memset(src_str, 0x00, 10000);
8071 memset(hash_str, 0x00, 10000);
8072 memset(output, 0x00, 100);
8074 strncpy( (
char *) md_name,
"sha384", 100 );
8076 fct_chk( md_info != NULL );
8079 src_len =
unhexify( src_str,
"665da6eda214" );
8082 fct_chk ( ctx.
md_ctx != NULL );
8083 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
8084 fct_chk ( 0 ==
md_finish( &ctx, output ) );
8089 fct_chk( strcmp( (
char *) hash_str,
"4c022f112010908848312f8b8f1072625fd5c105399d562ea1d56130619a7eac8dfc3748fd05ee37e4b690be9daa9980" ) == 0 );
8094 #ifdef POLARSSL_SHA4_C
8096 FCT_TEST_BGN(generic_multi_step_sha_384_test_vector_nist_cavs_8)
8099 unsigned char src_str[10000];
8100 unsigned char hash_str[10000];
8101 unsigned char output[100];
8106 memset(md_name, 0x00, 100);
8107 memset(src_str, 0x00, 10000);
8108 memset(hash_str, 0x00, 10000);
8109 memset(output, 0x00, 100);
8111 strncpy( (
char *) md_name,
"sha384", 100 );
8113 fct_chk( md_info != NULL );
8116 src_len =
unhexify( src_str,
"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" );
8119 fct_chk ( ctx.
md_ctx != NULL );
8120 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
8121 fct_chk ( 0 ==
md_finish( &ctx, output ) );
8126 fct_chk( strcmp( (
char *) hash_str,
"cba9e3eb12a6f83db11e8a6ff40d1049854ee094416bc527fea931d8585428a8ed6242ce81f6769b36e2123a5c23483e" ) == 0 );
8131 #ifdef POLARSSL_SHA4_C
8133 FCT_TEST_BGN(generic_multi_step_sha_512_test_vector_nist_cavs_1)
8136 unsigned char src_str[10000];
8137 unsigned char hash_str[10000];
8138 unsigned char output[100];
8143 memset(md_name, 0x00, 100);
8144 memset(src_str, 0x00, 10000);
8145 memset(hash_str, 0x00, 10000);
8146 memset(output, 0x00, 100);
8148 strncpy( (
char *) md_name,
"sha512", 100 );
8150 fct_chk( md_info != NULL );
8156 fct_chk ( ctx.
md_ctx != NULL );
8157 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
8158 fct_chk ( 0 ==
md_finish( &ctx, output ) );
8163 fct_chk( strcmp( (
char *) hash_str,
"cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e" ) == 0 );
8168 #ifdef POLARSSL_SHA4_C
8170 FCT_TEST_BGN(generic_multi_step_sha_512_test_vector_nist_cavs_2)
8173 unsigned char src_str[10000];
8174 unsigned char hash_str[10000];
8175 unsigned char output[100];
8180 memset(md_name, 0x00, 100);
8181 memset(src_str, 0x00, 10000);
8182 memset(hash_str, 0x00, 10000);
8183 memset(output, 0x00, 100);
8185 strncpy( (
char *) md_name,
"sha512", 100 );
8187 fct_chk( md_info != NULL );
8190 src_len =
unhexify( src_str,
"8f" );
8193 fct_chk ( ctx.
md_ctx != NULL );
8194 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
8195 fct_chk ( 0 ==
md_finish( &ctx, output ) );
8200 fct_chk( strcmp( (
char *) hash_str,
"e4cd2d19931b5aad9c920f45f56f6ce34e3d38c6d319a6e11d0588ab8b838576d6ce6d68eea7c830de66e2bd96458bfa7aafbcbec981d4ed040498c3dd95f22a" ) == 0 );
8205 #ifdef POLARSSL_SHA4_C
8207 FCT_TEST_BGN(generic_multi_step_sha_512_test_vector_nist_cavs_3)
8210 unsigned char src_str[10000];
8211 unsigned char hash_str[10000];
8212 unsigned char output[100];
8217 memset(md_name, 0x00, 100);
8218 memset(src_str, 0x00, 10000);
8219 memset(hash_str, 0x00, 10000);
8220 memset(output, 0x00, 100);
8222 strncpy( (
char *) md_name,
"sha512", 100 );
8224 fct_chk( md_info != NULL );
8227 src_len =
unhexify( src_str,
"e724" );
8230 fct_chk ( ctx.
md_ctx != NULL );
8231 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
8232 fct_chk ( 0 ==
md_finish( &ctx, output ) );
8237 fct_chk( strcmp( (
char *) hash_str,
"7dbb520221a70287b23dbcf62bfc1b73136d858e86266732a7fffa875ecaa2c1b8f673b5c065d360c563a7b9539349f5f59bef8c0c593f9587e3cd50bb26a231" ) == 0 );
8242 #ifdef POLARSSL_SHA4_C
8244 FCT_TEST_BGN(generic_multi_step_sha_512_test_vector_nist_cavs_4)
8247 unsigned char src_str[10000];
8248 unsigned char hash_str[10000];
8249 unsigned char output[100];
8254 memset(md_name, 0x00, 100);
8255 memset(src_str, 0x00, 10000);
8256 memset(hash_str, 0x00, 10000);
8257 memset(output, 0x00, 100);
8259 strncpy( (
char *) md_name,
"sha512", 100 );
8261 fct_chk( md_info != NULL );
8264 src_len =
unhexify( src_str,
"de4c90" );
8267 fct_chk ( ctx.
md_ctx != NULL );
8268 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
8269 fct_chk ( 0 ==
md_finish( &ctx, output ) );
8274 fct_chk( strcmp( (
char *) hash_str,
"33ce98281045a5c4c9df0363d8196f1d7dfcd5ee46ac89776fd8a4344c12f123a66788af5bd41ceff1941aa5637654b4064c88c14e00465ab79a2fc6c97e1014" ) == 0 );
8279 #ifdef POLARSSL_SHA4_C
8281 FCT_TEST_BGN(generic_multi_step_sha_512_test_vector_nist_cavs_5)
8284 unsigned char src_str[10000];
8285 unsigned char hash_str[10000];
8286 unsigned char output[100];
8291 memset(md_name, 0x00, 100);
8292 memset(src_str, 0x00, 10000);
8293 memset(hash_str, 0x00, 10000);
8294 memset(output, 0x00, 100);
8296 strncpy( (
char *) md_name,
"sha512", 100 );
8298 fct_chk( md_info != NULL );
8301 src_len =
unhexify( src_str,
"a801e94b" );
8304 fct_chk ( ctx.
md_ctx != NULL );
8305 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
8306 fct_chk ( 0 ==
md_finish( &ctx, output ) );
8311 fct_chk( strcmp( (
char *) hash_str,
"dadb1b5a27f9fece8d86adb2a51879beb1787ff28f4e8ce162cad7fee0f942efcabbf738bc6f797fc7cc79a3a75048cd4c82ca0757a324695bfb19a557e56e2f" ) == 0 );
8316 #ifdef POLARSSL_SHA4_C
8318 FCT_TEST_BGN(generic_multi_step_sha_512_test_vector_nist_cavs_6)
8321 unsigned char src_str[10000];
8322 unsigned char hash_str[10000];
8323 unsigned char output[100];
8328 memset(md_name, 0x00, 100);
8329 memset(src_str, 0x00, 10000);
8330 memset(hash_str, 0x00, 10000);
8331 memset(output, 0x00, 100);
8333 strncpy( (
char *) md_name,
"sha512", 100 );
8335 fct_chk( md_info != NULL );
8338 src_len =
unhexify( src_str,
"94390d3502" );
8341 fct_chk ( ctx.
md_ctx != NULL );
8342 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
8343 fct_chk ( 0 ==
md_finish( &ctx, output ) );
8348 fct_chk( strcmp( (
char *) hash_str,
"b6175c4c4cccf69e0ce5f0312010886ea6b34d43673f942ae42483f9cbb7da817de4e11b5d58e25a3d9bd721a22cdffe1c40411cc45df1911fa5506129b69297" ) == 0 );
8353 #ifdef POLARSSL_SHA4_C
8355 FCT_TEST_BGN(generic_multi_step_sha_512_test_vector_nist_cavs_7)
8358 unsigned char src_str[10000];
8359 unsigned char hash_str[10000];
8360 unsigned char output[100];
8365 memset(md_name, 0x00, 100);
8366 memset(src_str, 0x00, 10000);
8367 memset(hash_str, 0x00, 10000);
8368 memset(output, 0x00, 100);
8370 strncpy( (
char *) md_name,
"sha512", 100 );
8372 fct_chk( md_info != NULL );
8375 src_len =
unhexify( src_str,
"49297dd63e5f" );
8378 fct_chk ( ctx.
md_ctx != NULL );
8379 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
8380 fct_chk ( 0 ==
md_finish( &ctx, output ) );
8385 fct_chk( strcmp( (
char *) hash_str,
"1fcc1e6f6870859d11649f5e5336a9cd16329c029baf04d5a6edf257889a2e9522b497dd656bb402da461307c4ee382e2e89380c8e6e6e7697f1e439f650fa94" ) == 0 );
8390 #ifdef POLARSSL_SHA4_C
8392 FCT_TEST_BGN(generic_multi_step_sha_512_test_vector_nist_cavs_8)
8395 unsigned char src_str[10000];
8396 unsigned char hash_str[10000];
8397 unsigned char output[100];
8402 memset(md_name, 0x00, 100);
8403 memset(src_str, 0x00, 10000);
8404 memset(hash_str, 0x00, 10000);
8405 memset(output, 0x00, 100);
8407 strncpy( (
char *) md_name,
"sha512", 100 );
8409 fct_chk( md_info != NULL );
8412 src_len =
unhexify( src_str,
"990d1ae71a62d7bda9bfdaa1762a68d296eee72a4cd946f287a898fbabc002ea941fd8d4d991030b4d27a637cce501a834bb95eab1b7889a3e784c7968e67cbf552006b206b68f76d9191327524fcc251aeb56af483d10b4e0c6c5e599ee8c0fe4faeca8293844a8547c6a9a90d093f2526873a19ad4a5e776794c68c742fb834793d2dfcb7fea46c63af4b70fd11cb6e41834e72ee40edb067b292a794990c288d5007e73f349fb383af6a756b8301ad6e5e0aa8cd614399bb3a452376b1575afa6bdaeaafc286cb064bb91edef97c632b6c1113d107fa93a0905098a105043c2f05397f702514439a08a9e5ddc196100721d45c8fc17d2ed659376f8a00bd5cb9a0860e26d8a29d8d6aaf52de97e9346033d6db501a35dbbaf97c20b830cd2d18c2532f3a59cc497ee64c0e57d8d060e5069b28d86edf1adcf59144b221ce3ddaef134b3124fbc7dd000240eff0f5f5f41e83cd7f5bb37c9ae21953fe302b0f6e8b68fa91c6ab99265c64b2fd9cd4942be04321bb5d6d71932376c6f2f88e02422ba6a5e2cb765df93fd5dd0728c6abdaf03bce22e0678a544e2c3636f741b6f4447ee58a8fc656b43ef817932176adbfc2e04b2c812c273cd6cbfa4098f0be036a34221fa02643f5ee2e0b38135f2a18ecd2f16ebc45f8eb31b8ab967a1567ee016904188910861ca1fa205c7adaa194b286893ffe2f4fbe0384c2aef72a4522aeafd3ebc71f9db71eeeef86c48394a1c86d5b36c352cc33a0a2c800bc99e62fd65b3a2fd69e0b53996ec13d8ce483ce9319efd9a85acefabdb5342226febb83fd1daf4b24265f50c61c6de74077ef89b6fecf9f29a1f871af1e9f89b2d345cda7499bd45c42fa5d195a1e1a6ba84851889e730da3b2b916e96152ae0c92154b49719841db7e7cc707ba8a5d7b101eb4ac7b629bb327817910fff61580b59aab78182d1a2e33473d05b00b170b29e331870826cfe45af206aa7d0246bbd8566ca7cfb2d3c10bfa1db7dd48dd786036469ce7282093d78b5e1a5b0fc81a54c8ed4ceac1e5305305e78284ac276f5d7862727aff246e17addde50c670028d572cbfc0be2e4f8b2eb28fa68ad7b4c6c2a239c460441bfb5ea049f23b08563b4e47729a59e5986a61a6093dbd54f8c36ebe87edae01f251cb060ad1364ce677d7e8d5a4a4ca966a7241cc360bc2acb280e5f9e9c1b032ad6a180a35e0c5180b9d16d026c865b252098cc1d99ba7375ca31c7702c0d943d5e3dd2f6861fa55bd46d94b67ed3e52eccd8dd06d968e01897d6de97ed3058d91dd" );
8415 fct_chk ( ctx.
md_ctx != NULL );
8416 fct_chk ( 0 ==
md_update( &ctx, src_str, src_len ) );
8417 fct_chk ( 0 ==
md_finish( &ctx, output ) );
8422 fct_chk( strcmp( (
char *) hash_str,
"8e4bc6f8b8c60fe4d68c61d9b159c8693c3151c46749af58da228442d927f23359bd6ccd6c2ec8fa3f00a86cecbfa728e1ad60b821ed22fcd309ba91a4138bc9" ) == 0 );
8427 #ifdef POLARSSL_SHA1_C
8428 #ifdef POLARSSL_FS_IO
8430 FCT_TEST_BGN(generic_sha1_hash_file_1)
8433 unsigned char hash_str[1000];
8434 unsigned char output[100];
8437 memset(md_name, 0x00, 100);
8438 memset(hash_str, 0x00, 1000);
8439 memset(output, 0x00, 100);
8441 strncpy( (
char *) md_name,
"sha1", 100 );
8443 fct_chk( md_info != NULL );
8445 md_file( md_info,
"data_files/hash_file_1", output);
8448 fct_chk( strcmp( (
char *) hash_str,
"d21c965b1e768bd7a6aa6869f5f821901d255f9f" ) == 0 );
8454 #ifdef POLARSSL_SHA1_C
8455 #ifdef POLARSSL_FS_IO
8457 FCT_TEST_BGN(generic_sha1_hash_file_2)
8460 unsigned char hash_str[1000];
8461 unsigned char output[100];
8464 memset(md_name, 0x00, 100);
8465 memset(hash_str, 0x00, 1000);
8466 memset(output, 0x00, 100);
8468 strncpy( (
char *) md_name,
"sha1", 100 );
8470 fct_chk( md_info != NULL );
8472 md_file( md_info,
"data_files/hash_file_2", output);
8475 fct_chk( strcmp( (
char *) hash_str,
"353f34271f2aef49d23a8913d4a6bd82b2cecdc6" ) == 0 );
8481 #ifdef POLARSSL_SHA1_C
8482 #ifdef POLARSSL_FS_IO
8484 FCT_TEST_BGN(generic_sha1_hash_file_3)
8487 unsigned char hash_str[1000];
8488 unsigned char output[100];
8491 memset(md_name, 0x00, 100);
8492 memset(hash_str, 0x00, 1000);
8493 memset(output, 0x00, 100);
8495 strncpy( (
char *) md_name,
"sha1", 100 );
8497 fct_chk( md_info != NULL );
8499 md_file( md_info,
"data_files/hash_file_3", output);
8502 fct_chk( strcmp( (
char *) hash_str,
"93640ed592076328096270c756db2fba9c486b35" ) == 0 );
8508 #ifdef POLARSSL_SHA1_C
8509 #ifdef POLARSSL_FS_IO
8511 FCT_TEST_BGN(generic_sha1_hash_file_4)
8514 unsigned char hash_str[1000];
8515 unsigned char output[100];
8518 memset(md_name, 0x00, 100);
8519 memset(hash_str, 0x00, 1000);
8520 memset(output, 0x00, 100);
8522 strncpy( (
char *) md_name,
"sha1", 100 );
8524 fct_chk( md_info != NULL );
8526 md_file( md_info,
"data_files/hash_file_4", output);
8529 fct_chk( strcmp( (
char *) hash_str,
"da39a3ee5e6b4b0d3255bfef95601890afd80709" ) == 0 );
8535 #ifdef POLARSSL_SHA2_C
8536 #ifdef POLARSSL_FS_IO
8538 FCT_TEST_BGN(generic_sha_224_hash_file_1)
8541 unsigned char hash_str[1000];
8542 unsigned char output[100];
8545 memset(md_name, 0x00, 100);
8546 memset(hash_str, 0x00, 1000);
8547 memset(output, 0x00, 100);
8549 strncpy( (
char *) md_name,
"sha224", 100 );
8551 fct_chk( md_info != NULL );
8553 md_file( md_info,
"data_files/hash_file_1", output);
8556 fct_chk( strcmp( (
char *) hash_str,
"8606da018870f0c16834a21bc3385704cb1683b9dbab04c5ddb90a48" ) == 0 );
8562 #ifdef POLARSSL_SHA2_C
8563 #ifdef POLARSSL_FS_IO
8565 FCT_TEST_BGN(generic_sha_224_hash_file_2)
8568 unsigned char hash_str[1000];
8569 unsigned char output[100];
8572 memset(md_name, 0x00, 100);
8573 memset(hash_str, 0x00, 1000);
8574 memset(output, 0x00, 100);
8576 strncpy( (
char *) md_name,
"sha224", 100 );
8578 fct_chk( md_info != NULL );
8580 md_file( md_info,
"data_files/hash_file_2", output);
8583 fct_chk( strcmp( (
char *) hash_str,
"733b2ab97b6f63f2e29b9a2089756d81e14c93fe4cc9615c0d5e8a03" ) == 0 );
8589 #ifdef POLARSSL_SHA2_C
8590 #ifdef POLARSSL_FS_IO
8592 FCT_TEST_BGN(generic_sha_224_hash_file_3)
8595 unsigned char hash_str[1000];
8596 unsigned char output[100];
8599 memset(md_name, 0x00, 100);
8600 memset(hash_str, 0x00, 1000);
8601 memset(output, 0x00, 100);
8603 strncpy( (
char *) md_name,
"sha224", 100 );
8605 fct_chk( md_info != NULL );
8607 md_file( md_info,
"data_files/hash_file_3", output);
8610 fct_chk( strcmp( (
char *) hash_str,
"e1df95867580e2cc2100e9565bf9c2e42c24fe5250c19efe33d1c4fe" ) == 0 );
8616 #ifdef POLARSSL_SHA2_C
8617 #ifdef POLARSSL_FS_IO
8619 FCT_TEST_BGN(generic_sha_224_hash_file_4)
8622 unsigned char hash_str[1000];
8623 unsigned char output[100];
8626 memset(md_name, 0x00, 100);
8627 memset(hash_str, 0x00, 1000);
8628 memset(output, 0x00, 100);
8630 strncpy( (
char *) md_name,
"sha224", 100 );
8632 fct_chk( md_info != NULL );
8634 md_file( md_info,
"data_files/hash_file_4", output);
8637 fct_chk( strcmp( (
char *) hash_str,
"d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f" ) == 0 );
8643 #ifdef POLARSSL_SHA2_C
8644 #ifdef POLARSSL_FS_IO
8646 FCT_TEST_BGN(generic_sha_256_hash_file_1)
8649 unsigned char hash_str[1000];
8650 unsigned char output[100];
8653 memset(md_name, 0x00, 100);
8654 memset(hash_str, 0x00, 1000);
8655 memset(output, 0x00, 100);
8657 strncpy( (
char *) md_name,
"sha256", 100 );
8659 fct_chk( md_info != NULL );
8661 md_file( md_info,
"data_files/hash_file_1", output);
8664 fct_chk( strcmp( (
char *) hash_str,
"975d0c620d3936886f8a3665e585a3e84aa0501f4225bf53029710242823e391" ) == 0 );
8670 #ifdef POLARSSL_SHA2_C
8671 #ifdef POLARSSL_FS_IO
8673 FCT_TEST_BGN(generic_sha_256_hash_file_2)
8676 unsigned char hash_str[1000];
8677 unsigned char output[100];
8680 memset(md_name, 0x00, 100);
8681 memset(hash_str, 0x00, 1000);
8682 memset(output, 0x00, 100);
8684 strncpy( (
char *) md_name,
"sha256", 100 );
8686 fct_chk( md_info != NULL );
8688 md_file( md_info,
"data_files/hash_file_2", output);
8691 fct_chk( strcmp( (
char *) hash_str,
"11fcbf1baa36ca45745f10cc5467aee86f066f80ba2c46806d876bf783022ad2" ) == 0 );
8697 #ifdef POLARSSL_SHA2_C
8698 #ifdef POLARSSL_FS_IO
8700 FCT_TEST_BGN(generic_sha_256_hash_file_3)
8703 unsigned char hash_str[1000];
8704 unsigned char output[100];
8707 memset(md_name, 0x00, 100);
8708 memset(hash_str, 0x00, 1000);
8709 memset(output, 0x00, 100);
8711 strncpy( (
char *) md_name,
"sha256", 100 );
8713 fct_chk( md_info != NULL );
8715 md_file( md_info,
"data_files/hash_file_3", output);
8718 fct_chk( strcmp( (
char *) hash_str,
"9ae4b369f9f4f03b86505b46a5469542e00aaff7cf7417a71af6d6d0aba3b70c" ) == 0 );
8724 #ifdef POLARSSL_SHA2_C
8725 #ifdef POLARSSL_FS_IO
8727 FCT_TEST_BGN(generic_sha_256_hash_file_4)
8730 unsigned char hash_str[1000];
8731 unsigned char output[100];
8734 memset(md_name, 0x00, 100);
8735 memset(hash_str, 0x00, 1000);
8736 memset(output, 0x00, 100);
8738 strncpy( (
char *) md_name,
"sha256", 100 );
8740 fct_chk( md_info != NULL );
8742 md_file( md_info,
"data_files/hash_file_4", output);
8745 fct_chk( strcmp( (
char *) hash_str,
"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" ) == 0 );
8751 #ifdef POLARSSL_SHA4_C
8752 #ifdef POLARSSL_FS_IO
8754 FCT_TEST_BGN(generic_sha_384_hash_file_1)
8757 unsigned char hash_str[1000];
8758 unsigned char output[100];
8761 memset(md_name, 0x00, 100);
8762 memset(hash_str, 0x00, 1000);
8763 memset(output, 0x00, 100);
8765 strncpy( (
char *) md_name,
"sha384", 100 );
8767 fct_chk( md_info != NULL );
8769 md_file( md_info,
"data_files/hash_file_1", output);
8772 fct_chk( strcmp( (
char *) hash_str,
"e0a3e6259d6378001b54ef82f5dd087009c5fad86d8db226a9fe1d14ecbe33a6fc916e3a4b16f5f286424de15d5a8e0e" ) == 0 );
8778 #ifdef POLARSSL_SHA4_C
8779 #ifdef POLARSSL_FS_IO
8781 FCT_TEST_BGN(generic_sha_384_hash_file_2)
8784 unsigned char hash_str[1000];
8785 unsigned char output[100];
8788 memset(md_name, 0x00, 100);
8789 memset(hash_str, 0x00, 1000);
8790 memset(output, 0x00, 100);
8792 strncpy( (
char *) md_name,
"sha384", 100 );
8794 fct_chk( md_info != NULL );
8796 md_file( md_info,
"data_files/hash_file_2", output);
8799 fct_chk( strcmp( (
char *) hash_str,
"eff727afc8495c92e2f370f97a317f93c3350324b0646b0f0e264708b3c97d3d332d3c5390e1e47130f5c92f1ef4b9cf" ) == 0 );
8805 #ifdef POLARSSL_SHA4_C
8806 #ifdef POLARSSL_FS_IO
8808 FCT_TEST_BGN(generic_sha_384_hash_file_3)
8811 unsigned char hash_str[1000];
8812 unsigned char output[100];
8815 memset(md_name, 0x00, 100);
8816 memset(hash_str, 0x00, 1000);
8817 memset(output, 0x00, 100);
8819 strncpy( (
char *) md_name,
"sha384", 100 );
8821 fct_chk( md_info != NULL );
8823 md_file( md_info,
"data_files/hash_file_3", output);
8826 fct_chk( strcmp( (
char *) hash_str,
"6fc10ebda96a1ccf61777cac72f6034f92533d42052a4bf9f9d929c672973c71e5aeb1213268043c21527ac0f7f349c4" ) == 0 );
8832 #ifdef POLARSSL_SHA4_C
8833 #ifdef POLARSSL_FS_IO
8835 FCT_TEST_BGN(generic_sha_384_hash_file_4)
8838 unsigned char hash_str[1000];
8839 unsigned char output[100];
8842 memset(md_name, 0x00, 100);
8843 memset(hash_str, 0x00, 1000);
8844 memset(output, 0x00, 100);
8846 strncpy( (
char *) md_name,
"sha384", 100 );
8848 fct_chk( md_info != NULL );
8850 md_file( md_info,
"data_files/hash_file_4", output);
8853 fct_chk( strcmp( (
char *) hash_str,
"38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b" ) == 0 );
8859 #ifdef POLARSSL_SHA4_C
8860 #ifdef POLARSSL_FS_IO
8862 FCT_TEST_BGN(generic_sha_512_hash_file_1)
8865 unsigned char hash_str[1000];
8866 unsigned char output[100];
8869 memset(md_name, 0x00, 100);
8870 memset(hash_str, 0x00, 1000);
8871 memset(output, 0x00, 100);
8873 strncpy( (
char *) md_name,
"sha512", 100 );
8875 fct_chk( md_info != NULL );
8877 md_file( md_info,
"data_files/hash_file_1", output);
8880 fct_chk( strcmp( (
char *) hash_str,
"d8207a2e1ff2b424f2c4163fe1b723c9bd42e464061eb411e8df730bcd24a7ab3956a6f3ff044a52eb2d262f9e4ca6b524092b544ab78f14d6f9c4cc8ddf335a" ) == 0 );
8886 #ifdef POLARSSL_SHA4_C
8887 #ifdef POLARSSL_FS_IO
8889 FCT_TEST_BGN(generic_sha_512_hash_file_2)
8892 unsigned char hash_str[1000];
8893 unsigned char output[100];
8896 memset(md_name, 0x00, 100);
8897 memset(hash_str, 0x00, 1000);
8898 memset(output, 0x00, 100);
8900 strncpy( (
char *) md_name,
"sha512", 100 );
8902 fct_chk( md_info != NULL );
8904 md_file( md_info,
"data_files/hash_file_2", output);
8907 fct_chk( strcmp( (
char *) hash_str,
"ecbb7f0ed8a702b49f16ad3088bcc06ea93451912a7187db15f64d93517b09630b039293aed418d4a00695777b758b1f381548c2fd7b92ce5ed996b32c8734e7" ) == 0 );
8913 #ifdef POLARSSL_SHA4_C
8914 #ifdef POLARSSL_FS_IO
8916 FCT_TEST_BGN(generic_sha_512_hash_file_3)
8919 unsigned char hash_str[1000];
8920 unsigned char output[100];
8923 memset(md_name, 0x00, 100);
8924 memset(hash_str, 0x00, 1000);
8925 memset(output, 0x00, 100);
8927 strncpy( (
char *) md_name,
"sha512", 100 );
8929 fct_chk( md_info != NULL );
8931 md_file( md_info,
"data_files/hash_file_3", output);
8934 fct_chk( strcmp( (
char *) hash_str,
"7ccc9b2da71ffde9966c3ce44d7f20945fccf33b1fade4da152b021f1afcc7293382944aa6c09eac67af25f22026758e2bf6bed86ae2a43592677ee50f8eea41" ) == 0 );
8940 #ifdef POLARSSL_SHA4_C
8941 #ifdef POLARSSL_FS_IO
8943 FCT_TEST_BGN(generic_sha_512_hash_file_4)
8946 unsigned char hash_str[1000];
8947 unsigned char output[100];
8950 memset(md_name, 0x00, 100);
8951 memset(hash_str, 0x00, 1000);
8952 memset(output, 0x00, 100);
8954 strncpy( (
char *) md_name,
"sha512", 100 );
8956 fct_chk( md_info != NULL );
8958 md_file( md_info,
"data_files/hash_file_4", output);
8961 fct_chk( strcmp( (
char *) hash_str,
"cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e" ) == 0 );