Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
8774 | rgimad | 1 | /** |
2 | * \file md_wrap.c |
||
3 | * |
||
4 | * \brief Generic message digest wrapper for mbed TLS |
||
5 | * |
||
6 | * \author Adriaan de Jong |
||
7 | * |
||
8 | * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved |
||
9 | * SPDX-License-Identifier: GPL-2.0 |
||
10 | * |
||
11 | * This program is free software; you can redistribute it and/or modify |
||
12 | * it under the terms of the GNU General Public License as published by |
||
13 | * the Free Software Foundation; either version 2 of the License, or |
||
14 | * (at your option) any later version. |
||
15 | * |
||
16 | * This program is distributed in the hope that it will be useful, |
||
17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||
19 | * GNU General Public License for more details. |
||
20 | * |
||
21 | * You should have received a copy of the GNU General Public License along |
||
22 | * with this program; if not, write to the Free Software Foundation, Inc., |
||
23 | * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. |
||
24 | * |
||
25 | * This file is part of mbed TLS (https://tls.mbed.org) |
||
26 | */ |
||
27 | |||
28 | #if !defined(MBEDTLS_CONFIG_FILE) |
||
29 | #include "mbedtls/config.h" |
||
30 | #else |
||
31 | #include MBEDTLS_CONFIG_FILE |
||
32 | #endif |
||
33 | |||
34 | #if defined(MBEDTLS_MD_C) |
||
35 | |||
36 | #include "mbedtls/md_internal.h" |
||
37 | |||
38 | #if defined(MBEDTLS_MD2_C) |
||
39 | #include "mbedtls/md2.h" |
||
40 | #endif |
||
41 | |||
42 | #if defined(MBEDTLS_MD4_C) |
||
43 | #include "mbedtls/md4.h" |
||
44 | #endif |
||
45 | |||
46 | #if defined(MBEDTLS_MD5_C) |
||
47 | #include "mbedtls/md5.h" |
||
48 | #endif |
||
49 | |||
50 | #if defined(MBEDTLS_RIPEMD160_C) |
||
51 | #include "mbedtls/ripemd160.h" |
||
52 | #endif |
||
53 | |||
54 | #if defined(MBEDTLS_SHA1_C) |
||
55 | #include "mbedtls/sha1.h" |
||
56 | #endif |
||
57 | |||
58 | #if defined(MBEDTLS_SHA256_C) |
||
59 | #include "mbedtls/sha256.h" |
||
60 | #endif |
||
61 | |||
62 | #if defined(MBEDTLS_SHA512_C) |
||
63 | #include "mbedtls/sha512.h" |
||
64 | #endif |
||
65 | |||
66 | #if defined(MBEDTLS_PLATFORM_C) |
||
67 | #include "mbedtls/platform.h" |
||
68 | #else |
||
69 | #include |
||
70 | #define mbedtls_calloc calloc |
||
71 | #define mbedtls_free free |
||
72 | #endif |
||
73 | |||
74 | #if defined(MBEDTLS_MD2_C) |
||
75 | |||
76 | static int md2_starts_wrap( void *ctx ) |
||
77 | { |
||
78 | return( mbedtls_md2_starts_ret( (mbedtls_md2_context *) ctx ) ); |
||
79 | } |
||
80 | |||
81 | static int md2_update_wrap( void *ctx, const unsigned char *input, |
||
82 | size_t ilen ) |
||
83 | { |
||
84 | return( mbedtls_md2_update_ret( (mbedtls_md2_context *) ctx, input, ilen ) ); |
||
85 | } |
||
86 | |||
87 | static int md2_finish_wrap( void *ctx, unsigned char *output ) |
||
88 | { |
||
89 | return( mbedtls_md2_finish_ret( (mbedtls_md2_context *) ctx, output ) ); |
||
90 | } |
||
91 | |||
92 | static void *md2_ctx_alloc( void ) |
||
93 | { |
||
94 | void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_md2_context ) ); |
||
95 | |||
96 | if( ctx != NULL ) |
||
97 | mbedtls_md2_init( (mbedtls_md2_context *) ctx ); |
||
98 | |||
99 | return( ctx ); |
||
100 | } |
||
101 | |||
102 | static void md2_ctx_free( void *ctx ) |
||
103 | { |
||
104 | mbedtls_md2_free( (mbedtls_md2_context *) ctx ); |
||
105 | mbedtls_free( ctx ); |
||
106 | } |
||
107 | |||
108 | static void md2_clone_wrap( void *dst, const void *src ) |
||
109 | { |
||
110 | mbedtls_md2_clone( (mbedtls_md2_context *) dst, |
||
111 | (const mbedtls_md2_context *) src ); |
||
112 | } |
||
113 | |||
114 | static int md2_process_wrap( void *ctx, const unsigned char *data ) |
||
115 | { |
||
116 | ((void) data); |
||
117 | |||
118 | return( mbedtls_internal_md2_process( (mbedtls_md2_context *) ctx ) ); |
||
119 | } |
||
120 | |||
121 | const mbedtls_md_info_t mbedtls_md2_info = { |
||
122 | MBEDTLS_MD_MD2, |
||
123 | "MD2", |
||
124 | 16, |
||
125 | 16, |
||
126 | md2_starts_wrap, |
||
127 | md2_update_wrap, |
||
128 | md2_finish_wrap, |
||
129 | mbedtls_md2_ret, |
||
130 | md2_ctx_alloc, |
||
131 | md2_ctx_free, |
||
132 | md2_clone_wrap, |
||
133 | md2_process_wrap, |
||
134 | }; |
||
135 | |||
136 | #endif /* MBEDTLS_MD2_C */ |
||
137 | |||
138 | #if defined(MBEDTLS_MD4_C) |
||
139 | |||
140 | static int md4_starts_wrap( void *ctx ) |
||
141 | { |
||
142 | return( mbedtls_md4_starts_ret( (mbedtls_md4_context *) ctx ) ); |
||
143 | } |
||
144 | |||
145 | static int md4_update_wrap( void *ctx, const unsigned char *input, |
||
146 | size_t ilen ) |
||
147 | { |
||
148 | return( mbedtls_md4_update_ret( (mbedtls_md4_context *) ctx, input, ilen ) ); |
||
149 | } |
||
150 | |||
151 | static int md4_finish_wrap( void *ctx, unsigned char *output ) |
||
152 | { |
||
153 | return( mbedtls_md4_finish_ret( (mbedtls_md4_context *) ctx, output ) ); |
||
154 | } |
||
155 | |||
156 | static void *md4_ctx_alloc( void ) |
||
157 | { |
||
158 | void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_md4_context ) ); |
||
159 | |||
160 | if( ctx != NULL ) |
||
161 | mbedtls_md4_init( (mbedtls_md4_context *) ctx ); |
||
162 | |||
163 | return( ctx ); |
||
164 | } |
||
165 | |||
166 | static void md4_ctx_free( void *ctx ) |
||
167 | { |
||
168 | mbedtls_md4_free( (mbedtls_md4_context *) ctx ); |
||
169 | mbedtls_free( ctx ); |
||
170 | } |
||
171 | |||
172 | static void md4_clone_wrap( void *dst, const void *src ) |
||
173 | { |
||
174 | mbedtls_md4_clone( (mbedtls_md4_context *) dst, |
||
175 | (const mbedtls_md4_context *) src ); |
||
176 | } |
||
177 | |||
178 | static int md4_process_wrap( void *ctx, const unsigned char *data ) |
||
179 | { |
||
180 | return( mbedtls_internal_md4_process( (mbedtls_md4_context *) ctx, data ) ); |
||
181 | } |
||
182 | |||
183 | const mbedtls_md_info_t mbedtls_md4_info = { |
||
184 | MBEDTLS_MD_MD4, |
||
185 | "MD4", |
||
186 | 16, |
||
187 | 64, |
||
188 | md4_starts_wrap, |
||
189 | md4_update_wrap, |
||
190 | md4_finish_wrap, |
||
191 | mbedtls_md4_ret, |
||
192 | md4_ctx_alloc, |
||
193 | md4_ctx_free, |
||
194 | md4_clone_wrap, |
||
195 | md4_process_wrap, |
||
196 | }; |
||
197 | |||
198 | #endif /* MBEDTLS_MD4_C */ |
||
199 | |||
200 | #if defined(MBEDTLS_MD5_C) |
||
201 | |||
202 | static int md5_starts_wrap( void *ctx ) |
||
203 | { |
||
204 | return( mbedtls_md5_starts_ret( (mbedtls_md5_context *) ctx ) ); |
||
205 | } |
||
206 | |||
207 | static int md5_update_wrap( void *ctx, const unsigned char *input, |
||
208 | size_t ilen ) |
||
209 | { |
||
210 | return( mbedtls_md5_update_ret( (mbedtls_md5_context *) ctx, input, ilen ) ); |
||
211 | } |
||
212 | |||
213 | static int md5_finish_wrap( void *ctx, unsigned char *output ) |
||
214 | { |
||
215 | return( mbedtls_md5_finish_ret( (mbedtls_md5_context *) ctx, output ) ); |
||
216 | } |
||
217 | |||
218 | static void *md5_ctx_alloc( void ) |
||
219 | { |
||
220 | void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_md5_context ) ); |
||
221 | |||
222 | if( ctx != NULL ) |
||
223 | mbedtls_md5_init( (mbedtls_md5_context *) ctx ); |
||
224 | |||
225 | return( ctx ); |
||
226 | } |
||
227 | |||
228 | static void md5_ctx_free( void *ctx ) |
||
229 | { |
||
230 | mbedtls_md5_free( (mbedtls_md5_context *) ctx ); |
||
231 | mbedtls_free( ctx ); |
||
232 | } |
||
233 | |||
234 | static void md5_clone_wrap( void *dst, const void *src ) |
||
235 | { |
||
236 | mbedtls_md5_clone( (mbedtls_md5_context *) dst, |
||
237 | (const mbedtls_md5_context *) src ); |
||
238 | } |
||
239 | |||
240 | static int md5_process_wrap( void *ctx, const unsigned char *data ) |
||
241 | { |
||
242 | return( mbedtls_internal_md5_process( (mbedtls_md5_context *) ctx, data ) ); |
||
243 | } |
||
244 | |||
245 | const mbedtls_md_info_t mbedtls_md5_info = { |
||
246 | MBEDTLS_MD_MD5, |
||
247 | "MD5", |
||
248 | 16, |
||
249 | 64, |
||
250 | md5_starts_wrap, |
||
251 | md5_update_wrap, |
||
252 | md5_finish_wrap, |
||
253 | mbedtls_md5_ret, |
||
254 | md5_ctx_alloc, |
||
255 | md5_ctx_free, |
||
256 | md5_clone_wrap, |
||
257 | md5_process_wrap, |
||
258 | }; |
||
259 | |||
260 | #endif /* MBEDTLS_MD5_C */ |
||
261 | |||
262 | #if defined(MBEDTLS_RIPEMD160_C) |
||
263 | |||
264 | static int ripemd160_starts_wrap( void *ctx ) |
||
265 | { |
||
266 | return( mbedtls_ripemd160_starts_ret( (mbedtls_ripemd160_context *) ctx ) ); |
||
267 | } |
||
268 | |||
269 | static int ripemd160_update_wrap( void *ctx, const unsigned char *input, |
||
270 | size_t ilen ) |
||
271 | { |
||
272 | return( mbedtls_ripemd160_update_ret( (mbedtls_ripemd160_context *) ctx, |
||
273 | input, ilen ) ); |
||
274 | } |
||
275 | |||
276 | static int ripemd160_finish_wrap( void *ctx, unsigned char *output ) |
||
277 | { |
||
278 | return( mbedtls_ripemd160_finish_ret( (mbedtls_ripemd160_context *) ctx, |
||
279 | output ) ); |
||
280 | } |
||
281 | |||
282 | static void *ripemd160_ctx_alloc( void ) |
||
283 | { |
||
284 | void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_ripemd160_context ) ); |
||
285 | |||
286 | if( ctx != NULL ) |
||
287 | mbedtls_ripemd160_init( (mbedtls_ripemd160_context *) ctx ); |
||
288 | |||
289 | return( ctx ); |
||
290 | } |
||
291 | |||
292 | static void ripemd160_ctx_free( void *ctx ) |
||
293 | { |
||
294 | mbedtls_ripemd160_free( (mbedtls_ripemd160_context *) ctx ); |
||
295 | mbedtls_free( ctx ); |
||
296 | } |
||
297 | |||
298 | static void ripemd160_clone_wrap( void *dst, const void *src ) |
||
299 | { |
||
300 | mbedtls_ripemd160_clone( (mbedtls_ripemd160_context *) dst, |
||
301 | (const mbedtls_ripemd160_context *) src ); |
||
302 | } |
||
303 | |||
304 | static int ripemd160_process_wrap( void *ctx, const unsigned char *data ) |
||
305 | { |
||
306 | return( mbedtls_internal_ripemd160_process( |
||
307 | (mbedtls_ripemd160_context *) ctx, data ) ); |
||
308 | } |
||
309 | |||
310 | const mbedtls_md_info_t mbedtls_ripemd160_info = { |
||
311 | MBEDTLS_MD_RIPEMD160, |
||
312 | "RIPEMD160", |
||
313 | 20, |
||
314 | 64, |
||
315 | ripemd160_starts_wrap, |
||
316 | ripemd160_update_wrap, |
||
317 | ripemd160_finish_wrap, |
||
318 | mbedtls_ripemd160_ret, |
||
319 | ripemd160_ctx_alloc, |
||
320 | ripemd160_ctx_free, |
||
321 | ripemd160_clone_wrap, |
||
322 | ripemd160_process_wrap, |
||
323 | }; |
||
324 | |||
325 | #endif /* MBEDTLS_RIPEMD160_C */ |
||
326 | |||
327 | #if defined(MBEDTLS_SHA1_C) |
||
328 | |||
329 | static int sha1_starts_wrap( void *ctx ) |
||
330 | { |
||
331 | return( mbedtls_sha1_starts_ret( (mbedtls_sha1_context *) ctx ) ); |
||
332 | } |
||
333 | |||
334 | static int sha1_update_wrap( void *ctx, const unsigned char *input, |
||
335 | size_t ilen ) |
||
336 | { |
||
337 | return( mbedtls_sha1_update_ret( (mbedtls_sha1_context *) ctx, |
||
338 | input, ilen ) ); |
||
339 | } |
||
340 | |||
341 | static int sha1_finish_wrap( void *ctx, unsigned char *output ) |
||
342 | { |
||
343 | return( mbedtls_sha1_finish_ret( (mbedtls_sha1_context *) ctx, output ) ); |
||
344 | } |
||
345 | |||
346 | static void *sha1_ctx_alloc( void ) |
||
347 | { |
||
348 | void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_sha1_context ) ); |
||
349 | |||
350 | if( ctx != NULL ) |
||
351 | mbedtls_sha1_init( (mbedtls_sha1_context *) ctx ); |
||
352 | |||
353 | return( ctx ); |
||
354 | } |
||
355 | |||
356 | static void sha1_clone_wrap( void *dst, const void *src ) |
||
357 | { |
||
358 | mbedtls_sha1_clone( (mbedtls_sha1_context *) dst, |
||
359 | (const mbedtls_sha1_context *) src ); |
||
360 | } |
||
361 | |||
362 | static void sha1_ctx_free( void *ctx ) |
||
363 | { |
||
364 | mbedtls_sha1_free( (mbedtls_sha1_context *) ctx ); |
||
365 | mbedtls_free( ctx ); |
||
366 | } |
||
367 | |||
368 | static int sha1_process_wrap( void *ctx, const unsigned char *data ) |
||
369 | { |
||
370 | return( mbedtls_internal_sha1_process( (mbedtls_sha1_context *) ctx, |
||
371 | data ) ); |
||
372 | } |
||
373 | |||
374 | const mbedtls_md_info_t mbedtls_sha1_info = { |
||
375 | MBEDTLS_MD_SHA1, |
||
376 | "SHA1", |
||
377 | 20, |
||
378 | 64, |
||
379 | sha1_starts_wrap, |
||
380 | sha1_update_wrap, |
||
381 | sha1_finish_wrap, |
||
382 | mbedtls_sha1_ret, |
||
383 | sha1_ctx_alloc, |
||
384 | sha1_ctx_free, |
||
385 | sha1_clone_wrap, |
||
386 | sha1_process_wrap, |
||
387 | }; |
||
388 | |||
389 | #endif /* MBEDTLS_SHA1_C */ |
||
390 | |||
391 | /* |
||
392 | * Wrappers for generic message digests |
||
393 | */ |
||
394 | #if defined(MBEDTLS_SHA256_C) |
||
395 | |||
396 | static int sha224_starts_wrap( void *ctx ) |
||
397 | { |
||
398 | return( mbedtls_sha256_starts_ret( (mbedtls_sha256_context *) ctx, 1 ) ); |
||
399 | } |
||
400 | |||
401 | static int sha224_update_wrap( void *ctx, const unsigned char *input, |
||
402 | size_t ilen ) |
||
403 | { |
||
404 | return( mbedtls_sha256_update_ret( (mbedtls_sha256_context *) ctx, |
||
405 | input, ilen ) ); |
||
406 | } |
||
407 | |||
408 | static int sha224_finish_wrap( void *ctx, unsigned char *output ) |
||
409 | { |
||
410 | return( mbedtls_sha256_finish_ret( (mbedtls_sha256_context *) ctx, |
||
411 | output ) ); |
||
412 | } |
||
413 | |||
414 | static int sha224_wrap( const unsigned char *input, size_t ilen, |
||
415 | unsigned char *output ) |
||
416 | { |
||
417 | return( mbedtls_sha256_ret( input, ilen, output, 1 ) ); |
||
418 | } |
||
419 | |||
420 | static void *sha224_ctx_alloc( void ) |
||
421 | { |
||
422 | void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_sha256_context ) ); |
||
423 | |||
424 | if( ctx != NULL ) |
||
425 | mbedtls_sha256_init( (mbedtls_sha256_context *) ctx ); |
||
426 | |||
427 | return( ctx ); |
||
428 | } |
||
429 | |||
430 | static void sha224_ctx_free( void *ctx ) |
||
431 | { |
||
432 | mbedtls_sha256_free( (mbedtls_sha256_context *) ctx ); |
||
433 | mbedtls_free( ctx ); |
||
434 | } |
||
435 | |||
436 | static void sha224_clone_wrap( void *dst, const void *src ) |
||
437 | { |
||
438 | mbedtls_sha256_clone( (mbedtls_sha256_context *) dst, |
||
439 | (const mbedtls_sha256_context *) src ); |
||
440 | } |
||
441 | |||
442 | static int sha224_process_wrap( void *ctx, const unsigned char *data ) |
||
443 | { |
||
444 | return( mbedtls_internal_sha256_process( (mbedtls_sha256_context *) ctx, |
||
445 | data ) ); |
||
446 | } |
||
447 | |||
448 | const mbedtls_md_info_t mbedtls_sha224_info = { |
||
449 | MBEDTLS_MD_SHA224, |
||
450 | "SHA224", |
||
451 | 28, |
||
452 | 64, |
||
453 | sha224_starts_wrap, |
||
454 | sha224_update_wrap, |
||
455 | sha224_finish_wrap, |
||
456 | sha224_wrap, |
||
457 | sha224_ctx_alloc, |
||
458 | sha224_ctx_free, |
||
459 | sha224_clone_wrap, |
||
460 | sha224_process_wrap, |
||
461 | }; |
||
462 | |||
463 | static int sha256_starts_wrap( void *ctx ) |
||
464 | { |
||
465 | return( mbedtls_sha256_starts_ret( (mbedtls_sha256_context *) ctx, 0 ) ); |
||
466 | } |
||
467 | |||
468 | static int sha256_wrap( const unsigned char *input, size_t ilen, |
||
469 | unsigned char *output ) |
||
470 | { |
||
471 | return( mbedtls_sha256_ret( input, ilen, output, 0 ) ); |
||
472 | } |
||
473 | |||
474 | const mbedtls_md_info_t mbedtls_sha256_info = { |
||
475 | MBEDTLS_MD_SHA256, |
||
476 | "SHA256", |
||
477 | 32, |
||
478 | 64, |
||
479 | sha256_starts_wrap, |
||
480 | sha224_update_wrap, |
||
481 | sha224_finish_wrap, |
||
482 | sha256_wrap, |
||
483 | sha224_ctx_alloc, |
||
484 | sha224_ctx_free, |
||
485 | sha224_clone_wrap, |
||
486 | sha224_process_wrap, |
||
487 | }; |
||
488 | |||
489 | #endif /* MBEDTLS_SHA256_C */ |
||
490 | |||
491 | #if defined(MBEDTLS_SHA512_C) |
||
492 | |||
493 | static int sha384_starts_wrap( void *ctx ) |
||
494 | { |
||
495 | return( mbedtls_sha512_starts_ret( (mbedtls_sha512_context *) ctx, 1 ) ); |
||
496 | } |
||
497 | |||
498 | static int sha384_update_wrap( void *ctx, const unsigned char *input, |
||
499 | size_t ilen ) |
||
500 | { |
||
501 | return( mbedtls_sha512_update_ret( (mbedtls_sha512_context *) ctx, |
||
502 | input, ilen ) ); |
||
503 | } |
||
504 | |||
505 | static int sha384_finish_wrap( void *ctx, unsigned char *output ) |
||
506 | { |
||
507 | return( mbedtls_sha512_finish_ret( (mbedtls_sha512_context *) ctx, |
||
508 | output ) ); |
||
509 | } |
||
510 | |||
511 | static int sha384_wrap( const unsigned char *input, size_t ilen, |
||
512 | unsigned char *output ) |
||
513 | { |
||
514 | return( mbedtls_sha512_ret( input, ilen, output, 1 ) ); |
||
515 | } |
||
516 | |||
517 | static void *sha384_ctx_alloc( void ) |
||
518 | { |
||
519 | void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_sha512_context ) ); |
||
520 | |||
521 | if( ctx != NULL ) |
||
522 | mbedtls_sha512_init( (mbedtls_sha512_context *) ctx ); |
||
523 | |||
524 | return( ctx ); |
||
525 | } |
||
526 | |||
527 | static void sha384_ctx_free( void *ctx ) |
||
528 | { |
||
529 | mbedtls_sha512_free( (mbedtls_sha512_context *) ctx ); |
||
530 | mbedtls_free( ctx ); |
||
531 | } |
||
532 | |||
533 | static void sha384_clone_wrap( void *dst, const void *src ) |
||
534 | { |
||
535 | mbedtls_sha512_clone( (mbedtls_sha512_context *) dst, |
||
536 | (const mbedtls_sha512_context *) src ); |
||
537 | } |
||
538 | |||
539 | static int sha384_process_wrap( void *ctx, const unsigned char *data ) |
||
540 | { |
||
541 | return( mbedtls_internal_sha512_process( (mbedtls_sha512_context *) ctx, |
||
542 | data ) ); |
||
543 | } |
||
544 | |||
545 | const mbedtls_md_info_t mbedtls_sha384_info = { |
||
546 | MBEDTLS_MD_SHA384, |
||
547 | "SHA384", |
||
548 | 48, |
||
549 | 128, |
||
550 | sha384_starts_wrap, |
||
551 | sha384_update_wrap, |
||
552 | sha384_finish_wrap, |
||
553 | sha384_wrap, |
||
554 | sha384_ctx_alloc, |
||
555 | sha384_ctx_free, |
||
556 | sha384_clone_wrap, |
||
557 | sha384_process_wrap, |
||
558 | }; |
||
559 | |||
560 | static int sha512_starts_wrap( void *ctx ) |
||
561 | { |
||
562 | return( mbedtls_sha512_starts_ret( (mbedtls_sha512_context *) ctx, 0 ) ); |
||
563 | } |
||
564 | |||
565 | static int sha512_wrap( const unsigned char *input, size_t ilen, |
||
566 | unsigned char *output ) |
||
567 | { |
||
568 | return( mbedtls_sha512_ret( input, ilen, output, 0 ) ); |
||
569 | } |
||
570 | |||
571 | const mbedtls_md_info_t mbedtls_sha512_info = { |
||
572 | MBEDTLS_MD_SHA512, |
||
573 | "SHA512", |
||
574 | 64, |
||
575 | 128, |
||
576 | sha512_starts_wrap, |
||
577 | sha384_update_wrap, |
||
578 | sha384_finish_wrap, |
||
579 | sha512_wrap, |
||
580 | sha384_ctx_alloc, |
||
581 | sha384_ctx_free, |
||
582 | sha384_clone_wrap, |
||
583 | sha384_process_wrap, |
||
584 | }; |
||
585 | |||
586 | #endif /* MBEDTLS_SHA512_C */ |
||
587 | |||
588 | #endif /* MBEDTLS_MD_C */ |