TrustedFirmware Git Browser
Code Review Sign In
review.trustedfirmware.org / mirror / mbed-tls / e827ce013fb0d414388e539eff20382e417dadf2 / . / tests / suites / test_suite_md.function
blob: 042af17e27104d00cc0ce3c4ee096a159ceea416 [file] [log] [blame]
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]1/* BEGIN_HEADER */
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]2#include <polarssl/md.h>
3#include <polarssl/md2.h>
4#include <polarssl/md4.h>
5#include <polarssl/md5.h>
6#include <polarssl/sha1.h>
Paul Bakkerd2681d82013-06-30 14:49:12 +0200[diff] [blame]7#include <polarssl/sha256.h>
8#include <polarssl/sha512.h>
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]9/* END_HEADER */
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]10
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]11/* BEGIN_DEPENDENCIES
12 * depends_on:POLARSSL_MD_C
13 * END_DEPENDENCIES
14 */
Paul Bakker5690efc2011-05-26 13:16:06 +0000[diff] [blame]15
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]16/* BEGIN_CASE */
17void md_text( char *text_md_name, char *text_src_string, char *hex_hash_string )
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]18{
19 char md_name[100];
20 unsigned char src_str[1000];
21 unsigned char hash_str[1000];
22 unsigned char output[100];
23 const md_info_t *md_info = NULL;
24
25 memset(md_name, 0x00, 100);
26 memset(src_str, 0x00, 1000);
27 memset(hash_str, 0x00, 1000);
28 memset(output, 0x00, 100);
29
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]30 strcpy( (char *) src_str, text_src_string );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]31
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]32 strncpy( (char *) md_name, text_md_name, 100 );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]33 md_info = md_info_from_string(md_name);
34 TEST_ASSERT( md_info != NULL );
35
36 TEST_ASSERT ( 0 == md( md_info, src_str, strlen( (char *) src_str ), output ) );
37 hexify( hash_str, output, md_get_size(md_info) );
38
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]39 TEST_ASSERT( strcmp( (char *) hash_str, hex_hash_string ) == 0 );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]40}
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]41/* END_CASE */
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]42
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]43/* BEGIN_CASE */
44void md_hex( char *text_md_name, char *hex_src_string, char *hex_hash_string )
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]45{
46 char md_name[100];
47 unsigned char src_str[10000];
48 unsigned char hash_str[10000];
49 unsigned char output[100];
50 int src_len;
51 const md_info_t *md_info = NULL;
52
53 memset(md_name, 0x00, 100);
54 memset(src_str, 0x00, 10000);
55 memset(hash_str, 0x00, 10000);
56 memset(output, 0x00, 100);
57
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]58 strncpy( (char *) md_name, text_md_name, 100 );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]59 md_info = md_info_from_string(md_name);
60 TEST_ASSERT( md_info != NULL );
61
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]62 src_len = unhexify( src_str, hex_src_string );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]63 TEST_ASSERT ( 0 == md( md_info, src_str, src_len, output ) );
64
65 hexify( hash_str, output, md_get_size(md_info) );
66
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]67 TEST_ASSERT( strcmp( (char *) hash_str, hex_hash_string ) == 0 );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]68}
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]69/* END_CASE */
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]70
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]71/* BEGIN_CASE */
72void md_text_multi( char *text_md_name, char *text_src_string,
73 char *hex_hash_string )
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]74{
75 char md_name[100];
76 unsigned char src_str[1000];
77 unsigned char hash_str[1000];
78 unsigned char output[100];
79
80 const md_info_t *md_info = NULL;
81 md_context_t ctx = MD_CONTEXT_T_INIT;
82
83 memset(md_name, 0x00, 100);
84 memset(src_str, 0x00, 1000);
85 memset(hash_str, 0x00, 1000);
86 memset(output, 0x00, 100);
87
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]88 strcpy( (char *) src_str, text_src_string );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]89
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]90 strncpy( (char *) md_name, text_md_name, 100 );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]91 md_info = md_info_from_string(md_name);
92 TEST_ASSERT( md_info != NULL );
Paul Bakker562535d2011-01-20 16:42:01 +0000[diff] [blame]93 TEST_ASSERT ( 0 == md_init_ctx( &ctx, md_info ) );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]94
Paul Bakker562535d2011-01-20 16:42:01 +0000[diff] [blame]95 TEST_ASSERT ( 0 == md_starts( &ctx ) );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]96 TEST_ASSERT ( ctx.md_ctx != NULL );
97 TEST_ASSERT ( 0 == md_update( &ctx, src_str, strlen( (char *) src_str ) ) );
98 TEST_ASSERT ( 0 == md_finish( &ctx, output ) );
99 TEST_ASSERT ( 0 == md_free_ctx( &ctx ) );
100
101 hexify( hash_str, output, md_get_size(md_info) );
102
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]103 TEST_ASSERT( strcmp( (char *) hash_str, hex_hash_string ) == 0 );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]104}
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]105/* END_CASE */
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]106
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]107/* BEGIN_CASE */
108void md_hex_multi( char *text_md_name, char *hex_src_string,
109 char *hex_hash_string )
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]110{
111 char md_name[100];
112 unsigned char src_str[10000];
113 unsigned char hash_str[10000];
114 unsigned char output[100];
115 int src_len;
116 const md_info_t *md_info = NULL;
117 md_context_t ctx = MD_CONTEXT_T_INIT;
118
119 memset(md_name, 0x00, 100);
120 memset(src_str, 0x00, 10000);
121 memset(hash_str, 0x00, 10000);
122 memset(output, 0x00, 100);
123
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]124 strncpy( (char *) md_name, text_md_name, 100 );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]125 md_info = md_info_from_string(md_name);
126 TEST_ASSERT( md_info != NULL );
Paul Bakker562535d2011-01-20 16:42:01 +0000[diff] [blame]127 TEST_ASSERT ( 0 == md_init_ctx( &ctx, md_info ) );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]128
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]129 src_len = unhexify( src_str, hex_src_string );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]130
Paul Bakker562535d2011-01-20 16:42:01 +0000[diff] [blame]131 TEST_ASSERT ( 0 == md_starts( &ctx ) );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]132 TEST_ASSERT ( ctx.md_ctx != NULL );
133 TEST_ASSERT ( 0 == md_update( &ctx, src_str, src_len ) );
134 TEST_ASSERT ( 0 == md_finish( &ctx, output ) );
135 TEST_ASSERT ( 0 == md_free_ctx( &ctx ) );
136
137 hexify( hash_str, output, md_get_size(md_info) );
138
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]139 TEST_ASSERT( strcmp( (char *) hash_str, hex_hash_string ) == 0 );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]140}
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]141/* END_CASE */
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]142
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]143/* BEGIN_CASE */
144void md_hmac( char *text_md_name, int trunc_size, char *hex_key_string,
145 char *hex_src_string, char *hex_hash_string )
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]146{
147 char md_name[100];
148 unsigned char src_str[10000];
149 unsigned char key_str[10000];
150 unsigned char hash_str[10000];
151 unsigned char output[100];
152 int key_len, src_len;
153 const md_info_t *md_info = NULL;
154
155 memset(md_name, 0x00, 100);
156 memset(src_str, 0x00, 10000);
157 memset(key_str, 0x00, 10000);
158 memset(hash_str, 0x00, 10000);
159 memset(output, 0x00, 100);
160
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]161 strncpy( (char *) md_name, text_md_name, 100 );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]162 md_info = md_info_from_string( md_name );
163 TEST_ASSERT( md_info != NULL );
164
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]165 key_len = unhexify( key_str, hex_key_string );
166 src_len = unhexify( src_str, hex_src_string );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]167
168 TEST_ASSERT ( md_hmac( md_info, key_str, key_len, src_str, src_len, output ) == 0 );
169 hexify( hash_str, output, md_get_size(md_info) );
170
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]171 TEST_ASSERT( strncmp( (char *) hash_str, hex_hash_string, trunc_size * 2 ) == 0 );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]172}
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]173/* END_CASE */
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]174
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]175/* BEGIN_CASE */
176void md_hmac_multi( char *text_md_name, int trunc_size, char *hex_key_string,
177 char *hex_src_string, char *hex_hash_string )
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]178{
179 char md_name[100];
180 unsigned char src_str[10000];
181 unsigned char key_str[10000];
182 unsigned char hash_str[10000];
183 unsigned char output[100];
184 int key_len, src_len;
185 const md_info_t *md_info = NULL;
186 md_context_t ctx = MD_CONTEXT_T_INIT;
187
188 memset(md_name, 0x00, 100);
189 memset(src_str, 0x00, 10000);
190 memset(key_str, 0x00, 10000);
191 memset(hash_str, 0x00, 10000);
192 memset(output, 0x00, 100);
193
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]194 strncpy( (char *) md_name, text_md_name, 100 );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]195 md_info = md_info_from_string( md_name );
196 TEST_ASSERT( md_info != NULL );
Paul Bakker562535d2011-01-20 16:42:01 +0000[diff] [blame]197 TEST_ASSERT ( 0 == md_init_ctx( &ctx, md_info ) );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]198
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]199 key_len = unhexify( key_str, hex_key_string );
200 src_len = unhexify( src_str, hex_src_string );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]201
Paul Bakker562535d2011-01-20 16:42:01 +0000[diff] [blame]202 TEST_ASSERT ( 0 == md_hmac_starts( &ctx, key_str, key_len ) );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]203 TEST_ASSERT ( ctx.md_ctx != NULL );
204 TEST_ASSERT ( 0 == md_hmac_update( &ctx, src_str, src_len ) );
205 TEST_ASSERT ( 0 == md_hmac_finish( &ctx, output ) );
206 TEST_ASSERT ( 0 == md_free_ctx( &ctx ) );
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]207
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]208 hexify( hash_str, output, md_get_size(md_info) );
209
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]210 TEST_ASSERT( strncmp( (char *) hash_str, hex_hash_string, trunc_size * 2 ) == 0 );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]211}
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]212/* END_CASE */
213/* BEGIN_CASE */
214void md_file( char *text_md_name, char *filename, char *hex_hash_string )
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]215{
216 char md_name[100];
217 unsigned char hash_str[1000];
218 unsigned char output[100];
219 const md_info_t *md_info = NULL;
220
221 memset(md_name, 0x00, 100);
222 memset(hash_str, 0x00, 1000);
223 memset(output, 0x00, 100);
224
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]225 strncpy( (char *) md_name, text_md_name, 100 );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]226 md_info = md_info_from_string( md_name );
227 TEST_ASSERT( md_info != NULL );
228
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]229 md_file( md_info, filename, output);
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]230 hexify( hash_str, output, md_get_size(md_info) );
231
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]232 TEST_ASSERT( strcmp( (char *) hash_str, hex_hash_string ) == 0 );
Paul Bakker17373852011-01-06 14:20:01 +0000[diff] [blame]233}
Paul Bakker33b43f12013-08-20 11:48:36 +0200[diff] [blame]234/* END_CASE */