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