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