CryptoPkg/Library/BaseHashApiLib/BaseHashApiLib.c

   1 /** @file
   2   Unified Hash API Implementation
   3
   4   This file implements the Unified Hash API.
   5
   6   This API, when called, will calculate the Hash using the
   7   hashing algorithm specified by PcdHashApiLibPolicy.
   8
   9   Copyright (c) 2020, Intel Corporation. All rights reserved.<BR>
  10   SPDX-License-Identifier: BSD-2-Clause-Patent
  11
  12 **/
  13
  14 #include <Base.h>
  15 #include <Library/BaseLib.h>
  16 #include <Library/BaseMemoryLib.h>
  17 #include <Library/MemoryAllocationLib.h>
  18 #include <Library/BaseCryptLib.h>
  19 #include <Library/DebugLib.h>
  20 #include <Library/PcdLib.h>
  21 #include <Library/HashApiLib.h>
  22
  23 /**
  24   Retrieves the size, in bytes, of the context buffer required for hash operations.
  25
  26   @return  The size, in bytes, of the context buffer required for hash operations.
  27 **/
  28 UINTN
  29 EFIAPI
  30 HashApiGetContextSize (
  31   VOID
  32   )
  33 {
  34   switch (PcdGet8 (PcdHashApiLibPolicy)) {
  35     case HASH_API_ALGO_MD4:
  36       return Md4GetContextSize ();
  37       break;
  38
  39     case HASH_API_ALGO_MD5:
  40       return Md5GetContextSize ();
  41       break;
  42
  43     case HASH_API_ALGO_SHA1:
  44       return Sha1GetContextSize ();
  45       break;
  46
  47     case HASH_API_ALGO_SHA256:
  48       return Sha256GetContextSize ();
  49       break;
  50
  51     case HASH_API_ALGO_SHA384:
  52       return Sha384GetContextSize ();
  53       break;
  54
  55     case HASH_API_ALGO_SHA512:
  56       return Sha512GetContextSize ();
  57       break;
  58
  59     case HASH_API_ALGO_SM3_256:
  60       return Sm3GetContextSize ();
  61       break;
  62
  63     default:
  64       ASSERT (FALSE);
  65       return 0;
  66       break;
  67   }
  68 }
  69
  70 /**
  71   Init hash sequence.
  72
  73   @param[out] HashContext   Hash context.
  74
  75   @retval TRUE         Hash start and HashHandle returned.
  76   @retval FALSE        Hash Init unsuccessful.
  77 **/
  78 BOOLEAN
  79 EFIAPI
  80 HashApiInit (
  81   OUT HASH_API_CONTEXT  HashContext
  82   )
  83 {
  84   switch (PcdGet8 (PcdHashApiLibPolicy)) {
  85     case HASH_API_ALGO_MD4:
  86       return Md4Init (HashContext);
  87       break;
  88
  89     case HASH_API_ALGO_MD5:
  90       return Md5Init (HashContext);
  91       break;
  92
  93     case HASH_API_ALGO_SHA1:
  94       return Sha1Init (HashContext);
  95       break;
  96
  97     case HASH_API_ALGO_SHA256:
  98       return Sha256Init (HashContext);
  99       break;
 100
 101     case HASH_API_ALGO_SHA384:
 102       return Sha384Init (HashContext);
 103       break;
 104
 105     case HASH_API_ALGO_SHA512:
 106       return Sha512Init (HashContext);
 107       break;
 108
 109     case HASH_API_ALGO_SM3_256:
 110       return Sm3Init (HashContext);
 111       break;
 112
 113     default:
 114       ASSERT (FALSE);
 115       return FALSE;
 116       break;
 117   }
 118 }
 119
 120 /**
 121   Makes a copy of an existing hash context.
 122
 123   @param[in]  HashContext     Hash context.
 124   @param[out] NewHashContext  New copy of hash context.
 125
 126   @retval TRUE         Hash context copy succeeded.
 127   @retval FALSE        Hash context copy failed.
 128 **/
 129 BOOLEAN
 130 EFIAPI
 131 HashApiDuplicate (
 132   IN  HASH_API_CONTEXT  HashContext,
 133   OUT HASH_API_CONTEXT  NewHashContext
 134   )
 135 {
 136   switch (PcdGet8 (PcdHashApiLibPolicy)) {
 137     case HASH_API_ALGO_MD4:
 138       return Md4Duplicate (HashContext, NewHashContext);
 139       break;
 140
 141     case HASH_API_ALGO_MD5:
 142       return Md5Duplicate (HashContext, NewHashContext);
 143       break;
 144
 145     case HASH_API_ALGO_SHA1:
 146       return Sha1Duplicate (HashContext, NewHashContext);
 147       break;
 148
 149     case HASH_API_ALGO_SHA256:
 150       return Sha256Duplicate (HashContext, NewHashContext);
 151       break;
 152
 153     case HASH_API_ALGO_SHA384:
 154       return Sha384Duplicate (HashContext, NewHashContext);
 155       break;
 156
 157     case HASH_API_ALGO_SHA512:
 158       return Sha512Duplicate (HashContext, NewHashContext);
 159       break;
 160
 161     case HASH_API_ALGO_SM3_256:
 162       return Sm3Duplicate (HashContext, NewHashContext);
 163       break;
 164
 165     default:
 166       ASSERT (FALSE);
 167       return FALSE;
 168       break;
 169   }
 170 }
 171
 172 /**
 173   Update hash data.
 174
 175   @param[in] HashContext   Hash context.
 176   @param[in] DataToHash    Data to be hashed.
 177   @param[in] DataToHashLen Data size.
 178
 179   @retval TRUE         Hash updated.
 180   @retval FALSE        Hash updated unsuccessful.
 181 **/
 182 BOOLEAN
 183 EFIAPI
 184 HashApiUpdate (
 185   IN HASH_API_CONTEXT  HashContext,
 186   IN VOID              *DataToHash,
 187   IN UINTN             DataToHashLen
 188   )
 189 {
 190   switch (PcdGet8 (PcdHashApiLibPolicy)) {
 191     case HASH_API_ALGO_MD4:
 192       return Md4Update (HashContext, DataToHash, DataToHashLen);
 193       break;
 194
 195     case HASH_API_ALGO_MD5:
 196       return Md5Update (HashContext, DataToHash, DataToHashLen);
 197       break;
 198
 199     case HASH_API_ALGO_SHA1:
 200       return Sha1Update (HashContext, DataToHash, DataToHashLen);
 201       break;
 202
 203     case HASH_API_ALGO_SHA256:
 204       return Sha256Update (HashContext, DataToHash, DataToHashLen);
 205       break;
 206
 207     case HASH_API_ALGO_SHA384:
 208       return Sha384Update (HashContext, DataToHash, DataToHashLen);
 209       break;
 210
 211     case HASH_API_ALGO_SHA512:
 212       return Sha512Update (HashContext, DataToHash, DataToHashLen);
 213       break;
 214
 215     case HASH_API_ALGO_SM3_256:
 216       return Sm3Update (HashContext, DataToHash, DataToHashLen);
 217       break;
 218
 219     default:
 220       ASSERT (FALSE);
 221       return FALSE;
 222       break;
 223   }
 224 }
 225
 226 /**
 227   Hash complete.
 228
 229   @param[in]  HashContext  Hash context.
 230   @param[out] Digest       Hash Digest.
 231
 232   @retval TRUE         Hash complete and Digest is returned.
 233   @retval FALSE        Hash complete unsuccessful.
 234 **/
 235 BOOLEAN
 236 EFIAPI
 237 HashApiFinal (
 238   IN  HASH_API_CONTEXT  HashContext,
 239   OUT UINT8             *Digest
 240   )
 241 {
 242   switch (PcdGet8 (PcdHashApiLibPolicy)) {
 243     case HASH_API_ALGO_MD4:
 244       return Md4Final (HashContext, Digest);
 245       break;
 246
 247     case HASH_API_ALGO_MD5:
 248       return Md5Final (HashContext, Digest);
 249       break;
 250
 251     case HASH_API_ALGO_SHA1:
 252       return Sha1Final (HashContext, Digest);
 253       break;
 254
 255     case HASH_API_ALGO_SHA256:
 256       return Sha256Final (HashContext, Digest);
 257       break;
 258
 259     case HASH_API_ALGO_SHA384:
 260       return Sha384Final (HashContext, Digest);
 261       break;
 262
 263     case HASH_API_ALGO_SHA512:
 264       return Sha512Final (HashContext, Digest);
 265       break;
 266
 267     case HASH_API_ALGO_SM3_256:
 268       return Sm3Final (HashContext, Digest);
 269       break;
 270
 271     default:
 272       ASSERT (FALSE);
 273       return FALSE;
 274       break;
 275   }
 276 }
 277
 278 /**
 279   Computes hash message digest of a input data buffer.
 280
 281   @param[in]  DataToHash     Data to be hashed.
 282   @param[in]  DataToHashLen  Data size.
 283   @param[out] Digest         Hash Digest.
 284
 285   @retval TRUE   Hash digest computation succeeded.
 286   @retval FALSE  Hash digest computation failed.
 287 **/
 288 BOOLEAN
 289 EFIAPI
 290 HashApiHashAll (
 291   IN  CONST VOID  *DataToHash,
 292   IN  UINTN       DataToHashLen,
 293   OUT UINT8       *Digest
 294   )
 295 {
 296   switch (PcdGet8 (PcdHashApiLibPolicy)) {
 297     case HASH_API_ALGO_MD4:
 298       return Md4HashAll (DataToHash, DataToHashLen, Digest);
 299       break;
 300
 301     case HASH_API_ALGO_MD5:
 302       return Md5HashAll (DataToHash, DataToHashLen, Digest);
 303       break;
 304
 305     case HASH_API_ALGO_SHA1:
 306       return Sha1HashAll (DataToHash, DataToHashLen, Digest);
 307       break;
 308
 309     case HASH_API_ALGO_SHA256:
 310       return Sha256HashAll (DataToHash, DataToHashLen, Digest);
 311       break;
 312
 313     case HASH_API_ALGO_SHA384:
 314       return Sha384HashAll (DataToHash, DataToHashLen, Digest);
 315       break;
 316
 317     case HASH_API_ALGO_SHA512:
 318       return Sha512HashAll (DataToHash, DataToHashLen, Digest);
 319       break;
 320
 321     case HASH_API_ALGO_SM3_256:
 322       return Sm3HashAll (DataToHash, DataToHashLen, Digest);
 323       break;
 324
 325     default:
 326       ASSERT (FALSE);
 327       return FALSE;
 328       break;
 329   }
 330 }