SecurityPkg/Hash2DxeCrypto/Hash2DxeCrypto.c

   1 /** @file
   2   This module implements Hash2 Protocol.
   3
   4 Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>
   5 This program and the accompanying materials are licensed and made available under
   6 the terms and conditions of the BSD License that accompanies this distribution.
   7 The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php.
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include <Uefi.h>
  16 #include <Protocol/Hash2.h>
  17 #include <Library/BaseLib.h>
  18 #include <Library/UefiBootServicesTableLib.h>
  19 #include <Library/MemoryAllocationLib.h>
  20 #include <Library/BaseMemoryLib.h>
  21 #include <Library/DebugLib.h>
  22 #include <Library/BaseCryptLib.h>
  23
  24 #include "Driver.h"
  25
  26 /**
  27   Retrieves the size, in bytes, of the context buffer required for hash operations.
  28
  29   If this interface is not supported, then return zero.
  30
  31   @return  The size, in bytes, of the context buffer required for hash operations.
  32   @retval  0   This interface is not supported.
  33
  34 **/
  35 typedef
  36 UINTN
  37 (EFIAPI *EFI_HASH_GET_CONTEXT_SIZE) (
  38   VOID
  39   );
  40
  41 /**
  42   Initializes user-supplied memory pointed by Sha1Context as hash context for
  43   subsequent use.
  44
  45   If HashContext is NULL, then return FALSE.
  46   If this interface is not supported, then return FALSE.
  47
  48   @param[out]  HashContext  Pointer to Hashcontext being initialized.
  49
  50   @retval TRUE   Hash context initialization succeeded.
  51   @retval FALSE  Hash context initialization failed.
  52   @retval FALSE  This interface is not supported.
  53
  54 **/
  55 typedef
  56 BOOLEAN
  57 (EFIAPI *EFI_HASH_INIT) (
  58   OUT  VOID  *HashContext
  59   );
  60
  61 /**
  62   Digests the input data and updates Hash context.
  63
  64   This function performs Hash digest on a data buffer of the specified size.
  65   It can be called multiple times to compute the digest of long or discontinuous data streams.
  66   Hash context should be already correctly intialized by HashInit(), and should not be finalized
  67   by HashFinal(). Behavior with invalid context is undefined.
  68
  69   If HashContext is NULL, then return FALSE.
  70   If this interface is not supported, then return FALSE.
  71
  72   @param[in, out]  HashContext  Pointer to the Hash context.
  73   @param[in]       Data         Pointer to the buffer containing the data to be hashed.
  74   @param[in]       DataSize     Size of Data buffer in bytes.
  75
  76   @retval TRUE   SHA-1 data digest succeeded.
  77   @retval FALSE  SHA-1 data digest failed.
  78   @retval FALSE  This interface is not supported.
  79
  80 **/
  81 typedef
  82 BOOLEAN
  83 (EFIAPI *EFI_HASH_UPDATE) (
  84   IN OUT  VOID        *HashContext,
  85   IN      CONST VOID  *Data,
  86   IN      UINTN       DataSize
  87   );
  88
  89 /**
  90   Completes computation of the Hash digest value.
  91
  92   This function completes hash computation and retrieves the digest value into
  93   the specified memory. After this function has been called, the Hash context cannot
  94   be used again.
  95   Hash context should be already correctly intialized by HashInit(), and should not be
  96   finalized by HashFinal(). Behavior with invalid Hash context is undefined.
  97
  98   If HashContext is NULL, then return FALSE.
  99   If HashValue is NULL, then return FALSE.
 100   If this interface is not supported, then return FALSE.
 101
 102   @param[in, out]  HashContext  Pointer to the Hash context.
 103   @param[out]      HashValue    Pointer to a buffer that receives the Hash digest
 104                                 value.
 105
 106   @retval TRUE   Hash digest computation succeeded.
 107   @retval FALSE  Hash digest computation failed.
 108   @retval FALSE  This interface is not supported.
 109
 110 **/
 111 typedef
 112 BOOLEAN
 113 (EFIAPI *EFI_HASH_FINAL) (
 114   IN OUT  VOID   *HashContext,
 115   OUT     UINT8  *HashValue
 116   );
 117
 118 typedef struct {
 119   EFI_GUID                   *Guid;
 120   UINT32                     HashSize;
 121   EFI_HASH_GET_CONTEXT_SIZE  GetContextSize;
 122   EFI_HASH_INIT              Init;
 123   EFI_HASH_UPDATE            Update;
 124   EFI_HASH_FINAL             Final;
 125 } EFI_HASH_INFO;
 126
 127 EFI_HASH_INFO  mHashInfo[] = {
 128   {&gEfiHashAlgorithmSha1Guid,    sizeof(EFI_SHA1_HASH2),   Sha1GetContextSize,   Sha1Init,   Sha1Update,   Sha1Final   },
 129   {&gEfiHashAlgorithmSha256Guid,  sizeof(EFI_SHA256_HASH2), Sha256GetContextSize, Sha256Init, Sha256Update, Sha256Final },
 130   {&gEfiHashAlgorithmSha384Guid,  sizeof(EFI_SHA384_HASH2), Sha384GetContextSize, Sha384Init, Sha384Update, Sha384Final },
 131   {&gEfiHashAlgorithmSha512Guid,  sizeof(EFI_SHA512_HASH2), Sha512GetContextSize, Sha512Init, Sha512Update, Sha512Final },
 132 };
 133
 134 /**
 135   Returns the size of the hash which results from a specific algorithm.
 136
 137   @param[in]  This                  Points to this instance of EFI_HASH2_PROTOCOL.
 138   @param[in]  HashAlgorithm         Points to the EFI_GUID which identifies the algorithm to use.
 139   @param[out] HashSize              Holds the returned size of the algorithm's hash.
 140
 141   @retval EFI_SUCCESS           Hash size returned successfully.
 142   @retval EFI_INVALID_PARAMETER This or HashSize is NULL.
 143   @retval EFI_UNSUPPORTED       The algorithm specified by HashAlgorithm is not supported by this driver
 144                                 or HashAlgorithm is null.
 145
 146 **/
 147 EFI_STATUS
 148 EFIAPI
 149 BaseCrypto2GetHashSize (
 150   IN  CONST EFI_HASH2_PROTOCOL     *This,
 151   IN  CONST EFI_GUID               *HashAlgorithm,
 152   OUT UINTN                        *HashSize
 153   );
 154
 155 /**
 156   Creates a hash for the specified message text. The hash is not extendable.
 157   The output is final with any algorithm-required padding added by the function.
 158
 159   @param[in]  This          Points to this instance of EFI_HASH2_PROTOCOL.
 160   @param[in]  HashAlgorithm Points to the EFI_GUID which identifies the algorithm to use.
 161   @param[in]  Message       Points to the start of the message.
 162   @param[in]  MessageSize   The size of Message, in bytes.
 163   @param[in,out]  Hash      On input, points to a caller-allocated buffer of the size
 164                               returned by GetHashSize() for the specified HashAlgorithm.
 165                             On output, the buffer holds the resulting hash computed from the message.
 166
 167   @retval EFI_SUCCESS           Hash returned successfully.
 168   @retval EFI_INVALID_PARAMETER This or Hash is NULL.
 169   @retval EFI_UNSUPPORTED       The algorithm specified by HashAlgorithm is not supported by this driver
 170                                 or HashAlgorithm is Null.
 171   @retval EFI_OUT_OF_RESOURCES  Some resource required by the function is not available
 172                                 or MessageSize is greater than platform maximum.
 173
 174 **/
 175 EFI_STATUS
 176 EFIAPI
 177 BaseCrypto2Hash (
 178   IN CONST EFI_HASH2_PROTOCOL      *This,
 179   IN CONST EFI_GUID                *HashAlgorithm,
 180   IN CONST UINT8                   *Message,
 181   IN UINTN                         MessageSize,
 182   IN OUT EFI_HASH2_OUTPUT          *Hash
 183   );
 184
 185 /**
 186   This function must be called to initialize a digest calculation to be subsequently performed using the
 187   EFI_HASH2_PROTOCOL functions HashUpdate() and HashFinal().
 188
 189   @param[in]  This          Points to this instance of EFI_HASH2_PROTOCOL.
 190   @param[in]  HashAlgorithm Points to the EFI_GUID which identifies the algorithm to use.
 191
 192   @retval EFI_SUCCESS           Initialized successfully.
 193   @retval EFI_INVALID_PARAMETER This is NULL.
 194   @retval EFI_UNSUPPORTED       The algorithm specified by HashAlgorithm is not supported by this driver
 195                                 or HashAlgorithm is Null.
 196   @retval EFI_OUT_OF_RESOURCES  Process failed due to lack of required resource.
 197   @retval EFI_ALREADY_STARTED   This function is called when the operation in progress is still in processing Hash(),
 198                                 or HashInit() is already called before and not terminated by HashFinal() yet on the same instance.
 199
 200 **/
 201 EFI_STATUS
 202 EFIAPI
 203 BaseCrypto2HashInit (
 204   IN CONST EFI_HASH2_PROTOCOL      *This,
 205   IN CONST EFI_GUID                *HashAlgorithm
 206   );
 207
 208 /**
 209   Updates the hash of a computation in progress by adding a message text.
 210
 211   @param[in]  This          Points to this instance of EFI_HASH2_PROTOCOL.
 212   @param[in]  Message       Points to the start of the message.
 213   @param[in]  MessageSize   The size of Message, in bytes.
 214
 215   @retval EFI_SUCCESS           Digest in progress updated successfully.
 216   @retval EFI_INVALID_PARAMETER This or Hash is NULL.
 217   @retval EFI_OUT_OF_RESOURCES  Some resource required by the function is not available
 218                                 or MessageSize is greater than platform maximum.
 219   @retval EFI_NOT_READY         This call was not preceded by a valid call to HashInit(),
 220                                 or the operation in progress was terminated by a call to Hash() or HashFinal() on the same instance.
 221
 222 **/
 223 EFI_STATUS
 224 EFIAPI
 225 BaseCrypto2HashUpdate (
 226   IN CONST EFI_HASH2_PROTOCOL      *This,
 227   IN CONST UINT8                   *Message,
 228   IN UINTN                         MessageSize
 229   );
 230
 231 /**
 232   Finalizes a hash operation in progress and returns calculation result.
 233   The output is final with any necessary padding added by the function.
 234   The hash may not be further updated or extended after HashFinal().
 235
 236   @param[in]  This          Points to this instance of EFI_HASH2_PROTOCOL.
 237   @param[in,out]  Hash      On input, points to a caller-allocated buffer of the size
 238                               returned by GetHashSize() for the specified HashAlgorithm specified in preceding HashInit().
 239                             On output, the buffer holds the resulting hash computed from the message.
 240
 241   @retval EFI_SUCCESS           Hash returned successfully.
 242   @retval EFI_INVALID_PARAMETER This or Hash is NULL.
 243   @retval EFI_NOT_READY         This call was not preceded by a valid call to HashInit() and at least one call to HashUpdate(),
 244                                 or the operation in progress was canceled by a call to Hash() on the same instance.
 245
 246 **/
 247 EFI_STATUS
 248 EFIAPI
 249 BaseCrypto2HashFinal (
 250   IN CONST EFI_HASH2_PROTOCOL      *This,
 251   IN OUT EFI_HASH2_OUTPUT          *Hash
 252   );
 253
 254 EFI_HASH2_PROTOCOL mHash2Protocol = {
 255   BaseCrypto2GetHashSize,
 256   BaseCrypto2Hash,
 257   BaseCrypto2HashInit,
 258   BaseCrypto2HashUpdate,
 259   BaseCrypto2HashFinal,
 260 };
 261
 262 /**
 263   Returns hash information.
 264
 265   @param[in]  HashAlgorithm         Points to the EFI_GUID which identifies the algorithm to use.
 266
 267   @return Hash information.
 268 **/
 269 EFI_HASH_INFO *
 270 GetHashInfo (
 271   IN CONST EFI_GUID              *HashAlgorithm
 272   )
 273 {
 274   UINTN      Index;
 275
 276   for (Index = 0; Index < sizeof(mHashInfo)/sizeof(mHashInfo[0]); Index++) {
 277     if (CompareGuid (HashAlgorithm, mHashInfo[Index].Guid)) {
 278       return &mHashInfo[Index];
 279     }
 280   }
 281   return NULL;
 282 }
 283
 284 /**
 285   Returns the size of the hash which results from a specific algorithm.
 286
 287   @param[in]  This                  Points to this instance of EFI_HASH2_PROTOCOL.
 288   @param[in]  HashAlgorithm         Points to the EFI_GUID which identifies the algorithm to use.
 289   @param[out] HashSize              Holds the returned size of the algorithm's hash.
 290
 291   @retval EFI_SUCCESS           Hash size returned successfully.
 292   @retval EFI_INVALID_PARAMETER This or HashSize is NULL.
 293   @retval EFI_UNSUPPORTED       The algorithm specified by HashAlgorithm is not supported by this driver
 294                                 or HashAlgorithm is null.
 295
 296 **/
 297 EFI_STATUS
 298 EFIAPI
 299 BaseCrypto2GetHashSize (
 300   IN  CONST EFI_HASH2_PROTOCOL     *This,
 301   IN  CONST EFI_GUID              *HashAlgorithm,
 302   OUT UINTN                       *HashSize
 303   )
 304 {
 305   EFI_HASH_INFO *HashInfo;
 306
 307   if ((This == NULL) || (HashSize == NULL)) {
 308     return EFI_INVALID_PARAMETER;
 309   }
 310
 311   if (HashAlgorithm == NULL) {
 312     return EFI_UNSUPPORTED;
 313   }
 314
 315   HashInfo = GetHashInfo (HashAlgorithm);
 316   if (HashInfo == NULL) {
 317     return EFI_UNSUPPORTED;
 318   }
 319
 320   *HashSize = HashInfo->HashSize;
 321   return EFI_SUCCESS;
 322 }
 323
 324 /**
 325   Creates a hash for the specified message text. The hash is not extendable.
 326   The output is final with any algorithm-required padding added by the function.
 327
 328   @param[in]  This          Points to this instance of EFI_HASH2_PROTOCOL.
 329   @param[in]  HashAlgorithm Points to the EFI_GUID which identifies the algorithm to use.
 330   @param[in]  Message       Points to the start of the message.
 331   @param[in]  MessageSize   The size of Message, in bytes.
 332   @param[in,out]  Hash      On input, points to a caller-allocated buffer of the size
 333                               returned by GetHashSize() for the specified HashAlgorithm.
 334                             On output, the buffer holds the resulting hash computed from the message.
 335
 336   @retval EFI_SUCCESS           Hash returned successfully.
 337   @retval EFI_INVALID_PARAMETER This or Hash is NULL.
 338   @retval EFI_UNSUPPORTED       The algorithm specified by HashAlgorithm is not supported by this driver
 339                                 or HashAlgorithm is Null.
 340   @retval EFI_OUT_OF_RESOURCES  Some resource required by the function is not available
 341                                 or MessageSize is greater than platform maximum.
 342
 343 **/
 344 EFI_STATUS
 345 EFIAPI
 346 BaseCrypto2Hash (
 347   IN CONST EFI_HASH2_PROTOCOL      *This,
 348   IN CONST EFI_GUID                *HashAlgorithm,
 349   IN CONST UINT8                   *Message,
 350   IN UINTN                         MessageSize,
 351   IN OUT EFI_HASH2_OUTPUT          *Hash
 352   )
 353 {
 354   EFI_HASH_INFO            *HashInfo;
 355   VOID                     *HashCtx;
 356   UINTN                    CtxSize;
 357   BOOLEAN                  Ret;
 358   EFI_STATUS               Status;
 359
 360   Status = EFI_SUCCESS;
 361
 362   if ((This == NULL) || (Hash == NULL)) {
 363     return EFI_INVALID_PARAMETER;
 364   }
 365
 366   if (HashAlgorithm == NULL) {
 367     return EFI_UNSUPPORTED;
 368   }
 369
 370   HashInfo = GetHashInfo (HashAlgorithm);
 371   if (HashInfo == NULL) {
 372     return EFI_UNSUPPORTED;
 373   }
 374
 375   //
 376   // Start hash sequence
 377   //
 378   CtxSize = HashInfo->GetContextSize ();
 379   if (CtxSize == 0) {
 380     return EFI_UNSUPPORTED;
 381   }
 382   HashCtx = AllocatePool (CtxSize);
 383   if (HashCtx == NULL) {
 384     return EFI_OUT_OF_RESOURCES;
 385   }
 386
 387   Ret = HashInfo->Init (HashCtx);
 388   if (!Ret) {
 389     Status = EFI_OUT_OF_RESOURCES;
 390     goto Done;
 391   }
 392
 393   Ret = HashInfo->Update (HashCtx, Message, MessageSize);
 394   if (!Ret) {
 395     Status = EFI_OUT_OF_RESOURCES;
 396     goto Done;
 397   }
 398
 399   Ret = HashInfo->Final (HashCtx, (UINT8 *)Hash->Sha1Hash);
 400   if (!Ret) {
 401     Status = EFI_OUT_OF_RESOURCES;
 402     goto Done;
 403   }
 404 Done:
 405   FreePool (HashCtx);
 406   return Status;
 407 }
 408
 409 /**
 410   This function must be called to initialize a digest calculation to be subsequently performed using the
 411   EFI_HASH2_PROTOCOL functions HashUpdate() and HashFinal().
 412
 413   @param[in]  This          Points to this instance of EFI_HASH2_PROTOCOL.
 414   @param[in]  HashAlgorithm Points to the EFI_GUID which identifies the algorithm to use.
 415
 416   @retval EFI_SUCCESS           Initialized successfully.
 417   @retval EFI_INVALID_PARAMETER This is NULL.
 418   @retval EFI_UNSUPPORTED       The algorithm specified by HashAlgorithm is not supported by this driver
 419                                 or HashAlgorithm is Null.
 420   @retval EFI_OUT_OF_RESOURCES  Process failed due to lack of required resource.
 421   @retval EFI_ALREADY_STARTED   This function is called when the operation in progress is still in processing Hash(),
 422                                 or HashInit() is already called before and not terminated by HashFinal() yet on the same instance.
 423
 424 **/
 425 EFI_STATUS
 426 EFIAPI
 427 BaseCrypto2HashInit (
 428   IN CONST EFI_HASH2_PROTOCOL      *This,
 429   IN CONST EFI_GUID                *HashAlgorithm
 430   )
 431 {
 432   EFI_HASH_INFO            *HashInfo;
 433   VOID                     *HashCtx;
 434   UINTN                    CtxSize;
 435   BOOLEAN                  Ret;
 436   HASH2_INSTANCE_DATA      *Instance;
 437
 438   if (This == NULL) {
 439     return EFI_INVALID_PARAMETER;
 440   }
 441
 442   if (HashAlgorithm == NULL) {
 443     return EFI_UNSUPPORTED;
 444   }
 445
 446   HashInfo = GetHashInfo (HashAlgorithm);
 447   if (HashInfo == NULL) {
 448     return EFI_UNSUPPORTED;
 449   }
 450
 451   //
 452   // Consistency Check
 453   //
 454   Instance = HASH2_INSTANCE_DATA_FROM_THIS(This);
 455   if ((Instance->HashContext != NULL) || (Instance->HashInfoContext != HashInfo)) {
 456     return EFI_ALREADY_STARTED;
 457   }
 458
 459   //
 460   // Start hash sequence
 461   //
 462   CtxSize = HashInfo->GetContextSize ();
 463   if (CtxSize == 0) {
 464     return EFI_UNSUPPORTED;
 465   }
 466   HashCtx = AllocatePool (CtxSize);
 467   if (HashCtx == NULL) {
 468     return EFI_OUT_OF_RESOURCES;
 469   }
 470
 471   Ret = HashInfo->Init (HashCtx);
 472   if (!Ret) {
 473     FreePool (HashCtx);
 474     return EFI_OUT_OF_RESOURCES;
 475   }
 476
 477   //
 478   // Setup the context
 479   //
 480   Instance->HashContext = HashCtx;
 481   Instance->HashInfoContext = HashInfo;
 482
 483   return EFI_SUCCESS;
 484 }
 485
 486 /**
 487   Updates the hash of a computation in progress by adding a message text.
 488
 489   @param[in]  This          Points to this instance of EFI_HASH2_PROTOCOL.
 490   @param[in]  Message       Points to the start of the message.
 491   @param[in]  MessageSize   The size of Message, in bytes.
 492
 493   @retval EFI_SUCCESS           Digest in progress updated successfully.
 494   @retval EFI_INVALID_PARAMETER This or Hash is NULL.
 495   @retval EFI_OUT_OF_RESOURCES  Some resource required by the function is not available
 496                                 or MessageSize is greater than platform maximum.
 497   @retval EFI_NOT_READY         This call was not preceded by a valid call to HashInit(),
 498                                 or the operation in progress was terminated by a call to Hash() or HashFinal() on the same instance.
 499
 500 **/
 501 EFI_STATUS
 502 EFIAPI
 503 BaseCrypto2HashUpdate (
 504   IN CONST EFI_HASH2_PROTOCOL      *This,
 505   IN CONST UINT8                   *Message,
 506   IN UINTN                         MessageSize
 507   )
 508 {
 509   EFI_HASH_INFO            *HashInfo;
 510   VOID                     *HashCtx;
 511   BOOLEAN                  Ret;
 512   HASH2_INSTANCE_DATA      *Instance;
 513
 514   if (This == NULL) {
 515     return EFI_INVALID_PARAMETER;
 516   }
 517
 518   //
 519   // Consistency Check
 520   //
 521   Instance = HASH2_INSTANCE_DATA_FROM_THIS(This);
 522   if ((Instance->HashContext == NULL) || (Instance->HashInfoContext == NULL)) {
 523     return EFI_NOT_READY;
 524   }
 525   HashInfo = Instance->HashInfoContext;
 526   HashCtx  = Instance->HashContext;
 527
 528   Ret = HashInfo->Update (HashCtx, Message, MessageSize);
 529   if (!Ret) {
 530     return EFI_OUT_OF_RESOURCES;
 531   }
 532
 533   return EFI_SUCCESS;
 534 }
 535
 536 /**
 537   Finalizes a hash operation in progress and returns calculation result.
 538   The output is final with any necessary padding added by the function.
 539   The hash may not be further updated or extended after HashFinal().
 540
 541   @param[in]  This          Points to this instance of EFI_HASH2_PROTOCOL.
 542   @param[in,out]  Hash      On input, points to a caller-allocated buffer of the size
 543                               returned by GetHashSize() for the specified HashAlgorithm specified in preceding HashInit().
 544                             On output, the buffer holds the resulting hash computed from the message.
 545
 546   @retval EFI_SUCCESS           Hash returned successfully.
 547   @retval EFI_INVALID_PARAMETER This or Hash is NULL.
 548   @retval EFI_NOT_READY         This call was not preceded by a valid call to HashInit() and at least one call to HashUpdate(),
 549                                 or the operation in progress was canceled by a call to Hash() on the same instance.
 550
 551 **/
 552 EFI_STATUS
 553 EFIAPI
 554 BaseCrypto2HashFinal (
 555   IN CONST EFI_HASH2_PROTOCOL      *This,
 556   IN OUT EFI_HASH2_OUTPUT          *Hash
 557   )
 558 {
 559   EFI_HASH_INFO            *HashInfo;
 560   VOID                     *HashCtx;
 561   BOOLEAN                  Ret;
 562   HASH2_INSTANCE_DATA      *Instance;
 563
 564   if ((This == NULL) || (Hash == NULL)) {
 565     return EFI_INVALID_PARAMETER;
 566   }
 567
 568   //
 569   // Consistency Check
 570   //
 571   Instance = HASH2_INSTANCE_DATA_FROM_THIS(This);
 572   if ((Instance->HashContext == NULL) || (Instance->HashInfoContext == NULL)) {
 573     return EFI_NOT_READY;
 574   }
 575   HashInfo = Instance->HashInfoContext;
 576   HashCtx  = Instance->HashContext;
 577
 578   Ret = HashInfo->Final (HashCtx, (UINT8 *)Hash->Sha1Hash);
 579
 580   //
 581   // Cleanup the context
 582   //
 583   FreePool (HashCtx);
 584   Instance->HashInfoContext = NULL;
 585   Instance->HashContext = NULL;
 586
 587   if (!Ret) {
 588     return EFI_OUT_OF_RESOURCES;
 589   }
 590
 591   return EFI_SUCCESS;
 592 }