luna - wolfssl/wolfcrypt/src/hash.c

   1/* hash.c
   2 *
   3 * Copyright (C) 2006-2026 wolfSSL Inc.
   4 *
   5 * This file is part of wolfSSL.
   6 *
   7 * wolfSSL is free software; you can redistribute it and/or modify
   8 * it under the terms of the GNU General Public License as published by
   9 * the Free Software Foundation; either version 3 of the License, or
  10 * (at your option) any later version.
  11 *
  12 * wolfSSL is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program; if not, write to the Free Software
  19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
  20 */
  21
  22#include <wolfssl/wolfcrypt/libwolfssl_sources.h>
  23
  24#ifndef NO_ASN
  25#include <wolfssl/wolfcrypt/asn.h>
  26#endif
  27
  28#include <wolfssl/wolfcrypt/hash.h>
  29#include <wolfssl/wolfcrypt/hmac.h>
  30#include <wolfssl/wolfcrypt/cryptocb.h>
  31
  32#ifdef NO_INLINE
  33    #include <wolfssl/wolfcrypt/misc.h>
  34#else
  35    #define WOLFSSL_MISC_INCLUDED
  36    #include <wolfcrypt/src/misc.c>
  37#endif
  38
  39
  40#if !defined(NO_PWDBASED) || !defined(NO_ASN)
  41/* function converts int hash type to enum */
  42enum wc_HashType wc_HashTypeConvert(int hashType)
  43{
  44    /* Default to hash type none as error */
  45    enum wc_HashType eHashType = WC_HASH_TYPE_NONE;
  46#if defined(HAVE_FIPS) || defined(HAVE_SELFTEST)
  47    /* original FIPSv1  and CAVP selftest require a mapping for unique hash
  48       type to wc_HashType */
  49    switch (hashType) {
  50    #ifndef NO_MD5
  51        case WC_MD5:
  52            eHashType = WC_HASH_TYPE_MD5;
  53            break;
  54    #endif /* !NO_MD5 */
  55    #ifndef NO_SHA
  56        case WC_SHA:
  57            eHashType = WC_HASH_TYPE_SHA;
  58            break;
  59    #endif /* !NO_SHA */
  60
  61    #ifdef WOLFSSL_SHA224
  62        case WC_SHA224:
  63            eHashType = WC_HASH_TYPE_SHA224;
  64            break;
  65    #endif /* WOLFSSL_SHA224 */
  66
  67    #ifndef NO_SHA256
  68        case WC_SHA256:
  69            eHashType = WC_HASH_TYPE_SHA256;
  70            break;
  71    #endif /* !NO_SHA256 */
  72
  73    #ifdef WOLFSSL_SHA384
  74        case WC_SHA384:
  75            eHashType = WC_HASH_TYPE_SHA384;
  76            break;
  77    #endif /* WOLFSSL_SHA384 */
  78    #ifdef WOLFSSL_SHA512
  79        case WC_SHA512:
  80            eHashType = WC_HASH_TYPE_SHA512;
  81            break;
  82    #if !defined(WOLFSSL_NOSHA512_224)
  83        case WC_SHA512_224:
  84            eHashType = WC_HASH_TYPE_SHA512_224;
  85            break;
  86    #endif
  87    #if !defined(WOLFSSL_NOSHA512_256)
  88        case WC_SHA512_256:
  89            eHashType = WC_HASH_TYPE_SHA512_256;
  90            break;
  91    #endif
  92    #endif /* WOLFSSL_SHA512 */
  93    #ifdef WOLFSSL_SHA3
  94        case WC_SHA3_224:
  95            eHashType = WC_HASH_TYPE_SHA3_224;
  96            break;
  97        case WC_SHA3_256:
  98            eHashType = WC_HASH_TYPE_SHA3_256;
  99            break;
 100        case WC_SHA3_384:
 101            eHashType = WC_HASH_TYPE_SHA3_384;
 102            break;
 103        case WC_SHA3_512:
 104            eHashType = WC_HASH_TYPE_SHA3_512;
 105            break;
 106    #endif /* WOLFSSL_SHA3 */
 107    #ifdef WOLFSSL_SM3
 108        case WC_SM3:
 109            eHashType = WC_HASH_TYPE_SM3;
 110            break;
 111    #endif
 112        default:
 113            eHashType = WC_HASH_TYPE_NONE;
 114            break;
 115    }
 116#else
 117    /* current master uses same unique types as wc_HashType */
 118    if (hashType > 0 && hashType <= WC_HASH_TYPE_MAX) {
 119        eHashType = (enum wc_HashType)hashType;
 120    }
 121#endif
 122    return eHashType;
 123}
 124#endif /* !NO_PWDBASED || !NO_ASN */
 125
 126#if !defined(NO_ASN) || !defined(NO_DH) || defined(HAVE_ECC)
 127
 128int wc_HashGetOID(enum wc_HashType hash_type)
 129{
 130    int oid;
 131    switch(hash_type)
 132    {
 133        case WC_HASH_TYPE_MD2:
 134        #ifdef WOLFSSL_MD2
 135            oid = MD2h;
 136        #else
 137            oid = HASH_TYPE_E;
 138        #endif
 139            break;
 140        case WC_HASH_TYPE_MD5_SHA:
 141        #if !defined(NO_MD5) && !defined(NO_SHA)
 142            oid = MD5h;
 143        #else
 144            oid = HASH_TYPE_E;
 145        #endif
 146            break;
 147        case WC_HASH_TYPE_MD5:
 148        #ifndef NO_MD5
 149            oid = MD5h;
 150        #else
 151            oid = HASH_TYPE_E;
 152        #endif
 153            break;
 154        case WC_HASH_TYPE_SHA:
 155        #ifndef NO_SHA
 156            oid = SHAh;
 157        #else
 158            oid = HASH_TYPE_E;
 159        #endif
 160            break;
 161        case WC_HASH_TYPE_SHA224:
 162        #ifdef WOLFSSL_SHA224
 163            oid = SHA224h;
 164        #else
 165            oid = HASH_TYPE_E;
 166        #endif
 167            break;
 168        case WC_HASH_TYPE_SHA256:
 169        #ifndef NO_SHA256
 170            oid = SHA256h;
 171        #else
 172            oid = HASH_TYPE_E;
 173        #endif
 174            break;
 175        case WC_HASH_TYPE_SHA384:
 176        #ifdef WOLFSSL_SHA384
 177            oid = SHA384h;
 178        #else
 179            oid = HASH_TYPE_E;
 180        #endif
 181            break;
 182        case WC_HASH_TYPE_SHA512:
 183        #ifdef WOLFSSL_SHA512
 184            oid = SHA512h;
 185        #else
 186            oid = HASH_TYPE_E;
 187        #endif
 188            break;
 189        case WC_HASH_TYPE_SHA512_224:
 190        #if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224)
 191            oid = SHA512_224h;
 192        #else
 193            oid = HASH_TYPE_E;
 194        #endif
 195            break;
 196        case WC_HASH_TYPE_SHA512_256:
 197        #if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256)
 198            oid = SHA512_256h;
 199        #else
 200            oid = HASH_TYPE_E;
 201        #endif
 202            break;
 203        case WC_HASH_TYPE_SHA3_224:
 204        #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224)
 205            oid = SHA3_224h;
 206        #else
 207            oid = HASH_TYPE_E;
 208        #endif
 209            break;
 210        case WC_HASH_TYPE_SHA3_256:
 211        #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256)
 212            oid = SHA3_256h;
 213        #else
 214            oid = HASH_TYPE_E;
 215        #endif
 216            break;
 217        case WC_HASH_TYPE_SHA3_384:
 218        #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384)
 219            oid = SHA3_384h;
 220        #else
 221            oid = HASH_TYPE_E;
 222        #endif
 223            break;
 224        case WC_HASH_TYPE_SHA3_512:
 225        #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512)
 226            oid = SHA3_512h;
 227        #else
 228            oid = HASH_TYPE_E;
 229        #endif
 230            break;
 231        case WC_HASH_TYPE_SHAKE128:
 232        #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128)
 233            oid = SHAKE128h;
 234        #else
 235            oid = HASH_TYPE_E;
 236        #endif
 237            break;
 238        case WC_HASH_TYPE_SHAKE256:
 239        #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256)
 240            oid = SHAKE256h;
 241        #else
 242            oid = HASH_TYPE_E;
 243        #endif
 244            break;
 245        case WC_HASH_TYPE_SM3:
 246        #ifdef WOLFSSL_SM3
 247            oid = SM3h;
 248        #else
 249            oid = HASH_TYPE_E;
 250        #endif
 251            break;
 252
 253        /* Not Supported */
 254        case WC_HASH_TYPE_MD4:
 255            oid = HASH_TYPE_E;
 256            break;
 257        case WC_HASH_TYPE_BLAKE2B:
 258            oid = HASH_TYPE_E;
 259            break;
 260        case WC_HASH_TYPE_BLAKE2S:
 261            oid = HASH_TYPE_E;
 262            break;
 263
 264        case WC_HASH_TYPE_NONE:
 265            oid = BAD_FUNC_ARG;
 266            break;
 267        default:
 268            oid = BAD_FUNC_ARG;
 269            break;
 270    }
 271    return oid;
 272}
 273
 274enum wc_HashType wc_OidGetHash(int oid)
 275{
 276    enum wc_HashType hash_type;
 277    switch (oid)
 278    {
 279        case MD2h:
 280        #ifdef WOLFSSL_MD2
 281            hash_type = WC_HASH_TYPE_MD2;
 282        #else
 283            hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE);
 284        #endif
 285            break;
 286        case MD5h:
 287        #ifndef NO_MD5
 288            hash_type = WC_HASH_TYPE_MD5;
 289        #else
 290            hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE);
 291        #endif
 292            break;
 293        case SHAh:
 294        #ifndef NO_SHA
 295            hash_type = WC_HASH_TYPE_SHA;
 296        #else
 297            hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE);
 298        #endif
 299            break;
 300        case SHA224h:
 301        #ifdef WOLFSSL_SHA224
 302            hash_type = WC_HASH_TYPE_SHA224;
 303        #else
 304            hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE);
 305        #endif
 306            break;
 307        case SHA256h:
 308        #ifndef NO_SHA256
 309            hash_type = WC_HASH_TYPE_SHA256;
 310        #else
 311            hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE);
 312        #endif
 313            break;
 314        case SHA384h:
 315        #ifdef WOLFSSL_SHA384
 316            hash_type = WC_HASH_TYPE_SHA384;
 317        #else
 318            hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE);
 319        #endif
 320            break;
 321        case SHA512h:
 322        #ifdef WOLFSSL_SHA512
 323            hash_type = WC_HASH_TYPE_SHA512;
 324        #else
 325            hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE);
 326        #endif
 327            break;
 328        case SHA3_224h:
 329        #ifdef WOLFSSL_SHA3
 330            hash_type = WC_HASH_TYPE_SHA3_224;
 331        #else
 332            hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE);
 333        #endif
 334            break;
 335        case SHA3_256h:
 336        #ifdef WOLFSSL_SHA3
 337            hash_type = WC_HASH_TYPE_SHA3_256;
 338        #else
 339            hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE);
 340        #endif
 341            break;
 342        case SHA3_384h:
 343        #ifdef WOLFSSL_SHA3
 344            hash_type = WC_HASH_TYPE_SHA3_384;
 345        #else
 346            hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE);
 347        #endif
 348            break;
 349        case SHA3_512h:
 350        #ifdef WOLFSSL_SHA3
 351            hash_type = WC_HASH_TYPE_SHA3_512;
 352        #else
 353            hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE);
 354        #endif
 355            break;
 356        case SM3h:
 357        #ifdef WOLFSSL_SM3
 358            hash_type = WC_HASH_TYPE_SM3;
 359        #else
 360            hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE);
 361        #endif
 362            break;
 363        default:
 364            hash_type = WC_ERR_TRACE(WC_HASH_TYPE_NONE);
 365            break;
 366    }
 367    return hash_type;
 368}
 369#endif /* !NO_ASN || !NO_DH || HAVE_ECC */
 370
 371#ifndef NO_HASH_WRAPPER
 372
 373/* Get Hash digest size */
 374int wc_HashGetDigestSize(enum wc_HashType hash_type)
 375{
 376    int dig_size;
 377    switch(hash_type)
 378    {
 379        case WC_HASH_TYPE_MD2:
 380        #ifdef WOLFSSL_MD2
 381            dig_size = WC_MD2_DIGEST_SIZE;
 382        #else
 383            dig_size = HASH_TYPE_E;
 384        #endif
 385            break;
 386        case WC_HASH_TYPE_MD4:
 387        #ifndef NO_MD4
 388            dig_size = WC_MD4_DIGEST_SIZE;
 389        #else
 390            dig_size = HASH_TYPE_E;
 391        #endif
 392            break;
 393        case WC_HASH_TYPE_MD5:
 394        #ifndef NO_MD5
 395            dig_size = WC_MD5_DIGEST_SIZE;
 396        #else
 397            dig_size = HASH_TYPE_E;
 398        #endif
 399            break;
 400        case WC_HASH_TYPE_SHA:
 401        #ifndef NO_SHA
 402            dig_size = WC_SHA_DIGEST_SIZE;
 403        #else
 404            dig_size = HASH_TYPE_E;
 405        #endif
 406            break;
 407        case WC_HASH_TYPE_SHA224:
 408        #ifdef WOLFSSL_SHA224
 409            dig_size = WC_SHA224_DIGEST_SIZE;
 410        #else
 411            dig_size = HASH_TYPE_E;
 412        #endif
 413            break;
 414        case WC_HASH_TYPE_SHA256:
 415        #ifndef NO_SHA256
 416            dig_size = WC_SHA256_DIGEST_SIZE;
 417        #else
 418            dig_size = HASH_TYPE_E;
 419        #endif
 420            break;
 421        case WC_HASH_TYPE_SHA384:
 422        #ifdef WOLFSSL_SHA384
 423            dig_size = WC_SHA384_DIGEST_SIZE;
 424        #else
 425            dig_size = HASH_TYPE_E;
 426        #endif
 427            break;
 428        case WC_HASH_TYPE_SHA512:
 429        #ifdef WOLFSSL_SHA512
 430            dig_size = WC_SHA512_DIGEST_SIZE;
 431        #else
 432            dig_size = HASH_TYPE_E;
 433        #endif
 434            break;
 435        case WC_HASH_TYPE_SHA512_224:
 436        #if (!defined(HAVE_FIPS) || FIPS_VERSION3_GE(7,0,0)) && \
 437            !defined(HAVE_SELFTEST) && defined(WOLFSSL_SHA512) && \
 438            !defined(WOLFSSL_NOSHA512_224)
 439            dig_size = WC_SHA512_224_DIGEST_SIZE;
 440        #else
 441            dig_size = HASH_TYPE_E;
 442        #endif
 443            break;
 444        case WC_HASH_TYPE_SHA512_256:
 445        #if (!defined(HAVE_FIPS) || FIPS_VERSION3_GE(7,0,0)) && \
 446            !defined(HAVE_SELFTEST) && defined(WOLFSSL_SHA512) && \
 447            !defined(WOLFSSL_NOSHA512_256)
 448            dig_size = WC_SHA512_256_DIGEST_SIZE;
 449        #else
 450            dig_size = HASH_TYPE_E;
 451        #endif
 452            break;
 453        case WC_HASH_TYPE_MD5_SHA: /* Old TLS Specific */
 454        #if !defined(NO_MD5) && !defined(NO_SHA)
 455            dig_size = (int)WC_MD5_DIGEST_SIZE + (int)WC_SHA_DIGEST_SIZE;
 456        #else
 457            dig_size = HASH_TYPE_E;
 458        #endif
 459            break;
 460
 461        case WC_HASH_TYPE_SHA3_224:
 462        #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224)
 463            dig_size = WC_SHA3_224_DIGEST_SIZE;
 464        #else
 465            dig_size = HASH_TYPE_E;
 466        #endif
 467            break;
 468        case WC_HASH_TYPE_SHA3_256:
 469        #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256)
 470            dig_size = WC_SHA3_256_DIGEST_SIZE;
 471        #else
 472            dig_size = HASH_TYPE_E;
 473        #endif
 474            break;
 475        case WC_HASH_TYPE_SHA3_384:
 476        #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384)
 477            dig_size = WC_SHA3_384_DIGEST_SIZE;
 478        #else
 479            dig_size = HASH_TYPE_E;
 480        #endif
 481            break;
 482        case WC_HASH_TYPE_SHA3_512:
 483        #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512)
 484            dig_size = WC_SHA3_512_DIGEST_SIZE;
 485        #else
 486            dig_size = HASH_TYPE_E;
 487        #endif
 488            break;
 489        case WC_HASH_TYPE_BLAKE2B:
 490        #if defined(HAVE_BLAKE2B)
 491            dig_size = BLAKE2B_OUTBYTES;
 492        #else
 493            dig_size = HASH_TYPE_E;
 494        #endif
 495            break;
 496        case WC_HASH_TYPE_BLAKE2S:
 497        #if defined(HAVE_BLAKE2S)
 498            dig_size = BLAKE2S_OUTBYTES;
 499        #else
 500            dig_size = HASH_TYPE_E;
 501        #endif
 502            break;
 503
 504        case WC_HASH_TYPE_SM3:
 505        #ifdef WOLFSSL_SM3
 506            dig_size = WC_SM3_DIGEST_SIZE;
 507        #else
 508            dig_size = HASH_TYPE_E;
 509        #endif
 510            break;
 511
 512    #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128)
 513        /* SHAKE is an XOF; default output here is 2x the security level
 514         * (256 bits for SHAKE128, 512 bits for SHAKE256). The SHA3 digest
 515         * macros are reused only for their bit-length value. */
 516        case WC_HASH_TYPE_SHAKE128:
 517            dig_size = WC_SHA3_256_DIGEST_SIZE;
 518            break;
 519    #else
 520        case WC_HASH_TYPE_SHAKE128:
 521            dig_size = HASH_TYPE_E;
 522            break;
 523    #endif
 524    #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256)
 525        case WC_HASH_TYPE_SHAKE256:
 526            dig_size = WC_SHA3_512_DIGEST_SIZE;
 527            break;
 528    #else
 529        case WC_HASH_TYPE_SHAKE256:
 530            dig_size = HASH_TYPE_E;
 531            break;
 532    #endif
 533
 534        /* Not Supported */
 535        case WC_HASH_TYPE_NONE:
 536            dig_size = BAD_FUNC_ARG;
 537            break;
 538        default:
 539            dig_size = BAD_FUNC_ARG;
 540            break;
 541    }
 542    return dig_size;
 543}
 544
 545
 546/* Get Hash block size */
 547int wc_HashGetBlockSize(enum wc_HashType hash_type)
 548{
 549    int block_size;
 550    switch (hash_type)
 551    {
 552        case WC_HASH_TYPE_MD2:
 553        #ifdef WOLFSSL_MD2
 554            block_size = WC_MD2_BLOCK_SIZE;
 555        #else
 556            block_size = HASH_TYPE_E;
 557        #endif
 558            break;
 559        case WC_HASH_TYPE_MD4:
 560        #ifndef NO_MD4
 561            block_size = WC_MD4_BLOCK_SIZE;
 562        #else
 563            block_size = HASH_TYPE_E;
 564        #endif
 565            break;
 566        case WC_HASH_TYPE_MD5:
 567        #ifndef NO_MD5
 568            block_size = WC_MD5_BLOCK_SIZE;
 569        #else
 570            block_size = HASH_TYPE_E;
 571        #endif
 572            break;
 573        case WC_HASH_TYPE_SHA:
 574        #ifndef NO_SHA
 575            block_size = WC_SHA_BLOCK_SIZE;
 576        #else
 577            block_size = HASH_TYPE_E;
 578        #endif
 579            break;
 580        case WC_HASH_TYPE_SHA224:
 581        #ifdef WOLFSSL_SHA224
 582            block_size = WC_SHA224_BLOCK_SIZE;
 583        #else
 584            block_size = HASH_TYPE_E;
 585        #endif
 586            break;
 587        case WC_HASH_TYPE_SHA256:
 588        #ifndef NO_SHA256
 589            block_size = WC_SHA256_BLOCK_SIZE;
 590        #else
 591            block_size = HASH_TYPE_E;
 592        #endif
 593            break;
 594        case WC_HASH_TYPE_SHA384:
 595        #ifdef WOLFSSL_SHA384
 596            block_size = WC_SHA384_BLOCK_SIZE;
 597        #else
 598            block_size = HASH_TYPE_E;
 599        #endif
 600            break;
 601        case WC_HASH_TYPE_SHA512:
 602        #ifdef WOLFSSL_SHA512
 603            block_size = WC_SHA512_BLOCK_SIZE;
 604        #else
 605            block_size = HASH_TYPE_E;
 606        #endif
 607            break;
 608        case WC_HASH_TYPE_SHA512_224:
 609        #if (!defined(HAVE_FIPS) || FIPS_VERSION3_GE(7,0,0)) && \
 610            !defined(HAVE_SELFTEST) && defined(WOLFSSL_SHA512) && \
 611            !defined(WOLFSSL_NOSHA512_224)
 612            block_size = WC_SHA512_224_BLOCK_SIZE;
 613        #else
 614            block_size = HASH_TYPE_E;
 615        #endif
 616            break;
 617        case WC_HASH_TYPE_SHA512_256:
 618        #if (!defined(HAVE_FIPS) || FIPS_VERSION3_GE(7,0,0)) && \
 619            !defined(HAVE_SELFTEST) && defined(WOLFSSL_SHA512) && \
 620            !defined(WOLFSSL_NOSHA512_256)
 621            block_size = WC_SHA512_256_BLOCK_SIZE;
 622        #else
 623            block_size = HASH_TYPE_E;
 624        #endif
 625            break;
 626        case WC_HASH_TYPE_MD5_SHA: /* Old TLS Specific */
 627        #if !defined(NO_MD5) && !defined(NO_SHA)
 628            block_size = (int)WC_MD5_BLOCK_SIZE + (int)WC_SHA_BLOCK_SIZE;
 629        #else
 630            block_size = HASH_TYPE_E;
 631        #endif
 632            break;
 633
 634        case WC_HASH_TYPE_SHA3_224:
 635        #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224)
 636            block_size = WC_SHA3_224_BLOCK_SIZE;
 637        #else
 638            block_size = HASH_TYPE_E;
 639        #endif
 640            break;
 641        case WC_HASH_TYPE_SHA3_256:
 642        #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256)
 643            block_size = WC_SHA3_256_BLOCK_SIZE;
 644        #else
 645            block_size = HASH_TYPE_E;
 646        #endif
 647            break;
 648        case WC_HASH_TYPE_SHA3_384:
 649        #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384)
 650            block_size = WC_SHA3_384_BLOCK_SIZE;
 651        #else
 652            block_size = HASH_TYPE_E;
 653        #endif
 654            break;
 655        case WC_HASH_TYPE_SHA3_512:
 656        #if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512)
 657            block_size = WC_SHA3_512_BLOCK_SIZE;
 658        #else
 659            block_size = HASH_TYPE_E;
 660        #endif
 661            break;
 662        case WC_HASH_TYPE_BLAKE2B:
 663        #if defined(HAVE_BLAKE2B)
 664            block_size = BLAKE2B_BLOCKBYTES;
 665        #else
 666            block_size = HASH_TYPE_E;
 667        #endif
 668            break;
 669        case WC_HASH_TYPE_BLAKE2S:
 670        #if defined(HAVE_BLAKE2S)
 671            block_size = BLAKE2S_BLOCKBYTES;
 672        #else
 673            block_size = HASH_TYPE_E;
 674        #endif
 675            break;
 676
 677        case WC_HASH_TYPE_SM3:
 678        #ifdef WOLFSSL_SM3
 679            block_size = WC_SM3_BLOCK_SIZE;
 680        #else
 681            block_size = HASH_TYPE_E;
 682        #endif
 683            break;
 684
 685    #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128)
 686        /* WC_SHA3_*_BLOCK_SIZE names the Keccak rate by capacity, not a
 687         * specific SHA-3 hash. SHAKE128 uses the 1344-bit rate (168 B);
 688         * SHAKE256 uses the 1088-bit rate (136 B), shared with SHA3-256.
 689         * Per FIPS 202. */
 690        case WC_HASH_TYPE_SHAKE128:
 691            block_size = WC_SHA3_128_BLOCK_SIZE;
 692            break;
 693    #else
 694        case WC_HASH_TYPE_SHAKE128:
 695            block_size = HASH_TYPE_E;
 696            break;
 697    #endif
 698    #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256)
 699        case WC_HASH_TYPE_SHAKE256:
 700            block_size = WC_SHA3_256_BLOCK_SIZE;
 701            break;
 702    #else
 703        case WC_HASH_TYPE_SHAKE256:
 704            block_size = HASH_TYPE_E;
 705            break;
 706    #endif
 707
 708        /* Not Supported */
 709        case WC_HASH_TYPE_NONE:
 710            block_size = BAD_FUNC_ARG;
 711            break;
 712        default:
 713            block_size = BAD_FUNC_ARG;
 714            break;
 715    }
 716    return block_size;
 717}
 718
 719/* Generic Hashing Wrapper */
 720int wc_Hash_ex(enum wc_HashType hash_type, const byte* data,
 721    word32 data_len, byte* hash, word32 hash_len, void* heap, int devId)
 722{
 723    int ret;
 724    int dig_size;
 725
 726    /* Validate hash buffer size */
 727    dig_size = wc_HashGetDigestSize(hash_type);
 728    if (dig_size < 0) {
 729        return dig_size;
 730    }
 731
 732    if (hash_len < (word32)dig_size) {
 733        return BUFFER_E;
 734    }
 735
 736    /* Suppress possible unused arg if all hashing is disabled */
 737    (void)data;
 738    (void)data_len;
 739    (void)hash;
 740    (void)hash_len;
 741
 742    switch(hash_type)
 743    {
 744        case WC_HASH_TYPE_MD5:
 745#ifndef NO_MD5
 746            ret = wc_Md5Hash_ex(data, data_len, hash, heap, devId);
 747#else
 748            ret = HASH_TYPE_E;
 749#endif
 750            break;
 751        case WC_HASH_TYPE_SHA:
 752#ifndef NO_SHA
 753            ret = wc_ShaHash_ex(data, data_len, hash, heap, devId);
 754#else
 755            ret = HASH_TYPE_E;
 756#endif
 757            break;
 758        case WC_HASH_TYPE_SHA224:
 759#ifdef WOLFSSL_SHA224
 760            ret = wc_Sha224Hash_ex(data, data_len, hash, heap, devId);
 761#else
 762            ret = HASH_TYPE_E;
 763#endif
 764            break;
 765        case WC_HASH_TYPE_SHA256:
 766#ifndef NO_SHA256
 767            ret = wc_Sha256Hash_ex(data, data_len, hash, heap, devId);
 768#else
 769            ret = HASH_TYPE_E;
 770#endif
 771            break;
 772        case WC_HASH_TYPE_SHA384:
 773#ifdef WOLFSSL_SHA384
 774            ret = wc_Sha384Hash_ex(data, data_len, hash, heap, devId);
 775#else
 776            ret = HASH_TYPE_E;
 777#endif
 778            break;
 779        case WC_HASH_TYPE_SHA512:
 780#ifdef WOLFSSL_SHA512
 781            ret = wc_Sha512Hash_ex(data, data_len, hash, heap, devId);
 782#else
 783            ret = HASH_TYPE_E;
 784#endif
 785            break;
 786        case WC_HASH_TYPE_SHA512_224:
 787#if (!defined(HAVE_FIPS) || FIPS_VERSION3_GE(7,0,0)) && \
 788    !defined(HAVE_SELFTEST) && defined(WOLFSSL_SHA512) && \
 789    !defined(WOLFSSL_NOSHA512_224)
 790            ret = wc_Sha512_224Hash_ex(data, data_len, hash, heap, devId);
 791#else
 792            ret = HASH_TYPE_E;
 793#endif
 794            break;
 795        case WC_HASH_TYPE_SHA512_256:
 796#if (!defined(HAVE_FIPS) || FIPS_VERSION3_GE(7,0,0)) && \
 797    !defined(HAVE_SELFTEST) && defined(WOLFSSL_SHA512) && \
 798    !defined(WOLFSSL_NOSHA512_256)
 799            ret = wc_Sha512_256Hash_ex(data, data_len, hash, heap, devId);
 800#else
 801            ret = HASH_TYPE_E;
 802#endif
 803            break;
 804        case WC_HASH_TYPE_MD5_SHA:
 805#if !defined(NO_MD5) && !defined(NO_SHA)
 806            ret = wc_Md5Hash_ex(data, data_len, hash, heap, devId);
 807            if (ret == 0) {
 808                ret = wc_ShaHash_ex(data, data_len, &hash[WC_MD5_DIGEST_SIZE],
 809                    heap, devId);
 810            }
 811#else
 812            ret = HASH_TYPE_E;
 813#endif
 814            break;
 815
 816        case WC_HASH_TYPE_SHA3_224:
 817#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224)
 818            ret = wc_Sha3_224Hash_ex(data, data_len, hash, heap, devId);
 819#else
 820            ret = HASH_TYPE_E;
 821#endif
 822            break;
 823        case WC_HASH_TYPE_SHA3_256:
 824#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256)
 825            ret = wc_Sha3_256Hash_ex(data, data_len, hash, heap, devId);
 826#else
 827            ret = HASH_TYPE_E;
 828#endif
 829            break;
 830        case WC_HASH_TYPE_SHA3_384:
 831#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384)
 832            ret = wc_Sha3_384Hash_ex(data, data_len, hash, heap, devId);
 833#else
 834            ret = HASH_TYPE_E;
 835#endif
 836            break;
 837        case WC_HASH_TYPE_SHA3_512:
 838#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512)
 839            ret = wc_Sha3_512Hash_ex(data, data_len, hash, heap, devId);
 840#else
 841            ret = HASH_TYPE_E;
 842#endif
 843            break;
 844
 845        case WC_HASH_TYPE_SM3:
 846#ifdef WOLFSSL_SM3
 847            ret = wc_Sm3Hash_ex(data, data_len, hash, heap, devId);
 848#else
 849            ret = HASH_TYPE_E;
 850#endif
 851            break;
 852
 853    #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128)
 854        case WC_HASH_TYPE_SHAKE128:
 855        {
 856            WC_DECLARE_VAR(shake, wc_Shake, 1, heap);
 857            WC_ALLOC_VAR_EX(shake, wc_Shake, 1, heap, DYNAMIC_TYPE_TMP_BUFFER,
 858                ret = MEMORY_E);
 859            if (WC_VAR_OK(shake)) {
 860                ret = wc_InitShake128(shake, heap, devId);
 861                if (ret == 0) {
 862                    ret = wc_Shake128_Update(shake, data, data_len);
 863                    if (ret == 0)
 864                        ret = wc_Shake128_Final(shake, hash,
 865                            WC_SHA3_256_DIGEST_SIZE);
 866                    wc_Shake128_Free(shake);
 867                }
 868            }
 869            WC_FREE_VAR_EX(shake, heap, DYNAMIC_TYPE_TMP_BUFFER);
 870            break;
 871        }
 872    #else
 873        case WC_HASH_TYPE_SHAKE128:
 874            ret = HASH_TYPE_E;
 875            break;
 876    #endif
 877    #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256)
 878        case WC_HASH_TYPE_SHAKE256:
 879        {
 880            WC_DECLARE_VAR(shake, wc_Shake, 1, heap);
 881            WC_ALLOC_VAR_EX(shake, wc_Shake, 1, heap, DYNAMIC_TYPE_TMP_BUFFER,
 882                ret = MEMORY_E);
 883            if (WC_VAR_OK(shake)) {
 884                ret = wc_InitShake256(shake, heap, devId);
 885                if (ret == 0) {
 886                    ret = wc_Shake256_Update(shake, data, data_len);
 887                    if (ret == 0)
 888                        ret = wc_Shake256_Final(shake, hash,
 889                            WC_SHA3_512_DIGEST_SIZE);
 890                    wc_Shake256_Free(shake);
 891                }
 892            }
 893            WC_FREE_VAR_EX(shake, heap, DYNAMIC_TYPE_TMP_BUFFER);
 894            break;
 895        }
 896    #else
 897        case WC_HASH_TYPE_SHAKE256:
 898            ret = HASH_TYPE_E;
 899            break;
 900    #endif
 901
 902        /* Not Supported */
 903        case WC_HASH_TYPE_MD2:
 904        case WC_HASH_TYPE_MD4:
 905        case WC_HASH_TYPE_BLAKE2B:
 906        case WC_HASH_TYPE_BLAKE2S:
 907            ret = HASH_TYPE_E;
 908            break;
 909        case WC_HASH_TYPE_NONE:
 910            ret = BAD_FUNC_ARG;
 911            break;
 912        default:
 913            ret = BAD_FUNC_ARG;
 914            break;
 915    }
 916    return ret;
 917}
 918int wc_Hash(enum wc_HashType hash_type, const byte* data,
 919    word32 data_len, byte* hash, word32 hash_len)
 920{
 921    return wc_Hash_ex(hash_type, data, data_len, hash, hash_len,
 922        NULL, INVALID_DEVID);
 923}
 924
 925#ifndef WC_NO_CONSTRUCTORS
 926wc_HashAlg* wc_HashNew(enum wc_HashType type, void* heap, int devId,
 927                       int *result_code)
 928{
 929    int ret;
 930    wc_HashAlg* hash = (wc_HashAlg*)XMALLOC(sizeof(wc_HashAlg), heap,
 931                        DYNAMIC_TYPE_HASHES);
 932    if (hash == NULL) {
 933        ret = MEMORY_E;
 934    }
 935    else {
 936        ret = wc_HashInit_ex(hash, type, heap, devId);
 937        if (ret != 0) {
 938            XFREE(hash, heap, DYNAMIC_TYPE_HASHES);
 939            hash = NULL;
 940        }
 941    }
 942
 943    if (result_code != NULL)
 944        *result_code = ret;
 945
 946    return hash;
 947}
 948
 949int wc_HashDelete(wc_HashAlg *hash, wc_HashAlg **hash_p) {
 950    int ret;
 951    void* heap;
 952    if (hash == NULL)
 953        return BAD_FUNC_ARG;
 954    heap = hash->heap;
 955    ret = wc_HashFree(hash, hash->type);
 956    if (ret < 0)
 957        return ret;
 958    XFREE(hash, heap, DYNAMIC_TYPE_HASHES);
 959    if (hash_p != NULL)
 960        *hash_p = NULL;
 961    return 0;
 962}
 963#endif /* !WC_NO_CONSTRUCTORS */
 964
 965int wc_HashInit_ex(wc_HashAlg* hash, enum wc_HashType type, void* heap,
 966    int devId)
 967{
 968    int ret;
 969
 970    if (hash == NULL)
 971        return BAD_FUNC_ARG;
 972
 973    hash->type = type;
 974
 975#ifdef WC_NO_CONSTRUCTORS
 976    (void)heap;
 977#else
 978    hash->heap = heap;
 979#endif
 980
 981    switch (type) {
 982        case WC_HASH_TYPE_MD5:
 983#ifndef NO_MD5
 984            ret = wc_InitMd5_ex(&hash->alg.md5, heap, devId);
 985#else
 986            ret = HASH_TYPE_E;
 987#endif
 988            break;
 989        case WC_HASH_TYPE_SHA:
 990#ifndef NO_SHA
 991            ret = wc_InitSha_ex(&hash->alg.sha, heap, devId);
 992#else
 993            ret = HASH_TYPE_E;
 994#endif
 995            break;
 996        case WC_HASH_TYPE_SHA224:
 997#ifdef WOLFSSL_SHA224
 998            ret = wc_InitSha224_ex(&hash->alg.sha224, heap, devId);
 999#else
1000            ret = HASH_TYPE_E;
1001#endif
1002            break;
1003        case WC_HASH_TYPE_SHA256:
1004#ifndef NO_SHA256
1005            ret = wc_InitSha256_ex(&hash->alg.sha256, heap, devId);
1006#else
1007            ret = HASH_TYPE_E;
1008#endif
1009            break;
1010        case WC_HASH_TYPE_SHA384:
1011#ifdef WOLFSSL_SHA384
1012            ret = wc_InitSha384_ex(&hash->alg.sha384, heap, devId);
1013#else
1014            ret = HASH_TYPE_E;
1015#endif
1016            break;
1017        case WC_HASH_TYPE_SHA512:
1018#ifdef WOLFSSL_SHA512
1019            ret = wc_InitSha512_ex(&hash->alg.sha512, heap, devId);
1020#else
1021            ret = HASH_TYPE_E;
1022#endif
1023            break;
1024        case WC_HASH_TYPE_SHA512_224:
1025#if (!defined(HAVE_FIPS) || FIPS_VERSION3_GE(7,0,0)) && \
1026    !defined(HAVE_SELFTEST) && defined(WOLFSSL_SHA512) && \
1027    !defined(WOLFSSL_NOSHA512_224)
1028            ret = wc_InitSha512_224_ex(&hash->alg.sha512, heap, devId);
1029#else
1030            ret = HASH_TYPE_E;
1031#endif
1032            break;
1033        case WC_HASH_TYPE_SHA512_256:
1034#if (!defined(HAVE_FIPS) || FIPS_VERSION3_GE(7,0,0)) && \
1035    !defined(HAVE_SELFTEST) && defined(WOLFSSL_SHA512) && \
1036    !defined(WOLFSSL_NOSHA512_256)
1037            ret = wc_InitSha512_256_ex(&hash->alg.sha512, heap, devId);
1038#else
1039            ret = HASH_TYPE_E;
1040#endif
1041            break;
1042        case WC_HASH_TYPE_SHA3_224:
1043#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224)
1044            ret = wc_InitSha3_224(&hash->alg.sha3, heap, devId);
1045#else
1046            ret = HASH_TYPE_E;
1047#endif
1048            break;
1049        case WC_HASH_TYPE_SHA3_256:
1050#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256)
1051            ret = wc_InitSha3_256(&hash->alg.sha3, heap, devId);
1052#else
1053            ret = HASH_TYPE_E;
1054#endif
1055            break;
1056        case WC_HASH_TYPE_SHA3_384:
1057#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384)
1058            ret = wc_InitSha3_384(&hash->alg.sha3, heap, devId);
1059#else
1060            ret = HASH_TYPE_E;
1061#endif
1062            break;
1063        case WC_HASH_TYPE_SHA3_512:
1064#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512)
1065            ret = wc_InitSha3_512(&hash->alg.sha3, heap, devId);
1066#else
1067            ret = HASH_TYPE_E;
1068#endif
1069            break;
1070
1071        case WC_HASH_TYPE_SM3:
1072#ifdef WOLFSSL_SM3
1073            ret = wc_InitSm3(&hash->alg.sm3, heap, devId);
1074#else
1075            ret = HASH_TYPE_E;
1076#endif
1077            break;
1078
1079    #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128)
1080        case WC_HASH_TYPE_SHAKE128:
1081            ret = wc_InitShake128(&hash->alg.sha3, heap, devId);
1082            break;
1083    #else
1084        case WC_HASH_TYPE_SHAKE128:
1085            ret = HASH_TYPE_E;
1086            break;
1087    #endif
1088    #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256)
1089        case WC_HASH_TYPE_SHAKE256:
1090            ret = wc_InitShake256(&hash->alg.sha3, heap, devId);
1091            break;
1092    #else
1093        case WC_HASH_TYPE_SHAKE256:
1094            ret = HASH_TYPE_E;
1095            break;
1096    #endif
1097
1098        /* not supported */
1099        case WC_HASH_TYPE_MD5_SHA:
1100        case WC_HASH_TYPE_MD2:
1101        case WC_HASH_TYPE_MD4:
1102        case WC_HASH_TYPE_BLAKE2B:
1103        case WC_HASH_TYPE_BLAKE2S:
1104            ret = HASH_TYPE_E;
1105            break;
1106        case WC_HASH_TYPE_NONE:
1107            ret = BAD_FUNC_ARG;
1108            break;
1109        default:
1110            ret = BAD_FUNC_ARG;
1111    };
1112
1113    (void)devId;
1114
1115    return ret;
1116}
1117
1118int wc_HashInit(wc_HashAlg* hash, enum wc_HashType type)
1119{
1120    return wc_HashInit_ex(hash, type, NULL, INVALID_DEVID);
1121}
1122
1123int wc_HashUpdate(wc_HashAlg* hash, enum wc_HashType type, const byte* data,
1124                  word32 dataSz)
1125{
1126    int ret;
1127
1128    if (hash == NULL || (data == NULL && dataSz > 0))
1129        return BAD_FUNC_ARG;
1130
1131#ifdef DEBUG_WOLFSSL
1132    if (hash->type != type) {
1133        WOLFSSL_MSG("Hash update type mismatch!");
1134        return BAD_FUNC_ARG;
1135    }
1136#endif
1137
1138    switch (type) {
1139        case WC_HASH_TYPE_MD5:
1140#ifndef NO_MD5
1141            ret = wc_Md5Update(&hash->alg.md5, data, dataSz);
1142#else
1143            ret = HASH_TYPE_E;
1144#endif
1145            break;
1146        case WC_HASH_TYPE_SHA:
1147#ifndef NO_SHA
1148            ret = wc_ShaUpdate(&hash->alg.sha, data, dataSz);
1149#else
1150            ret = HASH_TYPE_E;
1151#endif
1152            break;
1153        case WC_HASH_TYPE_SHA224:
1154#ifdef WOLFSSL_SHA224
1155            ret = wc_Sha224Update(&hash->alg.sha224, data, dataSz);
1156#else
1157            ret = HASH_TYPE_E;
1158#endif
1159            break;
1160        case WC_HASH_TYPE_SHA256:
1161#ifndef NO_SHA256
1162            ret = wc_Sha256Update(&hash->alg.sha256, data, dataSz);
1163#else
1164            ret = HASH_TYPE_E;
1165#endif
1166            break;
1167        case WC_HASH_TYPE_SHA384:
1168#ifdef WOLFSSL_SHA384
1169            ret = wc_Sha384Update(&hash->alg.sha384, data, dataSz);
1170#else
1171            ret = HASH_TYPE_E;
1172#endif
1173            break;
1174        case WC_HASH_TYPE_SHA512:
1175#ifdef WOLFSSL_SHA512
1176            ret = wc_Sha512Update(&hash->alg.sha512, data, dataSz);
1177#else
1178            ret = HASH_TYPE_E;
1179#endif
1180            break;
1181        case WC_HASH_TYPE_SHA512_224:
1182#if (!defined(HAVE_FIPS) || FIPS_VERSION3_GE(7,0,0)) && \
1183    !defined(HAVE_SELFTEST) && defined(WOLFSSL_SHA512) && \
1184    !defined(WOLFSSL_NOSHA512_224)
1185            ret = wc_Sha512_224Update(&hash->alg.sha512, data, dataSz);
1186#else
1187            ret = HASH_TYPE_E;
1188#endif
1189            break;
1190        case WC_HASH_TYPE_SHA512_256:
1191#if (!defined(HAVE_FIPS) || FIPS_VERSION3_GE(7,0,0)) && \
1192    !defined(HAVE_SELFTEST) && defined(WOLFSSL_SHA512) && \
1193    !defined(WOLFSSL_NOSHA512_256)
1194            ret = wc_Sha512_256Update(&hash->alg.sha512, data, dataSz);
1195#else
1196            ret = HASH_TYPE_E;
1197#endif
1198            break;
1199        case WC_HASH_TYPE_SHA3_224:
1200#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224)
1201            ret = wc_Sha3_224_Update(&hash->alg.sha3, data, dataSz);
1202#else
1203            ret = HASH_TYPE_E;
1204#endif
1205            break;
1206        case WC_HASH_TYPE_SHA3_256:
1207#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256)
1208            ret = wc_Sha3_256_Update(&hash->alg.sha3, data, dataSz);
1209#else
1210            ret = HASH_TYPE_E;
1211#endif
1212            break;
1213        case WC_HASH_TYPE_SHA3_384:
1214#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384)
1215            ret = wc_Sha3_384_Update(&hash->alg.sha3, data, dataSz);
1216#else
1217            ret = HASH_TYPE_E;
1218#endif
1219            break;
1220        case WC_HASH_TYPE_SHA3_512:
1221#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512)
1222            ret = wc_Sha3_512_Update(&hash->alg.sha3, data, dataSz);
1223#else
1224            ret = HASH_TYPE_E;
1225#endif
1226            break;
1227
1228        case WC_HASH_TYPE_SM3:
1229#ifdef WOLFSSL_SM3
1230            ret = wc_Sm3Update(&hash->alg.sm3, data, dataSz);
1231#else
1232            ret = HASH_TYPE_E;
1233#endif
1234            break;
1235
1236    #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128)
1237        case WC_HASH_TYPE_SHAKE128:
1238            ret = wc_Shake128_Update(&hash->alg.sha3, data, dataSz);
1239            break;
1240    #else
1241        case WC_HASH_TYPE_SHAKE128:
1242            ret = HASH_TYPE_E;
1243            break;
1244    #endif
1245    #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256)
1246        case WC_HASH_TYPE_SHAKE256:
1247            ret = wc_Shake256_Update(&hash->alg.sha3, data, dataSz);
1248            break;
1249    #else
1250        case WC_HASH_TYPE_SHAKE256:
1251            ret = HASH_TYPE_E;
1252            break;
1253    #endif
1254
1255        /* not supported */
1256        case WC_HASH_TYPE_MD5_SHA:
1257        case WC_HASH_TYPE_MD2:
1258        case WC_HASH_TYPE_MD4:
1259        case WC_HASH_TYPE_BLAKE2B:
1260        case WC_HASH_TYPE_BLAKE2S:
1261            ret = HASH_TYPE_E;
1262            break;
1263        case WC_HASH_TYPE_NONE:
1264            ret = BAD_FUNC_ARG;
1265            break;
1266        default:
1267            ret = BAD_FUNC_ARG;
1268    };
1269
1270    return ret;
1271}
1272
1273int wc_HashFinal(wc_HashAlg* hash, enum wc_HashType type, byte* out)
1274{
1275    int ret;
1276
1277    if (hash == NULL || out == NULL)
1278        return BAD_FUNC_ARG;
1279
1280#ifdef DEBUG_WOLFSSL
1281    if (hash->type != type) {
1282        WOLFSSL_MSG("Hash final type mismatch!");
1283        return BAD_FUNC_ARG;
1284    }
1285#endif
1286
1287    switch (type) {
1288        case WC_HASH_TYPE_MD5:
1289#ifndef NO_MD5
1290            ret = wc_Md5Final(&hash->alg.md5, out);
1291#else
1292            ret = HASH_TYPE_E;
1293#endif
1294            break;
1295        case WC_HASH_TYPE_SHA:
1296#ifndef NO_SHA
1297            ret = wc_ShaFinal(&hash->alg.sha, out);
1298#else
1299            ret = HASH_TYPE_E;
1300#endif
1301            break;
1302        case WC_HASH_TYPE_SHA224:
1303#ifdef WOLFSSL_SHA224
1304            ret = wc_Sha224Final(&hash->alg.sha224, out);
1305#else
1306            ret = HASH_TYPE_E;
1307#endif
1308            break;
1309        case WC_HASH_TYPE_SHA256:
1310#ifndef NO_SHA256
1311            ret = wc_Sha256Final(&hash->alg.sha256, out);
1312#else
1313            ret = HASH_TYPE_E;
1314#endif
1315            break;
1316        case WC_HASH_TYPE_SHA384:
1317#ifdef WOLFSSL_SHA384
1318            ret = wc_Sha384Final(&hash->alg.sha384, out);
1319#else
1320            ret = HASH_TYPE_E;
1321#endif
1322            break;
1323        case WC_HASH_TYPE_SHA512:
1324#ifdef WOLFSSL_SHA512
1325            ret = wc_Sha512Final(&hash->alg.sha512, out);
1326#else
1327            ret = HASH_TYPE_E;
1328#endif
1329            break;
1330        case WC_HASH_TYPE_SHA512_224:
1331#if (!defined(HAVE_FIPS) || FIPS_VERSION3_GE(7,0,0)) && \
1332    !defined(HAVE_SELFTEST) && defined(WOLFSSL_SHA512) && \
1333    !defined(WOLFSSL_NOSHA512_224)
1334            ret = wc_Sha512_224Final(&hash->alg.sha512, out);
1335#else
1336            ret = HASH_TYPE_E;
1337#endif
1338            break;
1339        case WC_HASH_TYPE_SHA512_256:
1340#if (!defined(HAVE_FIPS) || FIPS_VERSION3_GE(7,0,0)) && \
1341    !defined(HAVE_SELFTEST) && defined(WOLFSSL_SHA512) && \
1342    !defined(WOLFSSL_NOSHA512_256)
1343            ret = wc_Sha512_256Final(&hash->alg.sha512, out);
1344#else
1345            ret = HASH_TYPE_E;
1346#endif
1347            break;
1348        case WC_HASH_TYPE_SHA3_224:
1349#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224)
1350            ret = wc_Sha3_224_Final(&hash->alg.sha3, out);
1351#else
1352            ret = HASH_TYPE_E;
1353#endif
1354            break;
1355        case WC_HASH_TYPE_SHA3_256:
1356#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256)
1357            ret = wc_Sha3_256_Final(&hash->alg.sha3, out);
1358#else
1359            ret = HASH_TYPE_E;
1360#endif
1361            break;
1362        case WC_HASH_TYPE_SHA3_384:
1363#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384)
1364            ret = wc_Sha3_384_Final(&hash->alg.sha3, out);
1365#else
1366            ret = HASH_TYPE_E;
1367#endif
1368            break;
1369        case WC_HASH_TYPE_SHA3_512:
1370#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512)
1371            ret = wc_Sha3_512_Final(&hash->alg.sha3, out);
1372#else
1373            ret = HASH_TYPE_E;
1374#endif
1375            break;
1376
1377        case WC_HASH_TYPE_SM3:
1378#ifdef WOLFSSL_SM3
1379            ret = wc_Sm3Final(&hash->alg.sm3, out);
1380#else
1381            ret = HASH_TYPE_E;
1382#endif
1383            break;
1384
1385    #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128)
1386        case WC_HASH_TYPE_SHAKE128:
1387            ret = wc_Shake128_Final(&hash->alg.sha3, out,
1388                WC_SHA3_256_DIGEST_SIZE);
1389            break;
1390    #else
1391        case WC_HASH_TYPE_SHAKE128:
1392            ret = HASH_TYPE_E;
1393            break;
1394    #endif
1395    #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256)
1396        case WC_HASH_TYPE_SHAKE256:
1397            ret = wc_Shake256_Final(&hash->alg.sha3, out,
1398                WC_SHA3_512_DIGEST_SIZE);
1399            break;
1400    #else
1401        case WC_HASH_TYPE_SHAKE256:
1402            ret = HASH_TYPE_E;
1403            break;
1404    #endif
1405
1406        /* not supported */
1407        case WC_HASH_TYPE_MD5_SHA:
1408        case WC_HASH_TYPE_MD2:
1409        case WC_HASH_TYPE_MD4:
1410        case WC_HASH_TYPE_BLAKE2B:
1411        case WC_HASH_TYPE_BLAKE2S:
1412            ret = HASH_TYPE_E;
1413            break;
1414        case WC_HASH_TYPE_NONE:
1415            ret = BAD_FUNC_ARG;
1416            break;
1417        default:
1418            ret = BAD_FUNC_ARG;
1419    };
1420
1421    return ret;
1422}
1423
1424int wc_HashFree(wc_HashAlg* hash, enum wc_HashType type)
1425{
1426    int ret;
1427
1428    if (hash == NULL)
1429        return BAD_FUNC_ARG;
1430
1431#ifdef DEBUG_WOLFSSL
1432    if (hash->type != type) {
1433        WOLFSSL_MSG("Hash free type mismatch!");
1434        return BAD_FUNC_ARG;
1435    }
1436#endif
1437
1438    switch (type) {
1439        case WC_HASH_TYPE_MD5:
1440#ifndef NO_MD5
1441            wc_Md5Free(&hash->alg.md5);
1442            ret = 0;
1443#else
1444            ret = HASH_TYPE_E;
1445#endif
1446            break;
1447        case WC_HASH_TYPE_SHA:
1448#ifndef NO_SHA
1449            wc_ShaFree(&hash->alg.sha);
1450            ret = 0;
1451#else
1452            ret = HASH_TYPE_E;
1453#endif
1454            break;
1455        case WC_HASH_TYPE_SHA224:
1456#ifdef WOLFSSL_SHA224
1457            wc_Sha224Free(&hash->alg.sha224);
1458            ret = 0;
1459#else
1460            ret = HASH_TYPE_E;
1461#endif
1462            break;
1463        case WC_HASH_TYPE_SHA256:
1464#ifndef NO_SHA256
1465            wc_Sha256Free(&hash->alg.sha256);
1466            ret = 0;
1467#else
1468            ret = HASH_TYPE_E;
1469#endif
1470            break;
1471        case WC_HASH_TYPE_SHA384:
1472#ifdef WOLFSSL_SHA384
1473            wc_Sha384Free(&hash->alg.sha384);
1474            ret = 0;
1475#else
1476            ret = HASH_TYPE_E;
1477#endif
1478            break;
1479        case WC_HASH_TYPE_SHA512:
1480#ifdef WOLFSSL_SHA512
1481            wc_Sha512Free(&hash->alg.sha512);
1482            ret = 0;
1483#else
1484            ret = HASH_TYPE_E;
1485#endif
1486            break;
1487        case WC_HASH_TYPE_SHA512_224:
1488#if (!defined(HAVE_FIPS) || FIPS_VERSION3_GE(7,0,0)) && \
1489    !defined(HAVE_SELFTEST) && defined(WOLFSSL_SHA512) && \
1490    !defined(WOLFSSL_NOSHA512_224)
1491            wc_Sha512_224Free(&hash->alg.sha512);
1492            ret = 0;
1493#else
1494            ret = HASH_TYPE_E;
1495#endif
1496            break;
1497        case WC_HASH_TYPE_SHA512_256:
1498#if (!defined(HAVE_FIPS) || FIPS_VERSION3_GE(7,0,0)) && \
1499    !defined(HAVE_SELFTEST) && defined(WOLFSSL_SHA512) && \
1500    !defined(WOLFSSL_NOSHA512_256)
1501            wc_Sha512_256Free(&hash->alg.sha512);
1502            ret = 0;
1503#else
1504            ret = HASH_TYPE_E;
1505#endif
1506            break;
1507        case WC_HASH_TYPE_SHA3_224:
1508#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_224)
1509            wc_Sha3_224_Free(&hash->alg.sha3);
1510            ret = 0;
1511#else
1512            ret = HASH_TYPE_E;
1513#endif
1514            break;
1515        case WC_HASH_TYPE_SHA3_256:
1516#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_256)
1517            wc_Sha3_256_Free(&hash->alg.sha3);
1518            ret = 0;
1519#else
1520            ret = HASH_TYPE_E;
1521#endif
1522            break;
1523        case WC_HASH_TYPE_SHA3_384:
1524#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_384)
1525            wc_Sha3_384_Free(&hash->alg.sha3);
1526            ret = 0;
1527#else
1528            ret = HASH_TYPE_E;
1529#endif
1530            break;
1531        case WC_HASH_TYPE_SHA3_512:
1532#if defined(WOLFSSL_SHA3) && !defined(WOLFSSL_NOSHA3_512)
1533            wc_Sha3_512_Free(&hash->alg.sha3);
1534            ret = 0;
1535#else
1536            ret = HASH_TYPE_E;
1537#endif
1538            break;
1539
1540        case WC_HASH_TYPE_SM3:
1541#ifdef WOLFSSL_SM3
1542            wc_Sm3Free(&hash->alg.sm3);
1543            ret = 0;
1544#else
1545            ret = HASH_TYPE_E;
1546#endif
1547            break;
1548
1549    #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128)
1550        case WC_HASH_TYPE_SHAKE128:
1551            wc_Shake128_Free(&hash->alg.sha3);
1552            ret = 0;
1553            break;
1554    #else
1555        case WC_HASH_TYPE_SHAKE128:
1556            ret = HASH_TYPE_E;
1557            break;
1558    #endif
1559    #if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256)
1560        case WC_HASH_TYPE_SHAKE256:
1561            wc_Shake256_Free(&hash->alg.sha3);
1562            ret = 0;
1563            break;
1564    #else
1565        case WC_HASH_TYPE_SHAKE256:
1566            ret = HASH_TYPE_E;
1567            break;
1568    #endif
1569
1570        /* not supported */
1571        case WC_HASH_TYPE_MD5_SHA:
1572        case WC_HASH_TYPE_MD2:
1573        case WC_HASH_TYPE_MD4:
1574        case WC_HASH_TYPE_BLAKE2B:
1575        case WC_HASH_TYPE_BLAKE2S:
1576            ret = HASH_TYPE_E;
1577            break;
1578        case WC_HASH_TYPE_NONE:
1579            ret = BAD_FUNC_ARG;
1580            break;
1581        default:
1582            ret = BAD_FUNC_ARG;
1583    };
1584
1585    return ret;
1586}
1587
1588#ifdef WOLFSSL_HASH_FLAGS
1589int wc_HashSetFlags(wc_HashAlg* hash, enum wc_HashType type, word32 flags)
1590{
1591    int ret;
1592
1593    if (hash == NULL)
1594        return BAD_FUNC_ARG;
1595
1596    switch (type) {
1597        case WC_HASH_TYPE_MD5:
1598#ifndef NO_MD5
1599            ret = wc_Md5SetFlags(&hash->alg.md5, flags);
1600#else
1601            ret = HASH_TYPE_E;
1602#endif
1603            break;
1604        case WC_HASH_TYPE_SHA:
1605#ifndef NO_SHA
1606            ret = wc_ShaSetFlags(&hash->alg.sha, flags);
1607#else
1608            ret = HASH_TYPE_E;
1609#endif
1610            break;
1611        case WC_HASH_TYPE_SHA224:
1612#ifdef WOLFSSL_SHA224
1613            ret = wc_Sha224SetFlags(&hash->alg.sha224, flags);
1614#else
1615            ret = HASH_TYPE_E;
1616#endif
1617            break;
1618        case WC_HASH_TYPE_SHA256:
1619#ifndef NO_SHA256
1620            ret = wc_Sha256SetFlags(&hash->alg.sha256, flags);
1621#else
1622            ret = HASH_TYPE_E;
1623#endif
1624            break;
1625        case WC_HASH_TYPE_SHA384:
1626#ifdef WOLFSSL_SHA384
1627            ret = wc_Sha384SetFlags(&hash->alg.sha384, flags);
1628#else
1629            ret = HASH_TYPE_E;
1630#endif
1631            break;
1632        case WC_HASH_TYPE_SHA512:
1633#ifdef WOLFSSL_SHA512
1634            ret = wc_Sha512SetFlags(&hash->alg.sha512, flags);
1635#else
1636            ret = HASH_TYPE_E;
1637#endif
1638            break;
1639
1640        case WC_HASH_TYPE_SHA512_224:
1641#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224)
1642            ret = wc_Sha512SetFlags(&hash->alg.sha512, flags);
1643#else
1644            ret = HASH_TYPE_E;
1645#endif
1646            break;
1647
1648        case WC_HASH_TYPE_SHA512_256:
1649#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256)
1650            ret = wc_Sha512SetFlags(&hash->alg.sha512, flags);
1651#else
1652            ret = HASH_TYPE_E;
1653#endif
1654            break;
1655
1656        case WC_HASH_TYPE_SHA3_224:
1657        case WC_HASH_TYPE_SHA3_256:
1658        case WC_HASH_TYPE_SHA3_384:
1659        case WC_HASH_TYPE_SHA3_512:
1660#ifdef WOLFSSL_SHA3
1661            ret = wc_Sha3_SetFlags(&hash->alg.sha3, flags);
1662#else
1663            ret = HASH_TYPE_E;
1664#endif
1665            break;
1666
1667        case WC_HASH_TYPE_SHAKE128:
1668#if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128)
1669            ret = wc_Sha3_SetFlags(&hash->alg.sha3, flags);
1670#else
1671            ret = HASH_TYPE_E;
1672#endif
1673            break;
1674
1675        case WC_HASH_TYPE_SHAKE256:
1676#if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256)
1677            ret = wc_Sha3_SetFlags(&hash->alg.sha3, flags);
1678#else
1679            ret = HASH_TYPE_E;
1680#endif
1681            break;
1682
1683        case WC_HASH_TYPE_SM3:
1684#ifdef WOLFSSL_SM3
1685            ret = wc_Sm3SetFlags(&hash->alg.sm3, flags);
1686#else
1687            ret = HASH_TYPE_E;
1688#endif
1689            break;
1690
1691        /* not supported */
1692        case WC_HASH_TYPE_MD5_SHA:
1693        case WC_HASH_TYPE_MD2:
1694        case WC_HASH_TYPE_MD4:
1695        case WC_HASH_TYPE_BLAKE2B:
1696        case WC_HASH_TYPE_BLAKE2S:
1697            ret = HASH_TYPE_E;
1698            break;
1699        case WC_HASH_TYPE_NONE:
1700        default:
1701            ret = BAD_FUNC_ARG;
1702    };
1703
1704    return ret;
1705}
1706int wc_HashGetFlags(wc_HashAlg* hash, enum wc_HashType type, word32* flags)
1707{
1708    int ret;
1709
1710    if (hash == NULL)
1711        return BAD_FUNC_ARG;
1712
1713    switch (type) {
1714        case WC_HASH_TYPE_MD5:
1715#ifndef NO_MD5
1716            ret = wc_Md5GetFlags(&hash->alg.md5, flags);
1717#else
1718            ret = HASH_TYPE_E;
1719#endif
1720            break;
1721        case WC_HASH_TYPE_SHA:
1722#ifndef NO_SHA
1723            ret = wc_ShaGetFlags(&hash->alg.sha, flags);
1724#else
1725            ret = HASH_TYPE_E;
1726#endif
1727            break;
1728        case WC_HASH_TYPE_SHA224:
1729#ifdef WOLFSSL_SHA224
1730            ret = wc_Sha224GetFlags(&hash->alg.sha224, flags);
1731#else
1732            ret = HASH_TYPE_E;
1733#endif
1734            break;
1735        case WC_HASH_TYPE_SHA256:
1736#ifndef NO_SHA256
1737            ret = wc_Sha256GetFlags(&hash->alg.sha256, flags);
1738#else
1739            ret = HASH_TYPE_E;
1740#endif
1741            break;
1742        case WC_HASH_TYPE_SHA384:
1743#ifdef WOLFSSL_SHA384
1744            ret = wc_Sha384GetFlags(&hash->alg.sha384, flags);
1745#else
1746            ret = HASH_TYPE_E;
1747#endif
1748            break;
1749        case WC_HASH_TYPE_SHA512:
1750#ifdef WOLFSSL_SHA512
1751            ret = wc_Sha512GetFlags(&hash->alg.sha512, flags);
1752#else
1753            ret = HASH_TYPE_E;
1754#endif
1755            break;
1756        case WC_HASH_TYPE_SHA512_224:
1757#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_224)
1758            ret = wc_Sha512GetFlags(&hash->alg.sha512, flags);
1759#else
1760            ret = HASH_TYPE_E;
1761#endif
1762            break;
1763        case WC_HASH_TYPE_SHA512_256:
1764#if defined(WOLFSSL_SHA512) && !defined(WOLFSSL_NOSHA512_256)
1765            ret = wc_Sha512GetFlags(&hash->alg.sha512, flags);
1766#else
1767            ret = HASH_TYPE_E;
1768#endif
1769            break;
1770
1771        case WC_HASH_TYPE_SHA3_224:
1772        case WC_HASH_TYPE_SHA3_256:
1773        case WC_HASH_TYPE_SHA3_384:
1774        case WC_HASH_TYPE_SHA3_512:
1775#ifdef WOLFSSL_SHA3
1776            ret = wc_Sha3_GetFlags(&hash->alg.sha3, flags);
1777#else
1778            ret = HASH_TYPE_E;
1779#endif
1780            break;
1781
1782        case WC_HASH_TYPE_SHAKE128:
1783#if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE128)
1784            ret = wc_Sha3_GetFlags(&hash->alg.sha3, flags);
1785#else
1786            ret = HASH_TYPE_E;
1787#endif
1788            break;
1789
1790        case WC_HASH_TYPE_SHAKE256:
1791#if defined(WOLFSSL_SHA3) && defined(WOLFSSL_SHAKE256)
1792            ret = wc_Sha3_GetFlags(&hash->alg.sha3, flags);
1793#else
1794            ret = HASH_TYPE_E;
1795#endif
1796            break;
1797
1798        case WC_HASH_TYPE_SM3:
1799#ifdef WOLFSSL_SM3
1800            ret = wc_Sm3GetFlags(&hash->alg.sm3, flags);
1801#else
1802            ret = HASH_TYPE_E;
1803#endif
1804            break;
1805
1806        /* not supported */
1807        case WC_HASH_TYPE_MD5_SHA:
1808        case WC_HASH_TYPE_MD2:
1809        case WC_HASH_TYPE_MD4:
1810        case WC_HASH_TYPE_BLAKE2B:
1811        case WC_HASH_TYPE_BLAKE2S:
1812            ret = HASH_TYPE_E;
1813            break;
1814        case WC_HASH_TYPE_NONE:
1815            ret = BAD_FUNC_ARG;
1816            break;
1817        default:
1818            ret = BAD_FUNC_ARG;
1819    };
1820
1821    return ret;
1822}
1823#endif /* WOLFSSL_HASH_FLAGS */
1824
1825
1826#if !defined(WOLFSSL_TI_HASH)
1827
1828#if !defined(NO_MD5)
1829    int wc_Md5Hash_ex(const byte* data, word32 len, byte* hash,
1830        void* heap, int devId)
1831    {
1832        int ret;
1833        WC_DECLARE_VAR(md5, wc_Md5, 1, 0);
1834
1835        WC_ALLOC_VAR_EX(md5, wc_Md5, 1, NULL, DYNAMIC_TYPE_TMP_BUFFER,
1836            return MEMORY_E);
1837
1838        if ((ret = wc_InitMd5_ex(md5, heap, devId)) != 0) {
1839            WOLFSSL_MSG("InitMd5 failed");
1840        }
1841        else {
1842            if ((ret = wc_Md5Update(md5, data, len)) != 0) {
1843                WOLFSSL_MSG("Md5Update failed");
1844            }
1845            else if ((ret = wc_Md5Final(md5, hash)) != 0) {
1846                WOLFSSL_MSG("Md5Final failed");
1847            }
1848            wc_Md5Free(md5);
1849        }
1850
1851        WC_FREE_VAR_EX(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1852
1853        return ret;
1854    }
1855    int wc_Md5Hash(const byte* data, word32 len, byte* hash)
1856    {
1857        int devId = INVALID_DEVID;
1858    #ifdef WOLF_CRYPTO_CB
1859        /* find devId if its not an empty hash */
1860        if (data != NULL && len > 0) {
1861            devId = wc_CryptoCb_DefaultDevID();
1862        }
1863    #endif
1864        return wc_Md5Hash_ex(data, len, hash, NULL, devId);
1865    }
1866#endif /* !NO_MD5 */
1867
1868#if !defined(NO_SHA)
1869    int wc_ShaHash_ex(const byte* data, word32 len, byte* hash,
1870        void* heap, int devId)
1871    {
1872        int ret = 0;
1873        WC_DECLARE_VAR(sha, wc_Sha, 1, 0);
1874
1875        WC_ALLOC_VAR_EX(sha, wc_Sha, 1, NULL, DYNAMIC_TYPE_TMP_BUFFER,
1876            return MEMORY_E);
1877
1878        if ((ret = wc_InitSha_ex(sha, heap, devId)) != 0) {
1879            WOLFSSL_MSG("InitSha failed");
1880        }
1881        else {
1882            if ((ret = wc_ShaUpdate(sha, data, len)) != 0) {
1883                WOLFSSL_MSG("ShaUpdate failed");
1884            }
1885            else if ((ret = wc_ShaFinal(sha, hash)) != 0) {
1886                WOLFSSL_MSG("ShaFinal failed");
1887            }
1888            wc_ShaFree(sha);
1889        }
1890
1891        WC_FREE_VAR_EX(sha, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1892
1893        return ret;
1894    }
1895    int wc_ShaHash(const byte* data, word32 len, byte* hash)
1896    {
1897        int devId = INVALID_DEVID;
1898    #ifdef WOLF_CRYPTO_CB
1899        /* find devId if its not an empty hash */
1900        if (data != NULL && len > 0) {
1901            devId = wc_CryptoCb_DefaultDevID();
1902        }
1903    #endif
1904        return wc_ShaHash_ex(data, len, hash, NULL, devId);
1905    }
1906#endif /* !NO_SHA */
1907
1908#if defined(WOLFSSL_SHA224)
1909    int wc_Sha224Hash_ex(const byte* data, word32 len, byte* hash,
1910        void* heap, int devId)
1911    {
1912        int ret = 0;
1913        WC_DECLARE_VAR(sha224, wc_Sha224, 1, 0);
1914
1915        WC_ALLOC_VAR_EX(sha224, wc_Sha224, 1, NULL, DYNAMIC_TYPE_TMP_BUFFER,
1916            return MEMORY_E);
1917
1918        if ((ret = wc_InitSha224_ex(sha224, heap, devId)) != 0) {
1919            WOLFSSL_MSG("InitSha224 failed");
1920        }
1921        else {
1922            if ((ret = wc_Sha224Update(sha224, data, len)) != 0) {
1923                WOLFSSL_MSG("Sha224Update failed");
1924            }
1925            else if ((ret = wc_Sha224Final(sha224, hash)) != 0) {
1926                WOLFSSL_MSG("Sha224Final failed");
1927            }
1928            wc_Sha224Free(sha224);
1929        }
1930
1931        WC_FREE_VAR_EX(sha224, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1932
1933        return ret;
1934    }
1935    int wc_Sha224Hash(const byte* data, word32 len, byte* hash)
1936    {
1937        int devId = INVALID_DEVID;
1938    #ifdef WOLF_CRYPTO_CB
1939        /* find devId if its not an empty hash */
1940        if (data != NULL && len > 0) {
1941            devId = wc_CryptoCb_DefaultDevID();
1942        }
1943    #endif
1944        return wc_Sha224Hash_ex(data, len, hash, NULL, devId);
1945    }
1946#endif /* WOLFSSL_SHA224 */
1947
1948#if !defined(NO_SHA256)
1949    int wc_Sha256Hash_ex(const byte* data, word32 len, byte* hash,
1950        void* heap, int devId)
1951    {
1952        int ret = 0;
1953    #if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
1954        wc_Sha256* sha256;
1955    #else
1956        wc_Sha256 sha256[1];
1957    #endif
1958
1959    #if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
1960        sha256 = (wc_Sha256*)XMALLOC(sizeof(wc_Sha256), NULL,
1961            DYNAMIC_TYPE_TMP_BUFFER);
1962        if (sha256 == NULL)
1963            return MEMORY_E;
1964    #endif
1965
1966        if ((ret = wc_InitSha256_ex(sha256, heap, devId)) != 0) {
1967            WOLFSSL_MSG("InitSha256 failed");
1968        }
1969        else {
1970            if ((ret = wc_Sha256Update(sha256, data, len)) != 0) {
1971                WOLFSSL_MSG("Sha256Update failed");
1972            }
1973            else if ((ret = wc_Sha256Final(sha256, hash)) != 0) {
1974                WOLFSSL_MSG("Sha256Final failed");
1975            }
1976            wc_Sha256Free(sha256);
1977        }
1978
1979
1980    #if defined(WOLFSSL_SMALL_STACK) && !defined(WOLFSSL_NO_MALLOC)
1981        XFREE(sha256, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1982    #endif
1983
1984        return ret;
1985    }
1986    int wc_Sha256Hash(const byte* data, word32 len, byte* hash)
1987    {
1988        int devId = INVALID_DEVID;
1989    #ifdef WOLF_CRYPTO_CB
1990        /* find devId if its not an empty hash */
1991        if (data != NULL && len > 0) {
1992            devId = wc_CryptoCb_DefaultDevID();
1993        }
1994    #endif
1995        return wc_Sha256Hash_ex(data, len, hash, NULL, devId);
1996    }
1997#endif /* !NO_SHA256 */
1998
1999#endif /* !defined(WOLFSSL_TI_HASH) */
2000
2001
2002#if defined(WOLFSSL_SHA512)
2003    int wc_Sha512Hash_ex(const byte* data, word32 len, byte* hash,
2004        void* heap, int devId)
2005    {
2006        int ret = 0;
2007        WC_DECLARE_VAR(sha512, wc_Sha512, 1, 0);
2008
2009        WC_ALLOC_VAR_EX(sha512, wc_Sha512, 1, NULL, DYNAMIC_TYPE_TMP_BUFFER,
2010            return MEMORY_E);
2011
2012        if ((ret = wc_InitSha512_ex(sha512, heap, devId)) != 0) {
2013            WOLFSSL_MSG("InitSha512 failed");
2014        }
2015        else {
2016            if ((ret = wc_Sha512Update(sha512, data, len)) != 0) {
2017                WOLFSSL_MSG("Sha512Update failed");
2018            }
2019            else if ((ret = wc_Sha512Final(sha512, hash)) != 0) {
2020                WOLFSSL_MSG("Sha512Final failed");
2021            }
2022            wc_Sha512Free(sha512);
2023        }
2024
2025        WC_FREE_VAR_EX(sha512, NULL, DYNAMIC_TYPE_TMP_BUFFER);
2026
2027        return ret;
2028    }
2029    int wc_Sha512Hash(const byte* data, word32 len, byte* hash)
2030    {
2031        int devId = INVALID_DEVID;
2032    #ifdef WOLF_CRYPTO_CB
2033        /* find devId if its not an empty hash */
2034        if (data != NULL && len > 0) {
2035            devId = wc_CryptoCb_DefaultDevID();
2036        }
2037    #endif
2038        return wc_Sha512Hash_ex(data, len, hash, NULL, devId);
2039    }
2040#if (!defined(HAVE_FIPS) || FIPS_VERSION3_GE(7,0,0)) && !defined(HAVE_SELFTEST)
2041#ifndef WOLFSSL_NOSHA512_224
2042    int wc_Sha512_224Hash_ex(const byte* data, word32 len, byte* hash,
2043        void* heap, int devId)
2044    {
2045        int ret = 0;
2046        WC_DECLARE_VAR(sha512, wc_Sha512, 1, 0);
2047
2048        WC_ALLOC_VAR_EX(sha512, wc_Sha512, 1, NULL, DYNAMIC_TYPE_TMP_BUFFER,
2049            return MEMORY_E);
2050
2051        if ((ret = wc_InitSha512_224_ex(sha512, heap, devId)) != 0) {
2052            WOLFSSL_MSG("wc_InitSha512_224 failed");
2053        }
2054        else {
2055            if ((ret = wc_Sha512_224Update(sha512, data, len)) != 0) {
2056                WOLFSSL_MSG("wc_Sha512_224_Update failed");
2057            }
2058            else if ((ret = wc_Sha512_224Final(sha512, hash)) != 0) {
2059                WOLFSSL_MSG("wc_Sha512_224_Final failed");
2060            }
2061            wc_Sha512_224Free(sha512);
2062        }
2063
2064        WC_FREE_VAR_EX(sha512, NULL, DYNAMIC_TYPE_TMP_BUFFER);
2065
2066        return ret;
2067    }
2068    int wc_Sha512_224Hash(const byte* data, word32 len, byte* hash)
2069    {
2070        int devId = INVALID_DEVID;
2071    #ifdef WOLF_CRYPTO_CB
2072        /* find devId if its not an empty hash */
2073        if (data != NULL && len > 0) {
2074            devId = wc_CryptoCb_DefaultDevID();
2075        }
2076    #endif
2077        return wc_Sha512_224Hash_ex(data, len, hash, NULL, devId);
2078    }
2079#endif /* !WOLFSSL_NOSHA512_224 */
2080#endif /* (!HAVE_FIPS || FIPS v7+) && !HAVE_SELFTEST */
2081
2082#if (!defined(HAVE_FIPS) || FIPS_VERSION3_GE(7,0,0)) && !defined(HAVE_SELFTEST)
2083#ifndef WOLFSSL_NOSHA512_256
2084    int wc_Sha512_256Hash_ex(const byte* data, word32 len, byte* hash,
2085        void* heap, int devId)
2086    {
2087        int ret = 0;
2088        WC_DECLARE_VAR(sha512, wc_Sha512, 1, 0);
2089
2090        WC_ALLOC_VAR_EX(sha512, wc_Sha512, 1, NULL, DYNAMIC_TYPE_TMP_BUFFER,
2091            return MEMORY_E);
2092
2093        if ((ret = wc_InitSha512_256_ex(sha512, heap, devId)) != 0) {
2094            WOLFSSL_MSG("wc_InitSha512_256 failed");
2095        }
2096        else {
2097            if ((ret = wc_Sha512_256Update(sha512, data, len)) != 0) {
2098                WOLFSSL_MSG("wc_Sha512_256_Update failed");
2099            }
2100            else if ((ret = wc_Sha512_256Final(sha512, hash)) != 0) {
2101                WOLFSSL_MSG("wc_Sha512_256_Final failed");
2102            }
2103            wc_Sha512_256Free(sha512);
2104        }
2105
2106        WC_FREE_VAR_EX(sha512, NULL, DYNAMIC_TYPE_TMP_BUFFER);
2107
2108        return ret;
2109    }
2110    int wc_Sha512_256Hash(const byte* data, word32 len, byte* hash)
2111    {
2112        int devId = INVALID_DEVID;
2113    #ifdef WOLF_CRYPTO_CB
2114        /* find devId if its not an empty hash */
2115        if (data != NULL && len > 0) {
2116            devId = wc_CryptoCb_DefaultDevID();
2117        }
2118    #endif
2119        return wc_Sha512_256Hash_ex(data, len, hash, NULL, devId);
2120    }
2121#endif /* !WOLFSSL_NOSHA512_256 */
2122#endif /* (!HAVE_FIPS || FIPS v7+) && !HAVE_SELFTEST */
2123
2124#endif /* WOLFSSL_SHA512 */
2125
2126#if defined(WOLFSSL_SHA384)
2127    int wc_Sha384Hash_ex(const byte* data, word32 len, byte* hash,
2128        void* heap, int devId)
2129    {
2130        int ret = 0;
2131        WC_DECLARE_VAR(sha384, wc_Sha384, 1, 0);
2132
2133        WC_ALLOC_VAR_EX(sha384, wc_Sha384, 1, NULL, DYNAMIC_TYPE_TMP_BUFFER,
2134            return MEMORY_E);
2135
2136        if ((ret = wc_InitSha384_ex(sha384, heap, devId)) != 0) {
2137            WOLFSSL_MSG("InitSha384 failed");
2138        }
2139        else {
2140            if ((ret = wc_Sha384Update(sha384, data, len)) != 0) {
2141                WOLFSSL_MSG("Sha384Update failed");
2142            }
2143            else if ((ret = wc_Sha384Final(sha384, hash)) != 0) {
2144                WOLFSSL_MSG("Sha384Final failed");
2145            }
2146            wc_Sha384Free(sha384);
2147        }
2148
2149        WC_FREE_VAR_EX(sha384, NULL, DYNAMIC_TYPE_TMP_BUFFER);
2150
2151        return ret;
2152    }
2153    int wc_Sha384Hash(const byte* data, word32 len, byte* hash)
2154    {
2155        int devId = INVALID_DEVID;
2156    #ifdef WOLF_CRYPTO_CB
2157        /* find devId if its not an empty hash */
2158        if (data != NULL && len > 0) {
2159            devId = wc_CryptoCb_DefaultDevID();
2160        }
2161    #endif
2162        return wc_Sha384Hash_ex(data, len, hash, NULL, devId);
2163    }
2164#endif /* WOLFSSL_SHA384 */
2165
2166#if defined(WOLFSSL_SHA3)
2167#if !defined(WOLFSSL_NOSHA3_224)
2168    int wc_Sha3_224Hash_ex(const byte* data, word32 len, byte* hash,
2169        void* heap, int devId)
2170    {
2171        int ret = 0;
2172        WC_DECLARE_VAR(sha3, wc_Sha3, 1, 0);
2173
2174        WC_ALLOC_VAR_EX(sha3, wc_Sha3, 1, NULL, DYNAMIC_TYPE_TMP_BUFFER,
2175            return MEMORY_E);
2176
2177        if ((ret = wc_InitSha3_224(sha3, heap, devId)) != 0) {
2178            WOLFSSL_MSG("InitSha3_224 failed");
2179        }
2180        else {
2181            if ((ret = wc_Sha3_224_Update(sha3, data, len)) != 0) {
2182                WOLFSSL_MSG("Sha3_224_Update failed");
2183            }
2184            else if ((ret = wc_Sha3_224_Final(sha3, hash)) != 0) {
2185                WOLFSSL_MSG("Sha3_224_Final failed");
2186            }
2187            wc_Sha3_224_Free(sha3);
2188        }
2189
2190        WC_FREE_VAR_EX(sha3, NULL, DYNAMIC_TYPE_TMP_BUFFER);
2191
2192        return ret;
2193    }
2194    int wc_Sha3_224Hash(const byte* data, word32 len, byte* hash)
2195    {
2196        int devId = INVALID_DEVID;
2197    #ifdef WOLF_CRYPTO_CB
2198        /* find devId if its not an empty hash */
2199        if (data != NULL && len > 0) {
2200            devId = wc_CryptoCb_DefaultDevID();
2201        }
2202    #endif
2203        return wc_Sha3_224Hash_ex(data, len, hash, NULL, devId);
2204    }
2205#endif /* !WOLFSSL_NOSHA3_224 */
2206
2207#if !defined(WOLFSSL_NOSHA3_256)
2208    int wc_Sha3_256Hash_ex(const byte* data, word32 len, byte* hash,
2209        void* heap, int devId)
2210    {
2211        int ret = 0;
2212        WC_DECLARE_VAR(sha3, wc_Sha3, 1, 0);
2213
2214        WC_ALLOC_VAR_EX(sha3, wc_Sha3, 1, NULL, DYNAMIC_TYPE_TMP_BUFFER,
2215            return MEMORY_E);
2216
2217        if ((ret = wc_InitSha3_256(sha3, heap, devId)) != 0) {
2218            WOLFSSL_MSG("InitSha3_256 failed");
2219        }
2220        else {
2221            if ((ret = wc_Sha3_256_Update(sha3, data, len)) != 0) {
2222                WOLFSSL_MSG("Sha3_256_Update failed");
2223            }
2224            else if ((ret = wc_Sha3_256_Final(sha3, hash)) != 0) {
2225                WOLFSSL_MSG("Sha3_256_Final failed");
2226            }
2227            wc_Sha3_256_Free(sha3);
2228        }
2229
2230        WC_FREE_VAR_EX(sha3, NULL, DYNAMIC_TYPE_TMP_BUFFER);
2231
2232        return ret;
2233    }
2234    int wc_Sha3_256Hash(const byte* data, word32 len, byte* hash)
2235    {
2236        int devId = INVALID_DEVID;
2237    #ifdef WOLF_CRYPTO_CB
2238        /* find devId if its not an empty hash */
2239        if (data != NULL && len > 0) {
2240            devId = wc_CryptoCb_DefaultDevID();
2241        }
2242    #endif
2243        return wc_Sha3_256Hash_ex(data, len, hash, NULL, devId);
2244    }
2245#endif /* !WOLFSSL_NOSHA3_256 */
2246
2247#if !defined(WOLFSSL_NOSHA3_384)
2248    int wc_Sha3_384Hash_ex(const byte* data, word32 len, byte* hash,
2249        void* heap, int devId)
2250    {
2251        int ret = 0;
2252        WC_DECLARE_VAR(sha3, wc_Sha3, 1, 0);
2253
2254        WC_ALLOC_VAR_EX(sha3, wc_Sha3, 1, NULL, DYNAMIC_TYPE_TMP_BUFFER,
2255            return MEMORY_E);
2256
2257        if ((ret = wc_InitSha3_384(sha3, heap, devId)) != 0) {
2258            WOLFSSL_MSG("InitSha3_384 failed");
2259        }
2260        else {
2261            if ((ret = wc_Sha3_384_Update(sha3, data, len)) != 0) {
2262                WOLFSSL_MSG("Sha3_384_Update failed");
2263            }
2264            else if ((ret = wc_Sha3_384_Final(sha3, hash)) != 0) {
2265                WOLFSSL_MSG("Sha3_384_Final failed");
2266            }
2267            wc_Sha3_384_Free(sha3);
2268        }
2269
2270        WC_FREE_VAR_EX(sha3, NULL, DYNAMIC_TYPE_TMP_BUFFER);
2271
2272        return ret;
2273    }
2274    int wc_Sha3_384Hash(const byte* data, word32 len, byte* hash)
2275    {
2276        int devId = INVALID_DEVID;
2277    #ifdef WOLF_CRYPTO_CB
2278        /* find devId if its not an empty hash */
2279        if (data != NULL && len > 0) {
2280            devId = wc_CryptoCb_DefaultDevID();
2281        }
2282    #endif
2283        return wc_Sha3_384Hash_ex(data, len, hash, NULL, devId);
2284    }
2285#endif /* !WOLFSSL_NOSHA3_384 */
2286
2287#if !defined(WOLFSSL_NOSHA3_512)
2288    int wc_Sha3_512Hash_ex(const byte* data, word32 len, byte* hash,
2289        void* heap, int devId)
2290    {
2291        int ret = 0;
2292        WC_DECLARE_VAR(sha3, wc_Sha3, 1, 0);
2293
2294        WC_ALLOC_VAR_EX(sha3, wc_Sha3, 1, NULL, DYNAMIC_TYPE_TMP_BUFFER,
2295            return MEMORY_E);
2296
2297        if ((ret = wc_InitSha3_512(sha3, heap, devId)) != 0) {
2298            WOLFSSL_MSG("InitSha3_512 failed");
2299        }
2300        else {
2301            if ((ret = wc_Sha3_512_Update(sha3, data, len)) != 0) {
2302                WOLFSSL_MSG("Sha3_512_Update failed");
2303            }
2304            else if ((ret = wc_Sha3_512_Final(sha3, hash)) != 0) {
2305                WOLFSSL_MSG("Sha3_512_Final failed");
2306            }
2307            wc_Sha3_512_Free(sha3);
2308        }
2309
2310        WC_FREE_VAR_EX(sha3, NULL, DYNAMIC_TYPE_TMP_BUFFER);
2311
2312        return ret;
2313    }
2314    int wc_Sha3_512Hash(const byte* data, word32 len, byte* hash)
2315    {
2316        int devId = INVALID_DEVID;
2317    #ifdef WOLF_CRYPTO_CB
2318        /* find devId if its not an empty hash */
2319        if (data != NULL && len > 0) {
2320            devId = wc_CryptoCb_DefaultDevID();
2321        }
2322    #endif
2323        return wc_Sha3_512Hash_ex(data, len, hash, NULL, devId);
2324    }
2325#endif /* !WOLFSSL_NOSHA3_512 */
2326
2327#ifdef WOLFSSL_SHAKE128
2328    int wc_Shake128Hash_ex(const byte* data, word32 len, byte* hash,
2329                        word32 hashLen, void* heap, int devId)
2330    {
2331        int ret = 0;
2332        WC_DECLARE_VAR(shake, wc_Shake, 1, 0);
2333
2334        WC_ALLOC_VAR_EX(shake, wc_Shake, 1, NULL, DYNAMIC_TYPE_TMP_BUFFER,
2335            return MEMORY_E);
2336
2337        if ((ret = wc_InitShake128(shake, heap, devId)) != 0) {
2338            WOLFSSL_MSG("InitShake128 failed");
2339        }
2340        else {
2341            if ((ret = wc_Shake128_Update(shake, data, len)) != 0) {
2342                WOLFSSL_MSG("Shake128_Update failed");
2343            }
2344            else if ((ret = wc_Shake128_Final(shake, hash, hashLen)) != 0) {
2345                WOLFSSL_MSG("Shake128_Final failed");
2346            }
2347            wc_Shake128_Free(shake);
2348        }
2349
2350        WC_FREE_VAR_EX(shake, NULL, DYNAMIC_TYPE_TMP_BUFFER);
2351
2352        return ret;
2353    }
2354    int wc_Shake128Hash(const byte* data, word32 len, byte* hash,
2355                        word32 hashLen)
2356    {
2357        int devId = INVALID_DEVID;
2358    #ifdef WOLF_CRYPTO_CB
2359        /* find devId if its not an empty hash */
2360        if (data != NULL && len > 0) {
2361            devId = wc_CryptoCb_DefaultDevID();
2362        }
2363    #endif
2364        return wc_Shake128Hash_ex(data, len, hash, hashLen,
2365            NULL, devId);
2366    }
2367#endif /* WOLFSSL_SHAKE_128 */
2368
2369#ifdef WOLFSSL_SHAKE256
2370    int wc_Shake256Hash_ex(const byte* data, word32 len, byte* hash,
2371                        word32 hashLen, void* heap, int devId)
2372    {
2373        int ret = 0;
2374        WC_DECLARE_VAR(shake, wc_Shake, 1, 0);
2375
2376        WC_ALLOC_VAR_EX(shake, wc_Shake, 1, NULL, DYNAMIC_TYPE_TMP_BUFFER,
2377            return MEMORY_E);
2378
2379        if ((ret = wc_InitShake256(shake, heap, devId)) != 0) {
2380            WOLFSSL_MSG("InitShake256 failed");
2381        }
2382        else {
2383            if ((ret = wc_Shake256_Update(shake, data, len)) != 0) {
2384                WOLFSSL_MSG("Shake256_Update failed");
2385            }
2386            else if ((ret = wc_Shake256_Final(shake, hash, hashLen)) != 0) {
2387                WOLFSSL_MSG("Shake256_Final failed");
2388            }
2389            wc_Shake256_Free(shake);
2390        }
2391
2392        WC_FREE_VAR_EX(shake, NULL, DYNAMIC_TYPE_TMP_BUFFER);
2393
2394        return ret;
2395    }
2396    int wc_Shake256Hash(const byte* data, word32 len, byte* hash,
2397                        word32 hashLen)
2398    {
2399        int devId = INVALID_DEVID;
2400    #ifdef WOLF_CRYPTO_CB
2401        /* find devId if its not an empty hash */
2402        if (data != NULL && len > 0) {
2403            devId = wc_CryptoCb_DefaultDevID();
2404        }
2405    #endif
2406        return wc_Shake256Hash_ex(data, len, hash, hashLen,
2407            NULL, devId);
2408    }
2409#endif /* WOLFSSL_SHAKE_256 */
2410#endif /* WOLFSSL_SHA3 */
2411
2412#ifdef WOLFSSL_SM3
2413    int wc_Sm3Hash_ex(const byte* data, word32 len, byte* hash,
2414        void* heap, int devId)
2415    {
2416        int ret = 0;
2417        WC_DECLARE_VAR(sm3, wc_Sm3, 1, 0);
2418
2419        WC_ALLOC_VAR_EX(sm3, wc_Sm3, 1, NULL, DYNAMIC_TYPE_TMP_BUFFER,
2420            return MEMORY_E);
2421
2422        if ((ret = wc_InitSm3(sm3, heap, devId)) != 0) {
2423            WOLFSSL_MSG("InitSm3 failed");
2424        }
2425        else {
2426            if ((ret = wc_Sm3Update(sm3, data, len)) != 0) {
2427                WOLFSSL_MSG("Sm3Update failed");
2428            }
2429            else if ((ret = wc_Sm3Final(sm3, hash)) != 0) {
2430                WOLFSSL_MSG("Sm3Final failed");
2431            }
2432            wc_Sm3Free(sm3);
2433        }
2434
2435        WC_FREE_VAR_EX(sm3, NULL, DYNAMIC_TYPE_TMP_BUFFER);
2436
2437        return ret;
2438    }
2439    int wc_Sm3Hash(const byte* data, word32 len, byte* hash)
2440    {
2441        int devId = INVALID_DEVID;
2442    #ifdef WOLF_CRYPTO_CB
2443        /* find devId if its not an empty hash */
2444        if (data != NULL && len > 0) {
2445            devId = wc_CryptoCb_DefaultDevID();
2446        }
2447    #endif
2448        return wc_Sm3Hash_ex(data, len, hash, NULL, devId);
2449    }
2450#endif /* !WOLFSSL_NOSHA3_224 */
2451
2452#endif /* !NO_HASH_WRAPPER */
2453
2454#ifdef WOLFSSL_HASH_KEEP
2455int _wc_Hash_Grow(byte** msg, word32* used, word32* len, const byte* in,
2456                        int inSz, void* heap)
2457{
2458    word32 usedSz = 0;
2459
2460    if (inSz < 0 || !WC_SAFE_SUM_WORD32(*used, (word32)inSz, usedSz))
2461        return BAD_FUNC_ARG;
2462
2463    /* Allow zero-length input as a no-op. Some callers may pass zero-length
2464     * data during hash operations and this should not be treated as an error. */
2465    if (inSz == 0)
2466        return 0;
2467
2468    if (*len < usedSz) {
2469        if (*msg == NULL) {
2470            *msg = (byte*)XMALLOC(usedSz, heap, DYNAMIC_TYPE_TMP_BUFFER);
2471        }
2472        else {
2473            byte* pt = (byte*)XREALLOC(*msg, usedSz, heap,
2474                    DYNAMIC_TYPE_TMP_BUFFER);
2475            if (pt == NULL) {
2476                return MEMORY_E;
2477            }
2478            *msg = pt;
2479        }
2480        if (*msg == NULL) {
2481            return MEMORY_E;
2482        }
2483        *len = usedSz;
2484    }
2485    XMEMCPY(*msg + *used, in, inSz);
2486    *used += inSz;
2487    return 0;
2488}
2489#endif /* WOLFSSL_HASH_KEEP */
2490