1 /**
2  * \file vdb_mbedtls_md.c
3  *
4  * \brief Generic message digest wrapper for mbed TLS
5  *
6  * \author Adriaan de Jong <dejong@fox-it.com>
7  *
8  *  Copyright The Mbed TLS Contributors
9  *  SPDX-License-Identifier: Apache-2.0
10  *
11  *  Licensed under the Apache License, Version 2.0 (the "License"); you may
12  *  not use this file except in compliance with the License.
13  *  You may obtain a copy of the License at
14  *
15  *  http://www.apache.org/licenses/LICENSE-2.0
16  *
17  *  Unless required by applicable law or agreed to in writing, software
18  *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
19  *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
20  *  See the License for the specific language governing permissions and
21  *  limitations under the License.
22  */
23 
24 #include "common.h"
25 
26 #if defined(MBEDTLS_MD_C)
27 
28 #include "mbedtls/md.h"
29 #include "mbedtls/md_internal.h"
30 #include "mbedtls/platform_util.h"
31 #include "mbedtls/error.h"
32 
33 #include "mbedtls/md2.h"
34 #include "mbedtls/md4.h"
35 #include "mbedtls/md5.h"
36 #include "mbedtls/ripemd160.h"
37 #include "mbedtls/sha1.h"
38 #include "mbedtls/sha256.h"
39 #include "mbedtls/sha512.h"
40 
41 #if defined(MBEDTLS_PLATFORM_C)
42 #include "mbedtls/platform.h"
43 #else
44 #include <stdlib.h>
45 #define vdb_mbedtls_calloc    calloc
46 #define vdb_mbedtls_free       free
47 #endif
48 
49 #include <string.h>
50 
51 #if defined(MBEDTLS_FS_IO)
52 #include <stdio.h>
53 #endif
54 
55 #if defined(MBEDTLS_MD2_C)
56 const mbedtls_md_info_t vdb_mbedtls_md2_info = {
57     "MD2",
58     MBEDTLS_MD_MD2,
59     16,
60     16,
61 };
62 #endif
63 
64 #if defined(MBEDTLS_MD4_C)
65 const mbedtls_md_info_t vdb_mbedtls_md4_info = {
66     "MD4",
67     MBEDTLS_MD_MD4,
68     16,
69     64,
70 };
71 #endif
72 
73 #if defined(MBEDTLS_MD5_C)
74 const mbedtls_md_info_t vdb_mbedtls_md5_info = {
75     "MD5",
76     MBEDTLS_MD_MD5,
77     16,
78     64,
79 };
80 #endif
81 
82 #if defined(MBEDTLS_RIPEMD160_C)
83 const mbedtls_md_info_t vdb_mbedtls_ripemd160_info = {
84     "RIPEMD160",
85     MBEDTLS_MD_RIPEMD160,
86     20,
87     64,
88 };
89 #endif
90 
91 #if defined(MBEDTLS_SHA1_C)
92 const mbedtls_md_info_t vdb_mbedtls_sha1_info = {
93     "SHA1",
94     MBEDTLS_MD_SHA1,
95     20,
96     64,
97 };
98 #endif
99 
100 #if defined(MBEDTLS_SHA256_C)
101 const mbedtls_md_info_t vdb_mbedtls_sha224_info = {
102     "SHA224",
103     MBEDTLS_MD_SHA224,
104     28,
105     64,
106 };
107 
108 const mbedtls_md_info_t vdb_mbedtls_sha256_info = {
109     "SHA256",
110     MBEDTLS_MD_SHA256,
111     32,
112     64,
113 };
114 #endif
115 
116 #if defined(MBEDTLS_SHA512_C)
117 #if !defined(MBEDTLS_SHA512_NO_SHA384)
118 const mbedtls_md_info_t vdb_mbedtls_sha384_info = {
119     "SHA384",
120     MBEDTLS_MD_SHA384,
121     48,
122     128,
123 };
124 #endif
125 
126 const mbedtls_md_info_t vdb_mbedtls_sha512_info = {
127     "SHA512",
128     MBEDTLS_MD_SHA512,
129     64,
130     128,
131 };
132 #endif
133 
134 /*
135  * Reminder: update profiles in x509_crt.c when adding a new hash!
136  */
137 static const int supported_digests[] = {
138 
139 #if defined(MBEDTLS_SHA512_C)
140         MBEDTLS_MD_SHA512,
141 #if !defined(MBEDTLS_SHA512_NO_SHA384)
142         MBEDTLS_MD_SHA384,
143 #endif
144 #endif
145 
146 #if defined(MBEDTLS_SHA256_C)
147         MBEDTLS_MD_SHA256,
148         MBEDTLS_MD_SHA224,
149 #endif
150 
151 #if defined(MBEDTLS_SHA1_C)
152         MBEDTLS_MD_SHA1,
153 #endif
154 
155 #if defined(MBEDTLS_RIPEMD160_C)
156         MBEDTLS_MD_RIPEMD160,
157 #endif
158 
159 #if defined(MBEDTLS_MD5_C)
160         MBEDTLS_MD_MD5,
161 #endif
162 
163 #if defined(MBEDTLS_MD4_C)
164         MBEDTLS_MD_MD4,
165 #endif
166 
167 #if defined(MBEDTLS_MD2_C)
168         MBEDTLS_MD_MD2,
169 #endif
170 
171         MBEDTLS_MD_NONE
172 };
173 
vdb_mbedtls_md_list(void)174 const int *vdb_mbedtls_md_list( void )
175 {
176     return( supported_digests );
177 }
178 
vdb_mbedtls_md_info_from_string(const char * md_name)179 const mbedtls_md_info_t *vdb_mbedtls_md_info_from_string( const char *md_name )
180 {
181     if( NULL == md_name )
182         return( NULL );
183 
184     /* Get the appropriate digest information */
185 #if defined(MBEDTLS_MD2_C)
186     if( !strcmp( "MD2", md_name ) )
187         return vdb_mbedtls_md_info_from_type( MBEDTLS_MD_MD2 );
188 #endif
189 #if defined(MBEDTLS_MD4_C)
190     if( !strcmp( "MD4", md_name ) )
191         return vdb_mbedtls_md_info_from_type( MBEDTLS_MD_MD4 );
192 #endif
193 #if defined(MBEDTLS_MD5_C)
194     if( !strcmp( "MD5", md_name ) )
195         return vdb_mbedtls_md_info_from_type( MBEDTLS_MD_MD5 );
196 #endif
197 #if defined(MBEDTLS_RIPEMD160_C)
198     if( !strcmp( "RIPEMD160", md_name ) )
199         return vdb_mbedtls_md_info_from_type( MBEDTLS_MD_RIPEMD160 );
200 #endif
201 #if defined(MBEDTLS_SHA1_C)
202     if( !strcmp( "SHA1", md_name ) || !strcmp( "SHA", md_name ) )
203         return vdb_mbedtls_md_info_from_type( MBEDTLS_MD_SHA1 );
204 #endif
205 #if defined(MBEDTLS_SHA256_C)
206     if( !strcmp( "SHA224", md_name ) )
207         return vdb_mbedtls_md_info_from_type( MBEDTLS_MD_SHA224 );
208     if( !strcmp( "SHA256", md_name ) )
209         return vdb_mbedtls_md_info_from_type( MBEDTLS_MD_SHA256 );
210 #endif
211 #if defined(MBEDTLS_SHA512_C)
212 #if !defined(MBEDTLS_SHA512_NO_SHA384)
213     if( !strcmp( "SHA384", md_name ) )
214         return vdb_mbedtls_md_info_from_type( MBEDTLS_MD_SHA384 );
215 #endif
216     if( !strcmp( "SHA512", md_name ) )
217         return vdb_mbedtls_md_info_from_type( MBEDTLS_MD_SHA512 );
218 #endif
219     return( NULL );
220 }
221 
vdb_mbedtls_md_info_from_type(mbedtls_md_type_t md_type)222 const mbedtls_md_info_t *vdb_mbedtls_md_info_from_type( mbedtls_md_type_t md_type )
223 {
224     switch( md_type )
225     {
226 #if defined(MBEDTLS_MD2_C)
227         case MBEDTLS_MD_MD2:
228             return( &vdb_mbedtls_md2_info );
229 #endif
230 #if defined(MBEDTLS_MD4_C)
231         case MBEDTLS_MD_MD4:
232             return( &vdb_mbedtls_md4_info );
233 #endif
234 #if defined(MBEDTLS_MD5_C)
235         case MBEDTLS_MD_MD5:
236             return( &vdb_mbedtls_md5_info );
237 #endif
238 #if defined(MBEDTLS_RIPEMD160_C)
239         case MBEDTLS_MD_RIPEMD160:
240             return( &vdb_mbedtls_ripemd160_info );
241 #endif
242 #if defined(MBEDTLS_SHA1_C)
243         case MBEDTLS_MD_SHA1:
244             return( &vdb_mbedtls_sha1_info );
245 #endif
246 #if defined(MBEDTLS_SHA256_C)
247         case MBEDTLS_MD_SHA224:
248             return( &vdb_mbedtls_sha224_info );
249         case MBEDTLS_MD_SHA256:
250             return( &vdb_mbedtls_sha256_info );
251 #endif
252 #if defined(MBEDTLS_SHA512_C)
253 #if !defined(MBEDTLS_SHA512_NO_SHA384)
254         case MBEDTLS_MD_SHA384:
255             return( &vdb_mbedtls_sha384_info );
256 #endif
257         case MBEDTLS_MD_SHA512:
258             return( &vdb_mbedtls_sha512_info );
259 #endif
260         default:
261             return( NULL );
262     }
263 }
264 
vdb_mbedtls_md_init(mbedtls_md_context_t * ctx)265 void vdb_mbedtls_md_init( mbedtls_md_context_t *ctx )
266 {
267     memset( ctx, 0, sizeof( mbedtls_md_context_t ) );
268 }
269 
vdb_mbedtls_md_free(mbedtls_md_context_t * ctx)270 void vdb_mbedtls_md_free( mbedtls_md_context_t *ctx )
271 {
272     if( ctx == NULL || ctx->md_info == NULL )
273         return;
274 
275     if( ctx->md_ctx != NULL )
276     {
277         switch( ctx->md_info->type )
278         {
279 #if defined(MBEDTLS_MD2_C)
280             case MBEDTLS_MD_MD2:
281                 vdb_mbedtls_md2_free( ctx->md_ctx );
282                 break;
283 #endif
284 #if defined(MBEDTLS_MD4_C)
285             case MBEDTLS_MD_MD4:
286                 vdb_mbedtls_md4_free( ctx->md_ctx );
287                 break;
288 #endif
289 #if defined(MBEDTLS_MD5_C)
290             case MBEDTLS_MD_MD5:
291                 vdb_mbedtls_md5_free( ctx->md_ctx );
292                 break;
293 #endif
294 #if defined(MBEDTLS_RIPEMD160_C)
295             case MBEDTLS_MD_RIPEMD160:
296                 vdb_mbedtls_ripemd160_free( ctx->md_ctx );
297                 break;
298 #endif
299 #if defined(MBEDTLS_SHA1_C)
300             case MBEDTLS_MD_SHA1:
301                 vdb_mbedtls_sha1_free( ctx->md_ctx );
302                 break;
303 #endif
304 #if defined(MBEDTLS_SHA256_C)
305             case MBEDTLS_MD_SHA224:
306             case MBEDTLS_MD_SHA256:
307                 vdb_mbedtls_sha256_free( ctx->md_ctx );
308                 break;
309 #endif
310 #if defined(MBEDTLS_SHA512_C)
311 #if !defined(MBEDTLS_SHA512_NO_SHA384)
312             case MBEDTLS_MD_SHA384:
313 #endif
314             case MBEDTLS_MD_SHA512:
315                 vdb_mbedtls_sha512_free( ctx->md_ctx );
316                 break;
317 #endif
318             default:
319                 /* Shouldn't happen */
320                 break;
321         }
322         vdb_mbedtls_free( ctx->md_ctx );
323     }
324 
325     if( ctx->hmac_ctx != NULL )
326     {
327         vdb_mbedtls_platform_zeroize( ctx->hmac_ctx,
328                                   2 * ctx->md_info->block_size );
329         vdb_mbedtls_free( ctx->hmac_ctx );
330     }
331 
332     vdb_mbedtls_platform_zeroize( ctx, sizeof( mbedtls_md_context_t ) );
333 }
334 
vdb_mbedtls_md_clone(mbedtls_md_context_t * dst,const mbedtls_md_context_t * src)335 int vdb_mbedtls_md_clone( mbedtls_md_context_t *dst,
336                       const mbedtls_md_context_t *src )
337 {
338     if( dst == NULL || dst->md_info == NULL ||
339         src == NULL || src->md_info == NULL ||
340         dst->md_info != src->md_info )
341     {
342         return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
343     }
344 
345     switch( src->md_info->type )
346     {
347 #if defined(MBEDTLS_MD2_C)
348         case MBEDTLS_MD_MD2:
349             vdb_mbedtls_md2_clone( dst->md_ctx, src->md_ctx );
350             break;
351 #endif
352 #if defined(MBEDTLS_MD4_C)
353         case MBEDTLS_MD_MD4:
354             vdb_mbedtls_md4_clone( dst->md_ctx, src->md_ctx );
355             break;
356 #endif
357 #if defined(MBEDTLS_MD5_C)
358         case MBEDTLS_MD_MD5:
359             vdb_mbedtls_md5_clone( dst->md_ctx, src->md_ctx );
360             break;
361 #endif
362 #if defined(MBEDTLS_RIPEMD160_C)
363         case MBEDTLS_MD_RIPEMD160:
364             vdb_mbedtls_ripemd160_clone( dst->md_ctx, src->md_ctx );
365             break;
366 #endif
367 #if defined(MBEDTLS_SHA1_C)
368         case MBEDTLS_MD_SHA1:
369             vdb_mbedtls_sha1_clone( dst->md_ctx, src->md_ctx );
370             break;
371 #endif
372 #if defined(MBEDTLS_SHA256_C)
373         case MBEDTLS_MD_SHA224:
374         case MBEDTLS_MD_SHA256:
375             vdb_mbedtls_sha256_clone( dst->md_ctx, src->md_ctx );
376             break;
377 #endif
378 #if defined(MBEDTLS_SHA512_C)
379 #if !defined(MBEDTLS_SHA512_NO_SHA384)
380         case MBEDTLS_MD_SHA384:
381 #endif
382         case MBEDTLS_MD_SHA512:
383             vdb_mbedtls_sha512_clone( dst->md_ctx, src->md_ctx );
384             break;
385 #endif
386         default:
387             return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
388     }
389 
390     return( 0 );
391 }
392 
393 #if ! defined(MBEDTLS_DEPRECATED_REMOVED)
vdb_mbedtls_md_init_ctx(mbedtls_md_context_t * ctx,const mbedtls_md_info_t * md_info)394 int vdb_mbedtls_md_init_ctx( mbedtls_md_context_t *ctx, const mbedtls_md_info_t *md_info )
395 {
396     return vdb_mbedtls_md_setup( ctx, md_info, 1 );
397 }
398 #endif
399 
400 #define ALLOC( type )                                                   \
401     do {                                                                \
402         ctx->md_ctx = vdb_mbedtls_calloc( 1, sizeof( mbedtls_##type##_context ) ); \
403         if( ctx->md_ctx == NULL )                                       \
404             return( MBEDTLS_ERR_MD_ALLOC_FAILED );                      \
405         vdb_mbedtls_##type##_init( ctx->md_ctx );                           \
406     }                                                                   \
407     while( 0 )
408 
vdb_mbedtls_md_setup(mbedtls_md_context_t * ctx,const mbedtls_md_info_t * md_info,int hmac)409 int vdb_mbedtls_md_setup( mbedtls_md_context_t *ctx, const mbedtls_md_info_t *md_info, int hmac )
410 {
411     if( md_info == NULL || ctx == NULL )
412         return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
413 
414     ctx->md_info = md_info;
415     ctx->md_ctx = NULL;
416     ctx->hmac_ctx = NULL;
417 
418     switch( md_info->type )
419     {
420 #if defined(MBEDTLS_MD2_C)
421         case MBEDTLS_MD_MD2:
422             ALLOC( md2 );
423             break;
424 #endif
425 #if defined(MBEDTLS_MD4_C)
426         case MBEDTLS_MD_MD4:
427             ALLOC( md4 );
428             break;
429 #endif
430 #if defined(MBEDTLS_MD5_C)
431         case MBEDTLS_MD_MD5:
432             ALLOC( md5 );
433             break;
434 #endif
435 #if defined(MBEDTLS_RIPEMD160_C)
436         case MBEDTLS_MD_RIPEMD160:
437             ALLOC( ripemd160 );
438             break;
439 #endif
440 #if defined(MBEDTLS_SHA1_C)
441         case MBEDTLS_MD_SHA1:
442             ALLOC( sha1 );
443             break;
444 #endif
445 #if defined(MBEDTLS_SHA256_C)
446         case MBEDTLS_MD_SHA224:
447         case MBEDTLS_MD_SHA256:
448             ALLOC( sha256 );
449             break;
450 #endif
451 #if defined(MBEDTLS_SHA512_C)
452 #if !defined(MBEDTLS_SHA512_NO_SHA384)
453         case MBEDTLS_MD_SHA384:
454 #endif
455         case MBEDTLS_MD_SHA512:
456             ALLOC( sha512 );
457             break;
458 #endif
459         default:
460             return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
461     }
462 
463     if( hmac != 0 )
464     {
465         ctx->hmac_ctx = vdb_mbedtls_calloc( 2, md_info->block_size );
466         if( ctx->hmac_ctx == NULL )
467         {
468             vdb_mbedtls_md_free( ctx );
469             return( MBEDTLS_ERR_MD_ALLOC_FAILED );
470         }
471     }
472 
473     return( 0 );
474 }
475 #undef ALLOC
476 
vdb_mbedtls_md_starts(mbedtls_md_context_t * ctx)477 int vdb_mbedtls_md_starts( mbedtls_md_context_t *ctx )
478 {
479     if( ctx == NULL || ctx->md_info == NULL )
480         return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
481 
482     switch( ctx->md_info->type )
483     {
484 #if defined(MBEDTLS_MD2_C)
485         case MBEDTLS_MD_MD2:
486             return( vdb_mbedtls_md2_starts_ret( ctx->md_ctx ) );
487 #endif
488 #if defined(MBEDTLS_MD4_C)
489         case MBEDTLS_MD_MD4:
490             return( vdb_mbedtls_md4_starts_ret( ctx->md_ctx ) );
491 #endif
492 #if defined(MBEDTLS_MD5_C)
493         case MBEDTLS_MD_MD5:
494             return( vdb_mbedtls_md5_starts_ret( ctx->md_ctx ) );
495 #endif
496 #if defined(MBEDTLS_RIPEMD160_C)
497         case MBEDTLS_MD_RIPEMD160:
498             return( vdb_mbedtls_ripemd160_starts_ret( ctx->md_ctx ) );
499 #endif
500 #if defined(MBEDTLS_SHA1_C)
501         case MBEDTLS_MD_SHA1:
502             return( vdb_mbedtls_sha1_starts_ret( ctx->md_ctx ) );
503 #endif
504 #if defined(MBEDTLS_SHA256_C)
505         case MBEDTLS_MD_SHA224:
506             return( vdb_mbedtls_sha256_starts_ret( ctx->md_ctx, 1 ) );
507         case MBEDTLS_MD_SHA256:
508             return( vdb_mbedtls_sha256_starts_ret( ctx->md_ctx, 0 ) );
509 #endif
510 #if defined(MBEDTLS_SHA512_C)
511 #if !defined(MBEDTLS_SHA512_NO_SHA384)
512         case MBEDTLS_MD_SHA384:
513             return( vdb_mbedtls_sha512_starts_ret( ctx->md_ctx, 1 ) );
514 #endif
515         case MBEDTLS_MD_SHA512:
516             return( vdb_mbedtls_sha512_starts_ret( ctx->md_ctx, 0 ) );
517 #endif
518         default:
519             return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
520     }
521 }
522 
vdb_mbedtls_md_update(mbedtls_md_context_t * ctx,const unsigned char * input,size_t ilen)523 int vdb_mbedtls_md_update( mbedtls_md_context_t *ctx, const unsigned char *input, size_t ilen )
524 {
525     if( ctx == NULL || ctx->md_info == NULL )
526         return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
527 
528     switch( ctx->md_info->type )
529     {
530 #if defined(MBEDTLS_MD2_C)
531         case MBEDTLS_MD_MD2:
532             return( vdb_mbedtls_md2_update_ret( ctx->md_ctx, input, ilen ) );
533 #endif
534 #if defined(MBEDTLS_MD4_C)
535         case MBEDTLS_MD_MD4:
536             return( vdb_mbedtls_md4_update_ret( ctx->md_ctx, input, ilen ) );
537 #endif
538 #if defined(MBEDTLS_MD5_C)
539         case MBEDTLS_MD_MD5:
540             return( vdb_mbedtls_md5_update_ret( ctx->md_ctx, input, ilen ) );
541 #endif
542 #if defined(MBEDTLS_RIPEMD160_C)
543         case MBEDTLS_MD_RIPEMD160:
544             return( vdb_mbedtls_ripemd160_update_ret( ctx->md_ctx, input, ilen ) );
545 #endif
546 #if defined(MBEDTLS_SHA1_C)
547         case MBEDTLS_MD_SHA1:
548             return( vdb_mbedtls_sha1_update_ret( ctx->md_ctx, input, ilen ) );
549 #endif
550 #if defined(MBEDTLS_SHA256_C)
551         case MBEDTLS_MD_SHA224:
552         case MBEDTLS_MD_SHA256:
553             return( vdb_mbedtls_sha256_update_ret( ctx->md_ctx, input, ilen ) );
554 #endif
555 #if defined(MBEDTLS_SHA512_C)
556 #if !defined(MBEDTLS_SHA512_NO_SHA384)
557         case MBEDTLS_MD_SHA384:
558 #endif
559         case MBEDTLS_MD_SHA512:
560             return( vdb_mbedtls_sha512_update_ret( ctx->md_ctx, input, ilen ) );
561 #endif
562         default:
563             return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
564     }
565 }
566 
vdb_mbedtls_md_finish(mbedtls_md_context_t * ctx,unsigned char * output)567 int vdb_mbedtls_md_finish( mbedtls_md_context_t *ctx, unsigned char *output )
568 {
569     if( ctx == NULL || ctx->md_info == NULL )
570         return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
571 
572     switch( ctx->md_info->type )
573     {
574 #if defined(MBEDTLS_MD2_C)
575         case MBEDTLS_MD_MD2:
576             return( vdb_mbedtls_md2_finish_ret( ctx->md_ctx, output ) );
577 #endif
578 #if defined(MBEDTLS_MD4_C)
579         case MBEDTLS_MD_MD4:
580             return( vdb_mbedtls_md4_finish_ret( ctx->md_ctx, output ) );
581 #endif
582 #if defined(MBEDTLS_MD5_C)
583         case MBEDTLS_MD_MD5:
584             return( vdb_mbedtls_md5_finish_ret( ctx->md_ctx, output ) );
585 #endif
586 #if defined(MBEDTLS_RIPEMD160_C)
587         case MBEDTLS_MD_RIPEMD160:
588             return( vdb_mbedtls_ripemd160_finish_ret( ctx->md_ctx, output ) );
589 #endif
590 #if defined(MBEDTLS_SHA1_C)
591         case MBEDTLS_MD_SHA1:
592             return( vdb_mbedtls_sha1_finish_ret( ctx->md_ctx, output ) );
593 #endif
594 #if defined(MBEDTLS_SHA256_C)
595         case MBEDTLS_MD_SHA224:
596         case MBEDTLS_MD_SHA256:
597             return( vdb_mbedtls_sha256_finish_ret( ctx->md_ctx, output ) );
598 #endif
599 #if defined(MBEDTLS_SHA512_C)
600 #if !defined(MBEDTLS_SHA512_NO_SHA384)
601         case MBEDTLS_MD_SHA384:
602 #endif
603         case MBEDTLS_MD_SHA512:
604             return( vdb_mbedtls_sha512_finish_ret( ctx->md_ctx, output ) );
605 #endif
606         default:
607             return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
608     }
609 }
610 
vdb_mbedtls_md(const mbedtls_md_info_t * md_info,const unsigned char * input,size_t ilen,unsigned char * output)611 int vdb_mbedtls_md( const mbedtls_md_info_t *md_info, const unsigned char *input, size_t ilen,
612             unsigned char *output )
613 {
614     if( md_info == NULL )
615         return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
616 
617     switch( md_info->type )
618     {
619 #if defined(MBEDTLS_MD2_C)
620         case MBEDTLS_MD_MD2:
621             return( vdb_mbedtls_md2_ret( input, ilen, output ) );
622 #endif
623 #if defined(MBEDTLS_MD4_C)
624         case MBEDTLS_MD_MD4:
625             return( vdb_mbedtls_md4_ret( input, ilen, output ) );
626 #endif
627 #if defined(MBEDTLS_MD5_C)
628         case MBEDTLS_MD_MD5:
629             return( vdb_mbedtls_md5_ret( input, ilen, output ) );
630 #endif
631 #if defined(MBEDTLS_RIPEMD160_C)
632         case MBEDTLS_MD_RIPEMD160:
633             return( vdb_mbedtls_ripemd160_ret( input, ilen, output ) );
634 #endif
635 #if defined(MBEDTLS_SHA1_C)
636         case MBEDTLS_MD_SHA1:
637             return( vdb_mbedtls_sha1_ret( input, ilen, output ) );
638 #endif
639 #if defined(MBEDTLS_SHA256_C)
640         case MBEDTLS_MD_SHA224:
641             return( vdb_mbedtls_sha256_ret( input, ilen, output, 1 ) );
642         case MBEDTLS_MD_SHA256:
643             return( vdb_mbedtls_sha256_ret( input, ilen, output, 0 ) );
644 #endif
645 #if defined(MBEDTLS_SHA512_C)
646 #if !defined(MBEDTLS_SHA512_NO_SHA384)
647         case MBEDTLS_MD_SHA384:
648             return( vdb_mbedtls_sha512_ret( input, ilen, output, 1 ) );
649 #endif
650         case MBEDTLS_MD_SHA512:
651             return( vdb_mbedtls_sha512_ret( input, ilen, output, 0 ) );
652 #endif
653         default:
654             return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
655     }
656 }
657 
658 #if defined(MBEDTLS_FS_IO)
vdb_mbedtls_md_file(const mbedtls_md_info_t * md_info,const char * path,unsigned char * output)659 int vdb_mbedtls_md_file( const mbedtls_md_info_t *md_info, const char *path, unsigned char *output )
660 {
661     int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
662     FILE *f;
663     size_t n;
664     mbedtls_md_context_t ctx;
665     unsigned char buf[1024];
666 
667     if( md_info == NULL )
668         return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
669 
670     if( ( f = fopen( path, "rb" ) ) == NULL )
671         return( MBEDTLS_ERR_MD_FILE_IO_ERROR );
672 
673     vdb_mbedtls_md_init( &ctx );
674 
675     if( ( ret = vdb_mbedtls_md_setup( &ctx, md_info, 0 ) ) != 0 )
676         goto cleanup;
677 
678     if( ( ret = vdb_mbedtls_md_starts( &ctx ) ) != 0 )
679         goto cleanup;
680 
681     while( ( n = fread( buf, 1, sizeof( buf ), f ) ) > 0 )
682         if( ( ret = vdb_mbedtls_md_update( &ctx, buf, n ) ) != 0 )
683             goto cleanup;
684 
685     if( ferror( f ) != 0 )
686         ret = MBEDTLS_ERR_MD_FILE_IO_ERROR;
687     else
688         ret = vdb_mbedtls_md_finish( &ctx, output );
689 
690 cleanup:
691     vdb_mbedtls_platform_zeroize( buf, sizeof( buf ) );
692     fclose( f );
693     vdb_mbedtls_md_free( &ctx );
694 
695     return( ret );
696 }
697 #endif /* MBEDTLS_FS_IO */
698 
vdb_mbedtls_md_hmac_starts(mbedtls_md_context_t * ctx,const unsigned char * key,size_t keylen)699 int vdb_mbedtls_md_hmac_starts( mbedtls_md_context_t *ctx, const unsigned char *key, size_t keylen )
700 {
701     int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
702     unsigned char sum[MBEDTLS_MD_MAX_SIZE];
703     unsigned char *ipad, *opad;
704     size_t i;
705 
706     if( ctx == NULL || ctx->md_info == NULL || ctx->hmac_ctx == NULL )
707         return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
708 
709     if( keylen > (size_t) ctx->md_info->block_size )
710     {
711         if( ( ret = vdb_mbedtls_md_starts( ctx ) ) != 0 )
712             goto cleanup;
713         if( ( ret = vdb_mbedtls_md_update( ctx, key, keylen ) ) != 0 )
714             goto cleanup;
715         if( ( ret = vdb_mbedtls_md_finish( ctx, sum ) ) != 0 )
716             goto cleanup;
717 
718         keylen = ctx->md_info->size;
719         key = sum;
720     }
721 
722     ipad = (unsigned char *) ctx->hmac_ctx;
723     opad = (unsigned char *) ctx->hmac_ctx + ctx->md_info->block_size;
724 
725     memset( ipad, 0x36, ctx->md_info->block_size );
726     memset( opad, 0x5C, ctx->md_info->block_size );
727 
728     for( i = 0; i < keylen; i++ )
729     {
730         ipad[i] = (unsigned char)( ipad[i] ^ key[i] );
731         opad[i] = (unsigned char)( opad[i] ^ key[i] );
732     }
733 
734     if( ( ret = vdb_mbedtls_md_starts( ctx ) ) != 0 )
735         goto cleanup;
736     if( ( ret = vdb_mbedtls_md_update( ctx, ipad,
737                                    ctx->md_info->block_size ) ) != 0 )
738         goto cleanup;
739 
740 cleanup:
741     vdb_mbedtls_platform_zeroize( sum, sizeof( sum ) );
742 
743     return( ret );
744 }
745 
vdb_mbedtls_md_hmac_update(mbedtls_md_context_t * ctx,const unsigned char * input,size_t ilen)746 int vdb_mbedtls_md_hmac_update( mbedtls_md_context_t *ctx, const unsigned char *input, size_t ilen )
747 {
748     if( ctx == NULL || ctx->md_info == NULL || ctx->hmac_ctx == NULL )
749         return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
750 
751     return( vdb_mbedtls_md_update( ctx, input, ilen ) );
752 }
753 
vdb_mbedtls_md_hmac_finish(mbedtls_md_context_t * ctx,unsigned char * output)754 int vdb_mbedtls_md_hmac_finish( mbedtls_md_context_t *ctx, unsigned char *output )
755 {
756     int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
757     unsigned char tmp[MBEDTLS_MD_MAX_SIZE];
758     unsigned char *opad;
759 
760     if( ctx == NULL || ctx->md_info == NULL || ctx->hmac_ctx == NULL )
761         return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
762 
763     opad = (unsigned char *) ctx->hmac_ctx + ctx->md_info->block_size;
764 
765     if( ( ret = vdb_mbedtls_md_finish( ctx, tmp ) ) != 0 )
766         return( ret );
767     if( ( ret = vdb_mbedtls_md_starts( ctx ) ) != 0 )
768         return( ret );
769     if( ( ret = vdb_mbedtls_md_update( ctx, opad,
770                                    ctx->md_info->block_size ) ) != 0 )
771         return( ret );
772     if( ( ret = vdb_mbedtls_md_update( ctx, tmp,
773                                    ctx->md_info->size ) ) != 0 )
774         return( ret );
775     return( vdb_mbedtls_md_finish( ctx, output ) );
776 }
777 
vdb_mbedtls_md_hmac_reset(mbedtls_md_context_t * ctx)778 int vdb_mbedtls_md_hmac_reset( mbedtls_md_context_t *ctx )
779 {
780     int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
781     unsigned char *ipad;
782 
783     if( ctx == NULL || ctx->md_info == NULL || ctx->hmac_ctx == NULL )
784         return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
785 
786     ipad = (unsigned char *) ctx->hmac_ctx;
787 
788     if( ( ret = vdb_mbedtls_md_starts( ctx ) ) != 0 )
789         return( ret );
790     return( vdb_mbedtls_md_update( ctx, ipad, ctx->md_info->block_size ) );
791 }
792 
vdb_mbedtls_md_hmac(const mbedtls_md_info_t * md_info,const unsigned char * key,size_t keylen,const unsigned char * input,size_t ilen,unsigned char * output)793 int vdb_mbedtls_md_hmac( const mbedtls_md_info_t *md_info,
794                      const unsigned char *key, size_t keylen,
795                      const unsigned char *input, size_t ilen,
796                      unsigned char *output )
797 {
798     mbedtls_md_context_t ctx;
799     int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
800 
801     if( md_info == NULL )
802         return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
803 
804     vdb_mbedtls_md_init( &ctx );
805 
806     if( ( ret = vdb_mbedtls_md_setup( &ctx, md_info, 1 ) ) != 0 )
807         goto cleanup;
808 
809     if( ( ret = vdb_mbedtls_md_hmac_starts( &ctx, key, keylen ) ) != 0 )
810         goto cleanup;
811     if( ( ret = vdb_mbedtls_md_hmac_update( &ctx, input, ilen ) ) != 0 )
812         goto cleanup;
813     if( ( ret = vdb_mbedtls_md_hmac_finish( &ctx, output ) ) != 0 )
814         goto cleanup;
815 
816 cleanup:
817     vdb_mbedtls_md_free( &ctx );
818 
819     return( ret );
820 }
821 
vdb_mbedtls_md_process(mbedtls_md_context_t * ctx,const unsigned char * data)822 int vdb_mbedtls_md_process( mbedtls_md_context_t *ctx, const unsigned char *data )
823 {
824     if( ctx == NULL || ctx->md_info == NULL )
825         return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
826 
827     switch( ctx->md_info->type )
828     {
829 #if defined(MBEDTLS_MD2_C)
830         case MBEDTLS_MD_MD2:
831             return( vdb_mbedtls_internal_md2_process( ctx->md_ctx ) );
832 #endif
833 #if defined(MBEDTLS_MD4_C)
834         case MBEDTLS_MD_MD4:
835             return( vdb_mbedtls_internal_md4_process( ctx->md_ctx, data ) );
836 #endif
837 #if defined(MBEDTLS_MD5_C)
838         case MBEDTLS_MD_MD5:
839             return( vdb_mbedtls_internal_md5_process( ctx->md_ctx, data ) );
840 #endif
841 #if defined(MBEDTLS_RIPEMD160_C)
842         case MBEDTLS_MD_RIPEMD160:
843             return( vdb_mbedtls_internal_ripemd160_process( ctx->md_ctx, data ) );
844 #endif
845 #if defined(MBEDTLS_SHA1_C)
846         case MBEDTLS_MD_SHA1:
847             return( vdb_mbedtls_internal_sha1_process( ctx->md_ctx, data ) );
848 #endif
849 #if defined(MBEDTLS_SHA256_C)
850         case MBEDTLS_MD_SHA224:
851         case MBEDTLS_MD_SHA256:
852             return( vdb_mbedtls_internal_sha256_process( ctx->md_ctx, data ) );
853 #endif
854 #if defined(MBEDTLS_SHA512_C)
855 #if !defined(MBEDTLS_SHA512_NO_SHA384)
856         case MBEDTLS_MD_SHA384:
857 #endif
858         case MBEDTLS_MD_SHA512:
859             return( vdb_mbedtls_internal_sha512_process( ctx->md_ctx, data ) );
860 #endif
861         default:
862             return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
863     }
864 }
865 
vdb_mbedtls_md_get_size(const mbedtls_md_info_t * md_info)866 unsigned char vdb_mbedtls_md_get_size( const mbedtls_md_info_t *md_info )
867 {
868     if( md_info == NULL )
869         return( 0 );
870 
871     return md_info->size;
872 }
873 
vdb_mbedtls_md_get_type(const mbedtls_md_info_t * md_info)874 mbedtls_md_type_t vdb_mbedtls_md_get_type( const mbedtls_md_info_t *md_info )
875 {
876     if( md_info == NULL )
877         return( MBEDTLS_MD_NONE );
878 
879     return md_info->type;
880 }
881 
vdb_mbedtls_md_get_name(const mbedtls_md_info_t * md_info)882 const char *vdb_mbedtls_md_get_name( const mbedtls_md_info_t *md_info )
883 {
884     if( md_info == NULL )
885         return( NULL );
886 
887     return md_info->name;
888 }
889 
890 #endif /* MBEDTLS_MD_C */
891