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