Re: [PATCH v1] CryptoPkg: Add new hash algorithm ParallelHash256HashAll in BaseCryptLib.

["Yao, Jiewen" <jiewen.yao@intel.com>]

Thanks for the update.

Feedback below:

1) How block size is determined for below API?

BOOLEAN
EFIAPI
ParallelHash256HashAll (
  IN CONST VOID            *Input,
  IN       UINTN           InputByteLen,
  OUT      VOID            *Output,
  IN       UINTN           OutputByteLen,
  IN CONST VOID            *Customization,
  IN       UINTN           CustomByteLen
  );

Is that determined by PcdParallelHashBlockNumber ?

I don’t think it is good idea to let a crypto library determine a platform PCD.
For example, how do you support binary crypto module ?

2) Why we need "sha3.h" and "xkcp.h" ?
These are openssl specific structure. It shall not be put to EDKII file header.

CryptoPkg\Library\Include shall only contain generic dependency header.




Thank you
Yao, Jiewen

> -----Original Message-----
> From: Li, Zhihao <zhihao.li@intel.com>
> Sent: Friday, February 11, 2022 5:05 PM
> To: devel@edk2.groups.io
> Cc: Yao, Jiewen <jiewen.yao@intel.com>; Wang, Jian J <jian.j.wang@intel.com>;
> Lu, Xiaoyu1 <xiaoyu1.lu@intel.com>; Jiang, Guomin <guomin.jiang@intel.com>;
> Fu, Siyuan <siyuan.fu@intel.com>
> Subject: [PATCH v1] CryptoPkg: Add new hash algorithm ParallelHash256HashAll
> in BaseCryptLib.
> 
> REF: https://bugzilla.tianocore.org/show_bug.cgi?id=3596
> 
> Parallel hash function ParallelHash256HashAll, as defined in NIST's
> Special Publication 800-185, published December 2016. It utilizes
> multi-process to calculate the digest.
> 
> Cc: Jiewen Yao <jiewen.yao@intel.com>
> Cc: Jian J Wang <jian.j.wang@intel.com>
> Cc: Xiaoyu Lu <xiaoyu1.lu@intel.com>
> Cc: Guomin Jiang <guomin.jiang@intel.com>
> Cc: Siyuan Fu <siyuan.fu@intel.com>
> 
> Signed-off-by: Zhihao Li <zhihao.li@intel.com>
> ---
>  CryptoPkg/Library/BaseCryptLib/Hash/CryptCShake256.c                   | 313
> ++++++++++++++++++++
>  CryptoPkg/Library/BaseCryptLib/Hash/CryptParallelHash.c                | 275
> +++++++++++++++++
>  CryptoPkg/Library/BaseCryptLib/Hash/CryptSha3.c                        | 102 +++++++
>  CryptoPkg/Library/BaseCryptLib/Hash/CryptXkcp.c                        |  53 ++++
>  CryptoPkg/Test/UnitTest/Library/BaseCryptLib/ParallelhashTests.c       | 152
> ++++++++++
>  CryptoPkg/CryptoPkg.dec                                                |   9 +-
>  CryptoPkg/Include/Library/BaseCryptLib.h                               |  29 +-
>  CryptoPkg/Library/BaseCryptLib/SmmCryptLib.inf                         |  12 +-
>  CryptoPkg/Library/Include/CrtLibSupport.h                              |   5 +-
>  CryptoPkg/Library/Include/sha3.h                                       |  32 ++
>  CryptoPkg/Library/Include/xkcp.h                                       |  23 ++
>  CryptoPkg/Test/UnitTest/Library/BaseCryptLib/TestBaseCryptLib.h        |   3 +-
>  CryptoPkg/Test/UnitTest/Library/BaseCryptLib/TestBaseCryptLibHost.inf  |   7 +
>  CryptoPkg/Test/UnitTest/Library/BaseCryptLib/TestBaseCryptLibShell.inf |   6 +
>  14 files changed, 1016 insertions(+), 5 deletions(-)
> 
> diff --git a/CryptoPkg/Library/BaseCryptLib/Hash/CryptCShake256.c
> b/CryptoPkg/Library/BaseCryptLib/Hash/CryptCShake256.c
> new file mode 100644
> index 0000000000..5efced3f46
> --- /dev/null
> +++ b/CryptoPkg/Library/BaseCryptLib/Hash/CryptCShake256.c
> @@ -0,0 +1,313 @@
> +/** @file
> 
> +  cSHAKE-256 Digest Wrapper Implementations.
> 
> +
> 
> +Copyright (c) 2022, Intel Corporation. All rights reserved.<BR>
> 
> +SPDX-License-Identifier: BSD-2-Clause-Patent
> 
> +
> 
> +**/
> 
> +
> 
> +#include "InternalCryptLib.h"
> 
> +#include "sha3.h"
> 
> +#include "xkcp.h"
> 
> +
> 
> +#define  CSHAKE256_SECURITY_STRENGTH    256
> 
> +#define  CSHAKE256_RATE_IN_BYTES        136
> 
> +
> 
> +const CHAR8 mZeroPadding[CSHAKE256_RATE_IN_BYTES] = {0};
> 
> +
> 
> +UINTN
> 
> +EFIAPI
> 
> +LeftEncode (
> 
> +  OUT UINT8     *Encbuf,
> 
> +  IN  UINTN     Value
> 
> +  )
> 
> +{
> 
> +  return left_encode (Encbuf, Value);
> 
> +}
> 
> +
> 
> +UINTN
> 
> +EFIAPI
> 
> +RightEncode (
> 
> +  OUT UINT8     *Encbuf,
> 
> +  IN  UINTN     Value
> 
> +  )
> 
> +{
> 
> +  return right_encode (Encbuf, Value);
> 
> +}
> 
> +
> 
> +/**
> 
> +  Retrieves the size, in bytes, of the context buffer required for cSHAKE-256
> hash operations.
> 
> +
> 
> +  @return  The size, in bytes, of the context buffer required for cSHAKE-256
> hash operations.
> 
> +
> 
> +**/
> 
> +UINTN
> 
> +EFIAPI
> 
> +CShake256GetContextSize (
> 
> +  VOID
> 
> +  )
> 
> +{
> 
> +  return (UINTN) (sizeof (KECCAK1600_CTX));
> 
> +}
> 
> +
> 
> +/**
> 
> +  Initializes user-supplied memory pointed by CShake256Context as cSHAKE-256
> hash context for
> 
> +  subsequent use.
> 
> +
> 
> +  @param[out] CShake256Context   Pointer to cSHAKE-256 context being
> initialized.
> 
> +  @param[in]  OutputLen          The desired number of output length in bytes.
> 
> +  @param[in]  Name               Pointer to the function name string.
> 
> +  @param[in]  NameLen            The length of the function name in bytes.
> 
> +  @param[in]  Customization      Pointer to the customization string.
> 
> +  @param[in]  CustomizationLen   The length of the customization string in
> bytes.
> 
> +
> 
> +  @retval TRUE   cSHAKE-256 context initialization succeeded.
> 
> +  @retval FALSE  cSHAKE-256 context initialization failed.
> 
> +  @retval FALSE  This interface is not supported.
> 
> +
> 
> +**/
> 
> +BOOLEAN
> 
> +EFIAPI
> 
> +CShake256Init (
> 
> +  OUT   VOID          *CShake256Context,
> 
> +  IN    UINTN         OutputLen,
> 
> +  IN    CONST VOID    *Name,
> 
> +  IN    UINTN         NameLen,
> 
> +  IN    CONST VOID    *Customization,
> 
> +  IN    UINTN         CustomizationLen
> 
> +  )
> 
> +{
> 
> +  BOOLEAN   Status;
> 
> +  unsigned char EncBuf[sizeof(size_t)+1];
> 
> +  UINTN     EncLen;
> 
> +  UINTN     AbsorbLen;
> 
> +  UINTN     PadLen;
> 
> +
> 
> +  //
> 
> +  // Check input parameters.
> 
> +  //
> 
> +  if (CShake256Context == NULL ||
> 
> +      OutputLen == 0 ||
> 
> +      (NameLen != 0 && Name == NULL) ||
> 
> +      (CustomizationLen != 0 && Customization == NULL)) {
> 
> +    return FALSE;
> 
> +  }
> 
> +
> 
> +  //
> 
> +  // Initialize KECCAK context with pad value and block size.
> 
> +  //
> 
> +  if (NameLen == 0 && CustomizationLen == 0) {
> 
> +    //
> 
> +    // When N and S are both empty strings, cSHAKE(X, L, N, S) is equivalent to
> 
> +    // SHAKE as defined in FIPS 202.
> 
> +    //
> 
> +    return (BOOLEAN) init (
> 
> +                      (KECCAK1600_CTX *) CShake256Context,
> 
> +                      '\x1f',
> 
> +                      (KECCAK1600_WIDTH - CSHAKE256_SECURITY_STRENGTH * 2) / 8,
> 
> +                      OutputLen
> 
> +                      );
> 
> +  }
> 
> +
> 
> +  Status = (BOOLEAN) init (
> 
> +                      (KECCAK1600_CTX *) CShake256Context,
> 
> +                      '\x04',
> 
> +                      (KECCAK1600_WIDTH - CSHAKE256_SECURITY_STRENGTH * 2) / 8,
> 
> +                      OutputLen
> 
> +                      );
> 
> +  if (!Status) {
> 
> +    return FALSE;
> 
> +  }
> 
> +
> 
> +  AbsorbLen = 0;
> 
> +  //
> 
> +  // Absorb Absorb bytepad(.., rate).
> 
> +  //
> 
> +  EncLen = left_encode (EncBuf, CSHAKE256_RATE_IN_BYTES);
> 
> +  Status = (BOOLEAN) sha3_update ((KECCAK1600_CTX *) CShake256Context,
> EncBuf, EncLen);
> 
> +  if (!Status) {
> 
> +    return FALSE;
> 
> +  }
> 
> +  AbsorbLen += EncLen;
> 
> +
> 
> +  //
> 
> +  // Absorb encode_string(N).
> 
> +  //
> 
> +  EncLen = left_encode (EncBuf, NameLen * 8);
> 
> +  Status = (BOOLEAN) sha3_update ((KECCAK1600_CTX *) CShake256Context,
> EncBuf, EncLen);
> 
> +  if (!Status) {
> 
> +    return FALSE;
> 
> +  }
> 
> +  AbsorbLen += EncLen;
> 
> +  Status = (BOOLEAN) sha3_update ((KECCAK1600_CTX *) CShake256Context,
> Name, NameLen);
> 
> +  if (!Status) {
> 
> +    return FALSE;
> 
> +  }
> 
> +  AbsorbLen += NameLen;
> 
> +
> 
> +  //
> 
> +  // Absorb encode_string(S).
> 
> +  //
> 
> +  EncLen = left_encode (EncBuf, CustomizationLen * 8);
> 
> +  Status = (BOOLEAN) sha3_update ((KECCAK1600_CTX *) CShake256Context,
> EncBuf, EncLen);
> 
> +  if (!Status) {
> 
> +    return FALSE;
> 
> +  }
> 
> +  AbsorbLen += EncLen;
> 
> +  Status = (BOOLEAN) sha3_update ((KECCAK1600_CTX *) CShake256Context,
> Customization, CustomizationLen);
> 
> +  if (!Status) {
> 
> +    return FALSE;
> 
> +  }
> 
> +  AbsorbLen += CustomizationLen;
> 
> +
> 
> +  //
> 
> +  // Absorb zero padding up to rate.
> 
> +  //
> 
> +  PadLen = CSHAKE256_RATE_IN_BYTES - AbsorbLen %
> CSHAKE256_RATE_IN_BYTES;
> 
> +  Status = (BOOLEAN) sha3_update ((KECCAK1600_CTX *) CShake256Context,
> mZeroPadding, PadLen);
> 
> +  if (!Status) {
> 
> +    return FALSE;
> 
> +  }
> 
> +
> 
> +  return TRUE;
> 
> +}
> 
> +
> 
> +/**
> 
> +  Digests the input data and updates cSHAKE-256 context.
> 
> +
> 
> +  This function performs cSHAKE-256 digest on a data buffer of the specified
> size.
> 
> +  It can be called multiple times to compute the digest of long or discontinuous
> data streams.
> 
> +  cSHAKE-256 context should be already correctly initialized by CShake256Init(),
> and should not be finalized
> 
> +  by CShake256Final(). Behavior with invalid context is undefined.
> 
> +
> 
> +  @param[in, out]  CShake256Context   Pointer to the cSHAKE-256 context.
> 
> +  @param[in]       Data               Pointer to the buffer containing the data to be
> hashed.
> 
> +  @param[in]       DataSize           Size of Data buffer in bytes.
> 
> +
> 
> +  @retval TRUE   cSHAKE-256 data digest succeeded.
> 
> +  @retval FALSE  cSHAKE-256 data digest failed.
> 
> +  @retval FALSE  This interface is not supported.
> 
> +
> 
> +**/
> 
> +BOOLEAN
> 
> +EFIAPI
> 
> +CShake256Update (
> 
> +  IN OUT  VOID        *CShake256Context,
> 
> +  IN      CONST VOID  *Data,
> 
> +  IN      UINTN       DataSize
> 
> +  )
> 
> +{
> 
> +  //
> 
> +  // Check input parameters.
> 
> +  //
> 
> +  if (CShake256Context == NULL) {
> 
> +    return FALSE;
> 
> +  }
> 
> +
> 
> +  //
> 
> +  // Check invalid parameters, in case that only DataLength was checked in
> OpenSSL.
> 
> +  //
> 
> +  if (Data == NULL && DataSize != 0) {
> 
> +    return FALSE;
> 
> +  }
> 
> +
> 
> +  return (BOOLEAN)(sha3_update ((KECCAK1600_CTX *) CShake256Context,
> Data, DataSize));
> 
> +}
> 
> +
> 
> +/**
> 
> +  Completes computation of the cSHAKE-256 digest value.
> 
> +
> 
> +  This function completes cSHAKE-256 hash computation and retrieves the
> digest value into
> 
> +  the specified memory. After this function has been called, the cSHAKE-256
> context cannot
> 
> +  be used again.
> 
> +  cSHAKE-256 context should be already correctly initialized by CShake256Init(),
> and should not be
> 
> +  finalized by CShake256Final(). Behavior with invalid cSHAKE-256 context is
> undefined.
> 
> +
> 
> +  @param[in, out]  CShake256Context  Pointer to the cSHAKE-256 context.
> 
> +  @param[out]      HashValue         Pointer to a buffer that receives the cSHAKE-
> 256 digest
> 
> +                                     value.
> 
> +
> 
> +  @retval TRUE   cSHAKE-256 digest computation succeeded.
> 
> +  @retval FALSE  cSHAKE-256 digest computation failed.
> 
> +  @retval FALSE  This interface is not supported.
> 
> +
> 
> +**/
> 
> +BOOLEAN
> 
> +EFIAPI
> 
> +CShake256Final (
> 
> +  IN OUT  VOID   *CShake256Context,
> 
> +  OUT     UINT8  *HashValue
> 
> +  )
> 
> +{
> 
> +  //
> 
> +  // Check input parameters.
> 
> +  //
> 
> +  if (CShake256Context == NULL || HashValue == NULL) {
> 
> +    return FALSE;
> 
> +  }
> 
> +
> 
> +  //
> 
> +  // cSHAKE-256 Hash Finalization.
> 
> +  //
> 
> +  return (BOOLEAN) (sha3_final ((KECCAK1600_CTX *) CShake256Context,
> HashValue));
> 
> +}
> 
> +
> 
> +/**
> 
> +  Computes the CSHAKE-256 message digest of a input data buffer.
> 
> +
> 
> +  This function performs the CSHAKE-256 message digest of a given data buffer,
> and places
> 
> +  the digest value into the specified memory.
> 
> +
> 
> +  @param[in]   Data               Pointer to the buffer containing the data to be
> hashed.
> 
> +  @param[in]   DataSize           Size of Data buffer in bytes.
> 
> +  @param[in]   OutputLen          Size of output in bytes.
> 
> +  @param[in]   Name               Pointer to the function name string.
> 
> +  @param[in]   NameLen            Size of the function name in bytes.
> 
> +  @param[in]   Customization      Pointer to the customization string.
> 
> +  @param[in]   CustomizationLen   Size of the customization string in bytes.
> 
> +  @param[out]  HashValue          Pointer to a buffer that receives the CSHAKE-
> 256 digest
> 
> +                                  value.
> 
> +
> 
> +  @retval TRUE   CSHAKE-256 digest computation succeeded.
> 
> +  @retval FALSE  CSHAKE-256 digest computation failed.
> 
> +  @retval FALSE  This interface is not supported.
> 
> +
> 
> +**/
> 
> +BOOLEAN
> 
> +EFIAPI
> 
> +CShake256HashAll (
> 
> +  IN   CONST VOID     *Data,
> 
> +  IN   UINTN          DataSize,
> 
> +  IN   UINTN          OutputLen,
> 
> +  IN   CONST VOID     *Name,
> 
> +  IN   UINTN          NameLen,
> 
> +  IN   CONST VOID     *Customization,
> 
> +  IN   UINTN          CustomizationLen,
> 
> +  OUT  UINT8          *HashValue
> 
> +  )
> 
> +{
> 
> +  BOOLEAN          Status;
> 
> +  KECCAK1600_CTX   Ctx;
> 
> +
> 
> +  //
> 
> +  // Check input parameters.
> 
> +  //
> 
> +  if (HashValue == NULL) {
> 
> +    return FALSE;
> 
> +  }
> 
> +  if (Data == NULL && DataSize != 0) {
> 
> +    return FALSE;
> 
> +  }
> 
> +
> 
> +  Status = CShake256Init (&Ctx, OutputLen, Name, NameLen, Customization,
> CustomizationLen);
> 
> +  if (!Status) {
> 
> +    return FALSE;
> 
> +  }
> 
> +
> 
> +  Status = CShake256Update (&Ctx, Data, DataSize);
> 
> +  if (!Status) {
> 
> +    return FALSE;
> 
> +  }
> 
> +
> 
> +  return CShake256Final (&Ctx, HashValue);
> 
> +}
> 
> diff --git a/CryptoPkg/Library/BaseCryptLib/Hash/CryptParallelHash.c
> b/CryptoPkg/Library/BaseCryptLib/Hash/CryptParallelHash.c
> new file mode 100644
> index 0000000000..3eaa7c2ceb
> --- /dev/null
> +++ b/CryptoPkg/Library/BaseCryptLib/Hash/CryptParallelHash.c
> @@ -0,0 +1,275 @@
> +/** @file
> 
> +  ParallelHash Implementation.
> 
> +
> 
> +Copyright (c) 2022, Intel Corporation. All rights reserved.<BR>
> 
> +SPDX-License-Identifier: BSD-2-Clause-Patent
> 
> +
> 
> +**/
> 
> +
> 
> +#include "InternalCryptLib.h"
> 
> +#include <Library\PcdLib.h>
> 
> +#include <Library\SynchronizationLib.h>
> 
> +#include <Library\MmServicesTableLib.h>
> 
> +
> 
> +
> 
> +UINT16        mBlockNum;
> 
> +UINTN        mBlockSize;
> 
> +UINTN        mLastBlockSize;
> 
> +UINT8        *mInput;
> 
> +UINTN        mBlockResultSize;
> 
> +UINT8        *mBlockHashResult;
> 
> +BOOLEAN      *mBlockIsCompleted;
> 
> +SPIN_LOCK    *mSpinLockList;
> 
> +
> 
> +UINTN LeftEncode (OUT UINT8 *Encbuf, IN UINTN Value);
> 
> +UINTN RightEncode (OUT UINT8 *Encbuf, IN UINTN Value);
> 
> +
> 
> +BOOLEAN
> 
> +EFIAPI
> 
> +CShake256HashAll (
> 
> +  IN   CONST VOID     *Data,
> 
> +  IN   UINTN          DataSize,
> 
> +  IN   UINTN          OutputLen,
> 
> +  IN   CONST VOID     *Name,
> 
> +  IN   UINTN          NameLen,
> 
> +  IN   CONST VOID     *Customization,
> 
> +  IN   UINTN          CustomizationLen,
> 
> +  OUT  UINT8          *HashValue
> 
> +  );
> 
> +
> 
> +VOID
> 
> +EFIAPI
> 
> +ParallelHashApExecute (
> 
> +  IN VOID          *ProcedureArgument
> 
> +  )
> 
> +{
> 
> +  UINTN         Index;
> 
> +  BOOLEAN       Status;
> 
> +
> 
> +  for (Index = 0; Index < mBlockNum; Index++) {
> 
> +    if (AcquireSpinLockOrFail (&mSpinLockList[Index])) {
> 
> +      //
> 
> +      // Completed, try next one.
> 
> +      //
> 
> +      if (mBlockIsCompleted[Index])
> 
> +      {
> 
> +        ReleaseSpinLock (&mSpinLockList[Index]);
> 
> +        continue;
> 
> +      }
> 
> +      //
> 
> +      // Calculate CShake256 for this block.
> 
> +      //
> 
> +      Status = CShake256HashAll (
> 
> +                 mInput + Index * mBlockSize,
> 
> +                 (Index == (mBlockNum - 1)) ? mLastBlockSize : mBlockSize,
> 
> +                 mBlockResultSize,
> 
> +                 NULL,
> 
> +                 0,
> 
> +                 NULL,
> 
> +                 0,
> 
> +                 mBlockHashResult + Index * mBlockResultSize
> 
> +                 );
> 
> +      if (!EFI_ERROR (Status)){
> 
> +        mBlockIsCompleted[Index] = TRUE;
> 
> +      }
> 
> +      ReleaseSpinLock (&mSpinLockList[Index]);
> 
> +    }
> 
> +  }
> 
> +}
> 
> +
> 
> +/**
> 
> +  Parallel hash function ParallelHash256, as defined in NIST's Special Publication
> 800-185,
> 
> +  published December 2016.
> 
> +
> 
> +  @param  Input[in]            Pointer to the input message (X).
> 
> +  @param  InputByteLen[in]     The number(>0) of input bytes provided for the
> input data.
> 
> +  @param  Output[out]          Pointer to the output buffer.
> 
> +  @param  OutputByteLen[in]    The desired number of output bytes (L).
> 
> +  @param  Customization[in]    Pointer to the customization string (S).
> 
> +  @param  CustomByteLen[in]    The length of the customization string in bytes.
> 
> +
> 
> +  @retval TRUE   ParallelHash256 digest computation succeeded.
> 
> +  @retval FALSE  ParallelHash256 digest computation failed.
> 
> +  @retval FALSE  This interface is not supported.
> 
> +
> 
> +*/
> 
> +BOOLEAN
> 
> +EFIAPI
> 
> +ParallelHash256HashAll (
> 
> +  IN CONST VOID            *Input,
> 
> +  IN       UINTN           InputByteLen,
> 
> +  OUT      VOID            *Output,
> 
> +  IN       UINTN           OutputByteLen,
> 
> +  IN CONST VOID            *Customization,
> 
> +  IN       UINTN           CustomByteLen
> 
> +  )
> 
> +
> 
> +{
> 
> +  UINT8        EncBufB[sizeof(UINTN)+1];
> 
> +  UINTN        EncSizeB;
> 
> +  UINT8        EncBufN[sizeof(UINTN)+1];
> 
> +  UINTN        EncSizeN;
> 
> +  UINT8        EncBufL[sizeof(UINTN)+1];
> 
> +  UINTN        EncSizeL;
> 
> +  UINTN        Index;
> 
> +  UINT8        *CombinedInput;
> 
> +  UINTN        CombinedInputSize;
> 
> +  EFI_STATUS   Status;
> 
> +  UINTN        StartedApNum;
> 
> +  BOOLEAN      AllCompleted;
> 
> +  UINTN        Offset;
> 
> +  BOOLEAN      ReturnValue;
> 
> +
> 
> +  if (InputByteLen == 0 || OutputByteLen == 0) {
> 
> +    return FALSE;
> 
> +  }
> 
> +
> 
> +  if (Input == NULL || Output == NULL){
> 
> +    return FALSE;
> 
> +  }
> 
> +
> 
> +  if (CustomByteLen != 0 && Customization == NULL){
> 
> +    return FALSE;
> 
> +  }
> 
> +
> 
> +  //
> 
> +  // Get Block number n.
> 
> +  //
> 
> +  mBlockNum = PcdGet16 (PcdParallelHashBlockNumber);
> 
> +
> 
> +  if (mBlockNum < 1 || InputByteLen < mBlockNum - 1){
> 
> +    return FALSE;
> 
> +  }
> 
> +
> 
> +  //
> 
> +  // Set hash result size of each block in bytes.
> 
> +  //
> 
> +  mBlockResultSize = OutputByteLen;
> 
> +
> 
> +  //
> 
> +  // calculate the block byte length B.
> 
> +  //
> 
> +  mBlockSize = InputByteLen % mBlockNum == 0 ? InputByteLen / mBlockNum :
> InputByteLen / (mBlockNum - 1);
> 
> +
> 
> +  //
> 
> +  // Encode B, n, L to string and record size.
> 
> +  //
> 
> +  EncSizeB = LeftEncode  (EncBufB, mBlockSize);
> 
> +  EncSizeN = RightEncode (EncBufN, mBlockNum);
> 
> +  EncSizeL = RightEncode (EncBufL, OutputByteLen * CHAR_BIT);
> 
> +
> 
> +  //
> 
> +  // Allocate buffer for combined input (newX), Block completed flag and
> SpinLock.
> 
> +  //
> 
> +  CombinedInputSize = EncSizeB + EncSizeN + EncSizeL + mBlockNum *
> mBlockResultSize;
> 
> +  CombinedInput = AllocateZeroPool (CombinedInputSize);
> 
> +  mBlockIsCompleted = AllocateZeroPool (mBlockNum * sizeof (BOOLEAN));
> 
> +  mSpinLockList = AllocatePool (mBlockNum * sizeof (SPIN_LOCK));
> 
> +  if (CombinedInput == NULL || mBlockIsCompleted == NULL || mSpinLockList
> == NULL) {
> 
> +    ReturnValue = FALSE;
> 
> +    goto Exit;
> 
> +  }
> 
> +
> 
> +  //
> 
> +  // Fill LeftEncode(B).
> 
> +  //
> 
> +  CopyMem (CombinedInput, EncBufB, EncSizeB);
> 
> +
> 
> +  //
> 
> +  // Prepare for parallel hash.
> 
> +  //
> 
> +  mBlockHashResult = CombinedInput + EncSizeB;
> 
> +  mInput = Input;
> 
> +  mLastBlockSize = InputByteLen % mBlockSize == 0 ? mBlockSize :
> InputByteLen % mBlockSize;
> 
> +
> 
> +  //
> 
> +  // Initialize SpinLock for each result block.
> 
> +  //
> 
> +  for (Index = 0; Index < mBlockNum; Index++) {
> 
> +    InitializeSpinLock (&mSpinLockList[Index]);
> 
> +  }
> 
> +
> 
> +  //
> 
> +  // Dispatch blocklist to each AP.
> 
> +  //
> 
> +  StartedApNum = 0;
> 
> +  for (Index = 0; Index < gMmst->NumberOfCpus; Index++) {
> 
> +    if (Index != gMmst->CurrentlyExecutingCpu) {
> 
> +      Status = gMmst->MmStartupThisAp (ParallelHashApExecute, Index, NULL);
> 
> +      if (!EFI_ERROR (Status)) {
> 
> +        StartedApNum++;
> 
> +      }
> 
> +    }
> 
> +  }
> 
> +
> 
> +  //
> 
> +  // Wait until all block hash completed.
> 
> +  //
> 
> +  do {
> 
> +    AllCompleted = TRUE;
> 
> +    for (Index = 0; Index < mBlockNum; Index++) {
> 
> +      if (AcquireSpinLockOrFail (&mSpinLockList[Index])) {
> 
> +        if (!mBlockIsCompleted[Index]) {
> 
> +          AllCompleted = FALSE;
> 
> +          ReturnValue = CShake256HashAll (
> 
> +                     mInput + Index * mBlockSize,
> 
> +                     (Index == (mBlockNum - 1)) ? mLastBlockSize : mBlockSize,
> 
> +                     mBlockResultSize,
> 
> +                     NULL,
> 
> +                     0,
> 
> +                     NULL,
> 
> +                     0,
> 
> +                     mBlockHashResult + Index * mBlockResultSize
> 
> +                     );
> 
> +          if (ReturnValue){
> 
> +            mBlockIsCompleted[Index] = TRUE;
> 
> +          }
> 
> +          ReleaseSpinLock (&mSpinLockList[Index]);
> 
> +          break;
> 
> +        }
> 
> +        ReleaseSpinLock (&mSpinLockList[Index]);
> 
> +      } else {
> 
> +        AllCompleted = FALSE;
> 
> +        break;
> 
> +      }
> 
> +    }
> 
> +  } while (!AllCompleted);
> 
> +
> 
> +  //
> 
> +  // Fill LeftEncode(n).
> 
> +  //
> 
> +  Offset = EncSizeB + mBlockNum * mBlockResultSize;
> 
> +  CopyMem (CombinedInput + Offset, EncBufN, EncSizeN);
> 
> +
> 
> +  //
> 
> +  // Fill LeftEncode(L).
> 
> +  //
> 
> +  Offset += EncSizeN;
> 
> +  CopyMem (CombinedInput + Offset, EncBufL, EncSizeL);
> 
> +
> 
> +  ReturnValue = CShake256HashAll (
> 
> +                  CombinedInput,
> 
> +                  CombinedInputSize,
> 
> +                  OutputByteLen,
> 
> +                  PARALLELHASH_CUSTOMIZATION,
> 
> +                  AsciiStrLen(PARALLELHASH_CUSTOMIZATION),
> 
> +                  Customization,
> 
> +                  CustomByteLen,
> 
> +                  Output
> 
> +                  );
> 
> +
> 
> +Exit:
> 
> +  ZeroMem (CombinedInput, CombinedInputSize);
> 
> +
> 
> +  if (CombinedInput != NULL){
> 
> +    FreePool (CombinedInput);
> 
> +  }
> 
> +  if (mSpinLockList != NULL){
> 
> +    FreePool (mSpinLockList);
> 
> +  }
> 
> +  if (mBlockIsCompleted != NULL){
> 
> +    FreePool (mBlockIsCompleted);
> 
> +  }
> 
> +
> 
> +  return ReturnValue;
> 
> +}
> 
> diff --git a/CryptoPkg/Library/BaseCryptLib/Hash/CryptSha3.c
> b/CryptoPkg/Library/BaseCryptLib/Hash/CryptSha3.c
> new file mode 100644
> index 0000000000..b170c463de
> --- /dev/null
> +++ b/CryptoPkg/Library/BaseCryptLib/Hash/CryptSha3.c
> @@ -0,0 +1,102 @@
> +/** @file
> 
> +  SHA3 realted functions from OpenSSL.
> 
> +
> 
> +Copyright (c) 2022, Intel Corporation. All rights reserved.<BR>
> 
> +SPDX-License-Identifier: BSD-2-Clause-Patent
> 
> +
> 
> +Copyright 2017-2022 The OpenSSL Project Authors. All Rights Reserved.
> 
> +Licensed under the OpenSSL license (the "License").  You may not use
> 
> +this file except in compliance with the License.  You can obtain a copy
> 
> +in the file LICENSE in the source distribution or at
> 
> +https://www.openssl.org/source/license.html
> 
> +
> 
> +**/
> 
> +
> 
> +#include "sha3.h"
> 
> +
> 
> +size_t SHA3_absorb(uint64_t A[5][5], const unsigned char *inp, size_t len,
> 
> +                   size_t r);
> 
> +void SHA3_squeeze(uint64_t A[5][5], unsigned char *out, size_t len, size_t r);
> 
> +
> 
> +int init(KECCAK1600_CTX *ctx, unsigned char pad, size_t bsz, size_t md_size)
> 
> +{
> 
> +    if (bsz <= sizeof(ctx->buf)) {
> 
> +        memset(ctx->A, 0, sizeof(ctx->A));
> 
> +
> 
> +        ctx->num = 0;
> 
> +        ctx->block_size = bsz;
> 
> +        ctx->md_size = md_size;
> 
> +        ctx->pad = pad;
> 
> +
> 
> +        return 1;
> 
> +    }
> 
> +
> 
> +    return 0;
> 
> +}
> 
> +
> 
> +
> 
> +int sha3_update(KECCAK1600_CTX *ctx, const void *_inp, size_t len)
> 
> +{
> 
> +    const unsigned char *inp = _inp;
> 
> +    size_t bsz = ctx->block_size;
> 
> +    size_t num, rem;
> 
> +
> 
> +    if (len == 0)
> 
> +        return 1;
> 
> +
> 
> +    if ((num = ctx->num) != 0) {      /* process intermediate buffer? */
> 
> +        rem = bsz - num;
> 
> +
> 
> +        if (len < rem) {
> 
> +            memcpy(ctx->buf + num, inp, len);
> 
> +            ctx->num += len;
> 
> +            return 1;
> 
> +        }
> 
> +        /*
> 
> +         * We have enough data to fill or overflow the intermediate
> 
> +         * buffer. So we append |rem| bytes and process the block,
> 
> +         * leaving the rest for later processing...
> 
> +         */
> 
> +        memcpy(ctx->buf + num, inp, rem);
> 
> +        inp += rem, len -= rem;
> 
> +        (void)SHA3_absorb(ctx->A, ctx->buf, bsz, bsz);
> 
> +        ctx->num = 0;
> 
> +        /* ctx->buf is processed, ctx->num is guaranteed to be zero */
> 
> +    }
> 
> +
> 
> +    if (len >= bsz)
> 
> +        rem = SHA3_absorb(ctx->A, inp, len, bsz);
> 
> +    else
> 
> +        rem = len;
> 
> +
> 
> +    if (rem) {
> 
> +        memcpy(ctx->buf, inp + len - rem, rem);
> 
> +        ctx->num = rem;
> 
> +    }
> 
> +
> 
> +    return 1;
> 
> +}
> 
> +
> 
> +int sha3_final(KECCAK1600_CTX *ctx, unsigned char *md)
> 
> +{
> 
> +    size_t bsz = ctx->block_size;
> 
> +    size_t num = ctx->num;
> 
> +
> 
> +    if (ctx->md_size == 0)
> 
> +        return 1;
> 
> +
> 
> +    /*
> 
> +     * Pad the data with 10*1. Note that |num| can be |bsz - 1|
> 
> +     * in which case both byte operations below are performed on
> 
> +     * same byte...
> 
> +     */
> 
> +    memset(ctx->buf + num, 0, bsz - num);
> 
> +    ctx->buf[num] = ctx->pad;
> 
> +    ctx->buf[bsz - 1] |= 0x80;
> 
> +
> 
> +    (void)SHA3_absorb(ctx->A, ctx->buf, bsz, bsz);
> 
> +
> 
> +    SHA3_squeeze(ctx->A, md, ctx->md_size, bsz);
> 
> +
> 
> +    return 1;
> 
> +}
> 
> diff --git a/CryptoPkg/Library/BaseCryptLib/Hash/CryptXkcp.c
> b/CryptoPkg/Library/BaseCryptLib/Hash/CryptXkcp.c
> new file mode 100644
> index 0000000000..b2a40ee044
> --- /dev/null
> +++ b/CryptoPkg/Library/BaseCryptLib/Hash/CryptXkcp.c
> @@ -0,0 +1,53 @@
> +/** @file
> 
> +  Encode realted functions from Xkcp.
> 
> +
> 
> +Copyright (c) 2022, Intel Corporation. All rights reserved.<BR>
> 
> +SPDX-License-Identifier: BSD-2-Clause-Patent
> 
> +
> 
> +The eXtended Keccak Code Package (XKCP)
> 
> +https://github.com/XKCP/XKCP
> 
> +Keccak, designed by Guido Bertoni, Joan Daemen, Michaël Peeters and Gilles
> Van Assche.
> 
> +Implementation by the designers, hereby denoted as "the implementer".
> 
> +For more information, feedback or questions, please refer to the Keccak Team
> website:
> 
> +https://keccak.team/
> 
> +To the extent possible under law, the implementer has waived all copyright
> 
> +and related or neighboring rights to the source code in this file.
> 
> +http://creativecommons.org/publicdomain/zero/1.0/
> 
> +
> 
> +**/
> 
> +
> 
> +#include "xkcp.h"
> 
> +
> 
> +unsigned int left_encode(unsigned char * encbuf, size_t value)
> 
> +{
> 
> +    unsigned int n, i;
> 
> +    size_t v;
> 
> +
> 
> +    for ( v = value, n = 0; v && (n < sizeof(size_t)); ++n, v >>= 8 )
> 
> +        ; /* empty */
> 
> +    if (n == 0)
> 
> +        n = 1;
> 
> +    for ( i = 1; i <= n; ++i )
> 
> +    {
> 
> +        encbuf[i] = (unsigned char)(value >> (8 * (n-i)));
> 
> +    }
> 
> +    encbuf[0] = (unsigned char)n;
> 
> +    return n + 1;
> 
> +}
> 
> +
> 
> +unsigned int right_encode(unsigned char * encbuf, size_t value)
> 
> +{
> 
> +    unsigned int n, i;
> 
> +    size_t v;
> 
> +
> 
> +    for ( v = value, n = 0; v && (n < sizeof(size_t)); ++n, v >>= 8 )
> 
> +        ; /* empty */
> 
> +    if (n == 0)
> 
> +        n = 1;
> 
> +    for ( i = 1; i <= n; ++i )
> 
> +    {
> 
> +        encbuf[i-1] = (unsigned char)(value >> (8 * (n-i)));
> 
> +    }
> 
> +    encbuf[n] = (unsigned char)n;
> 
> +    return n + 1;
> 
> +}
> 
> diff --git a/CryptoPkg/Test/UnitTest/Library/BaseCryptLib/ParallelhashTests.c
> b/CryptoPkg/Test/UnitTest/Library/BaseCryptLib/ParallelhashTests.c
> new file mode 100644
> index 0000000000..052ab3a0d6
> --- /dev/null
> +++ b/CryptoPkg/Test/UnitTest/Library/BaseCryptLib/ParallelhashTests.c
> @@ -0,0 +1,152 @@
> +/** @file
> 
> +  Application for Parallelhash Function Validation.
> 
> +
> 
> +Copyright (c) 2022, Intel Corporation. All rights reserved.<BR>
> 
> +SPDX-License-Identifier: BSD-2-Clause-Patent
> 
> +
> 
> +**/
> 
> +
> 
> +#include "TestBaseCryptLib.h"
> 
> +
> 
> +//
> 
> +// Parallelhash Test Sample common parameters.
> 
> +//
> 
> +GLOBAL_REMOVE_IF_UNREFERENCED CONST UINTN  OutputByteLen = 64;
> 
> +
> 
> +//
> 
> +// Parallelhash Test Sample #1 from NIST Special Publication 800-185.
> 
> +//
> 
> +GLOBAL_REMOVE_IF_UNREFERENCED CONST UINT8   InputSample1[]          = {
> 
> +  // input data of sample1.
> 
> +  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x12, 0x13, 0x14,
> 0x15, 0x16, 0x17,
> 
> +  0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27
> 
> +};
> 
> +GLOBAL_REMOVE_IF_UNREFERENCED UINTN        InputSample1ByteLen      =
> 24;     // Length of sample1 input data in bytes.
> 
> +GLOBAL_REMOVE_IF_UNREFERENCED CONST VOID   *CustomizationSample1
> = "";     // Customization string (S) of sample1.
> 
> +GLOBAL_REMOVE_IF_UNREFERENCED UINTN        CustomSample1ByteLen     =
> 0;      // Customization string length of sample1 in bytes.
> 
> +GLOBAL_REMOVE_IF_UNREFERENCED UINTN        BlockSizeSample1         = 8;
> // Block size of sample1.
> 
> +GLOBAL_REMOVE_IF_UNREFERENCED CONST UINT8  ExpectOutputSample1[]
> = {
> 
> +  // Expected output data of sample1.
> 
> +  0xbc, 0x1e, 0xf1, 0x24, 0xda, 0x34, 0x49, 0x5e, 0x94, 0x8e, 0xad, 0x20, 0x7d,
> 0xd9, 0x84, 0x22,
> 
> +  0x35, 0xda, 0x43, 0x2d, 0x2b, 0xbc, 0x54, 0xb4, 0xc1, 0x10, 0xe6, 0x4c, 0x45,
> 0x11, 0x05, 0x53,
> 
> +  0x1b, 0x7f, 0x2a, 0x3e, 0x0c, 0xe0, 0x55, 0xc0, 0x28, 0x05, 0xe7, 0xc2, 0xde,
> 0x1f, 0xb7, 0x46,
> 
> +  0xaf, 0x97, 0xa1, 0xd0, 0x01, 0xf4, 0x3b, 0x82, 0x4e, 0x31, 0xb8, 0x76, 0x12,
> 0x41, 0x04, 0x29
> 
> +};
> 
> +
> 
> +//
> 
> +// Parallelhash Test Sample #2 from NIST Special Publication 800-185.
> 
> +//
> 
> +GLOBAL_REMOVE_IF_UNREFERENCED CONST UINT8  *InputSample2            =
> InputSample1;            // Input of sample2 is same as sample1.
> 
> +GLOBAL_REMOVE_IF_UNREFERENCED UINTN        InputSample2ByteLen      =
> 24;                      // Length of sample2 input data in bytes.
> 
> +GLOBAL_REMOVE_IF_UNREFERENCED CONST VOID   *CustomizationSample2
> = "Parallel Data";         // Customization string (S) of sample2.
> 
> +GLOBAL_REMOVE_IF_UNREFERENCED UINTN        CustomSample2ByteLen     =
> 13;                      // Customization string length of sample2 in bytes.
> 
> +GLOBAL_REMOVE_IF_UNREFERENCED UINTN        BlockSizeSample2         = 8;
> // Block size of sample2.
> 
> +GLOBAL_REMOVE_IF_UNREFERENCED CONST UINT8  ExpectOutputSample2[]
> = {
> 
> +  // Expected output data of sample2.
> 
> +  0xcd, 0xf1, 0x52, 0x89, 0xb5, 0x4f, 0x62, 0x12, 0xb4, 0xbc, 0x27, 0x05, 0x28,
> 0xb4, 0x95, 0x26,
> 
> +  0x00, 0x6d, 0xd9, 0xb5, 0x4e, 0x2b, 0x6a, 0xdd, 0x1e, 0xf6, 0x90, 0x0d, 0xda,
> 0x39, 0x63, 0xbb,
> 
> +  0x33, 0xa7, 0x24, 0x91, 0xf2, 0x36, 0x96, 0x9c, 0xa8, 0xaf, 0xae, 0xa2, 0x9c,
> 0x68, 0x2d, 0x47,
> 
> +  0xa3, 0x93, 0xc0, 0x65, 0xb3, 0x8e, 0x29, 0xfa, 0xe6, 0x51, 0xa2, 0x09, 0x1c,
> 0x83, 0x31, 0x10
> 
> +};
> 
> +
> 
> +//
> 
> +// Parallelhash Test Sample #3 from NIST Special Publication 800-185.
> 
> +//
> 
> +GLOBAL_REMOVE_IF_UNREFERENCED CONST UINT8  InputSample3[]           = {
> 
> +  // input data of sample3.
> 
> +  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x10,
> 0x11, 0x12, 0x13,
> 
> +  0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x20, 0x21, 0x22, 0x23, 0x24,
> 0x25, 0x26, 0x27,
> 
> +  0x28, 0x29, 0x2a, 0x2b, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
> 0x39, 0x3a, 0x3b,
> 
> +  0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x50,
> 0x51, 0x52, 0x53,
> 
> +  0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b
> 
> +};
> 
> +GLOBAL_REMOVE_IF_UNREFERENCED UINTN        InputSample3ByteLen      =
> 72;                      // Length of sample3 input data in bytes.
> 
> +GLOBAL_REMOVE_IF_UNREFERENCED CONST VOID   *CustomizationSample3
> = "Parallel Data";         // Customization string (S) of sample3.
> 
> +GLOBAL_REMOVE_IF_UNREFERENCED UINTN        CustomSample3ByteLen     =
> 13;                      // Customization string length of sample3 in bytes.
> 
> +GLOBAL_REMOVE_IF_UNREFERENCED UINTN        BlockSizeSample3         = 12;
> // Block size of sample3.
> 
> +GLOBAL_REMOVE_IF_UNREFERENCED CONST UINT8  ExpectOutputSample3[]
> = {
> 
> +  // Expected output data of sample3.
> 
> +  0x69, 0xd0, 0xfc, 0xb7, 0x64, 0xea, 0x05, 0x5d, 0xd0, 0x93, 0x34, 0xbc, 0x60,
> 0x21, 0xcb, 0x7e,
> 
> +  0x4b, 0x61, 0x34, 0x8d, 0xff, 0x37, 0x5d, 0xa2, 0x62, 0x67, 0x1c, 0xde, 0xc3,
> 0xef, 0xfa, 0x8d,
> 
> +  0x1b, 0x45, 0x68, 0xa6, 0xcc, 0xe1, 0x6b, 0x1c, 0xad, 0x94, 0x6d, 0xdd, 0xe2,
> 0x7f, 0x6c, 0xe2,
> 
> +  0xb8, 0xde, 0xe4, 0xcd, 0x1b, 0x24, 0x85, 0x1e, 0xbf, 0x00, 0xeb, 0x90, 0xd4,
> 0x38, 0x13, 0xe9
> 
> +};
> 
> +
> 
> +UNIT_TEST_STATUS
> 
> +EFIAPI
> 
> +TestVerifyParallelHash256HashAll (
> 
> +  IN UNIT_TEST_CONTEXT  Context
> 
> +  )
> 
> +{
> 
> +  BOOLEAN  Status;
> 
> +  UINT16   OriginalParallelHashBlockNumber;
> 
> +  UINT8    Output[64];
> 
> +
> 
> +  // Restore original PcdParallelHashBlockNumber.
> 
> +  OriginalParallelHashBlockNumber = PcdGet16 (PcdParallelHashBlockNumber);
> 
> +
> 
> +  //
> 
> +  // Test #1 using sample1.
> 
> +  //
> 
> +  PcdSet16S (PcdParallelHashBlockNumber, InputSample1ByteLen /
> BlockSizeSample1);
> 
> +  Status = ParallelHash256HashAll (
> 
> +             InputSample1,
> 
> +             InputSample1ByteLen,
> 
> +             Output,
> 
> +             OutputByteLen,
> 
> +             CustomizationSample1,
> 
> +             CustomSample1ByteLen
> 
> +             );
> 
> +  UT_ASSERT_TRUE (Status);
> 
> +
> 
> +  // Check the output with the expected output.
> 
> +  UT_ASSERT_MEM_EQUAL (Output, ExpectOutputSample1, OutputByteLen);
> 
> +
> 
> +  //
> 
> +  // Test #2 using sample2.
> 
> +  //
> 
> +  PcdSet16S (PcdParallelHashBlockNumber, InputSample2ByteLen /
> BlockSizeSample2);
> 
> +  Status = ParallelHash256HashAll (
> 
> +             InputSample2,
> 
> +             InputSample2ByteLen,
> 
> +             Output,
> 
> +             OutputByteLen,
> 
> +             CustomizationSample2,
> 
> +             CustomSample2ByteLen
> 
> +             );
> 
> +  UT_ASSERT_TRUE (Status);
> 
> +
> 
> +  // Check the output with the expected output.
> 
> +  UT_ASSERT_MEM_EQUAL (Output, ExpectOutputSample2, OutputByteLen);
> 
> +
> 
> +  //
> 
> +  // Test #3 using sample3.
> 
> +  //
> 
> +  PcdSet16S (PcdParallelHashBlockNumber, InputSample3ByteLen /
> BlockSizeSample3);
> 
> +  Status = ParallelHash256HashAll (
> 
> +             InputSample3,
> 
> +             InputSample3ByteLen,
> 
> +             Output,
> 
> +             OutputByteLen,
> 
> +             CustomizationSample3,
> 
> +             CustomSample3ByteLen
> 
> +             );
> 
> +  UT_ASSERT_TRUE (Status);
> 
> +
> 
> +  // Check the output with the expected output.
> 
> +  UT_ASSERT_MEM_EQUAL (Output, ExpectOutputSample3, OutputByteLen);
> 
> +
> 
> +  // Recover original PcdParallelHashBlockNumber.
> 
> +  PcdSet16S (PcdParallelHashBlockNumber, OriginalParallelHashBlockNumber);
> 
> +
> 
> +  return EFI_SUCCESS;
> 
> +}
> 
> +
> 
> +TEST_DESC  mParallelhashTest[] = {
> 
> +  //
> 
> +  // -----Description------------------------------Class----------------------Function----
> -------------Pre---Post--Context
> 
> +  //
> 
> +  { "TestVerifyParallelHash256HashAll()",
> "CryptoPkg.BaseCryptLib.ParallelHash256HashAll",
> TestVerifyParallelHash256HashAll, NULL, NULL, NULL },
> 
> +};
> 
> +
> 
> +UINTN  mParallelhashTestNum = ARRAY_SIZE (mParallelhashTest);
> 
> diff --git a/CryptoPkg/CryptoPkg.dec b/CryptoPkg/CryptoPkg.dec
> index 5888941bab..3af55d9c10 100644
> --- a/CryptoPkg/CryptoPkg.dec
> +++ b/CryptoPkg/CryptoPkg.dec
> @@ -4,7 +4,7 @@
>  #  This Package provides cryptographic-related libraries for UEFI security
> modules.
> 
>  #  It also provides a test application to test libraries.
> 
>  #
> 
> -#  Copyright (c) 2009 - 2020, Intel Corporation. All rights reserved.<BR>
> 
> +#  Copyright (c) 2009 - 2022, Intel Corporation. All rights reserved.<BR>
> 
>  #  SPDX-License-Identifier: BSD-2-Clause-Patent
> 
>  #
> 
>  ##
> 
> @@ -81,5 +81,12 @@
>    # @ValidList 0x80000001 | 0x00000001, 0x00000002, 0x00000004,
> 0x00000008, 0x00000010
> 
> 
> gEfiCryptoPkgTokenSpaceGuid.PcdHashApiLibPolicy|0x00000002|UINT32|0x00
> 000001
> 
> 
> 
> +[PcdsFixedAtBuild, PcdsPatchableInModule, PcdsDynamic, PcdsDynamicEx]
> 
> +  ## This PCD indicates the block number of parallel hash
> 
> +  #  Based on the value set, parallel hash can chose the block
> 
> +  #  number to calculate specific hash.<BR>
> 
> +  #  The number can be set by platform team according to the core number.
> 
> +
> gEfiCryptoPkgTokenSpaceGuid.PcdParallelHashBlockNumber|0x0100|UINT16|0
> x00000003
> 
> +
> 
>  [UserExtensions.TianoCore."ExtraFiles"]
> 
>    CryptoPkgExtra.uni
> 
> diff --git a/CryptoPkg/Include/Library/BaseCryptLib.h
> b/CryptoPkg/Include/Library/BaseCryptLib.h
> index f4bc7c0d73..0b274b1257 100644
> --- a/CryptoPkg/Include/Library/BaseCryptLib.h
> +++ b/CryptoPkg/Include/Library/BaseCryptLib.h
> @@ -4,7 +4,7 @@
>    primitives (Hash Serials, HMAC, RSA, Diffie-Hellman, etc) for UEFI security
> 
>    functionality enabling.
> 
> 
> 
> -Copyright (c) 2009 - 2020, Intel Corporation. All rights reserved.<BR>
> 
> +Copyright (c) 2009 - 2022, Intel Corporation. All rights reserved.<BR>
> 
>  SPDX-License-Identifier: BSD-2-Clause-Patent
> 
> 
> 
>  **/
> 
> @@ -753,6 +753,33 @@ Sha512HashAll (
>    OUT  UINT8       *HashValue
> 
>    );
> 
> 
> 
> +/**
> 
> +  Parallel hash function ParallelHash256, as defined in NIST's Special Publication
> 800-185,
> 
> +  published December 2016.
> 
> +
> 
> +  @param[in]   Input            Pointer to the input message (X).
> 
> +  @param[in]   InputByteLen     The number(>0) of input bytes provided for the
> input data.
> 
> +  @param[out]  Output           Pointer to the output buffer.
> 
> +  @param[in]   OutputByteLen    The desired number of output bytes (L).
> 
> +  @param[in]   Customization    Pointer to the customization string (S).
> 
> +  @param[in]   CustomByteLen    The length of the customization string in bytes.
> 
> +
> 
> +  @retval TRUE   ParallelHash256 digest computation succeeded.
> 
> +  @retval FALSE  ParallelHash256 digest computation failed.
> 
> +  @retval FALSE  This interface is not supported.
> 
> +
> 
> +**/
> 
> +BOOLEAN
> 
> +EFIAPI
> 
> +ParallelHash256HashAll (
> 
> +  IN CONST VOID            *Input,
> 
> +  IN       UINTN           InputByteLen,
> 
> +  OUT      VOID            *Output,
> 
> +  IN       UINTN           OutputByteLen,
> 
> +  IN CONST VOID            *Customization,
> 
> +  IN       UINTN           CustomByteLen
> 
> +  );
> 
> +
> 
>  /**
> 
>    Retrieves the size, in bytes, of the context buffer required for SM3 hash
> operations.
> 
> 
> 
> diff --git a/CryptoPkg/Library/BaseCryptLib/SmmCryptLib.inf
> b/CryptoPkg/Library/BaseCryptLib/SmmCryptLib.inf
> index e6470d7a21..70159163d4 100644
> --- a/CryptoPkg/Library/BaseCryptLib/SmmCryptLib.inf
> +++ b/CryptoPkg/Library/BaseCryptLib/SmmCryptLib.inf
> @@ -10,7 +10,7 @@
>  #  RSA external functions, PKCS#7 SignedData sign functions, Diffie-Hellman
> functions, and
> 
>  #  authenticode signature verification functions are not supported in this
> instance.
> 
>  #
> 
> -#  Copyright (c) 2010 - 2021, Intel Corporation. All rights reserved.<BR>
> 
> +#  Copyright (c) 2010 - 2022, Intel Corporation. All rights reserved.<BR>
> 
>  #  SPDX-License-Identifier: BSD-2-Clause-Patent
> 
>  #
> 
>  ##
> 
> @@ -38,6 +38,10 @@
>    Hash/CryptSha256.c
> 
>    Hash/CryptSm3.c
> 
>    Hash/CryptSha512.c
> 
> +  Hash/CryptSha3.c
> 
> +  Hash/CryptXkcp.c
> 
> +  Hash/CryptCShake256.c
> 
> +  Hash/CryptParallelHash.c
> 
>    Hmac/CryptHmacSha256.c
> 
>    Kdf/CryptHkdfNull.c
> 
>    Cipher/CryptAes.c
> 
> @@ -85,6 +89,9 @@
>    OpensslLib
> 
>    IntrinsicLib
> 
>    PrintLib
> 
> +  MmServicesTableLib
> 
> +  SynchronizationLib
> 
> +  PcdLib
> 
> 
> 
>  #
> 
>  # Remove these [BuildOptions] after this library is cleaned up
> 
> @@ -101,3 +108,6 @@
>    GCC:*_CLANG35_*_CC_FLAGS = -std=c99
> 
>    GCC:*_CLANG38_*_CC_FLAGS = -std=c99
> 
>    GCC:*_CLANGPDB_*_CC_FLAGS = -std=c99 -Wno-error=incompatible-pointer-
> types
> 
> +
> 
> +[Pcd]
> 
> +  gEfiCryptoPkgTokenSpaceGuid.PcdParallelHashBlockNumber
> 
> diff --git a/CryptoPkg/Library/Include/CrtLibSupport.h
> b/CryptoPkg/Library/Include/CrtLibSupport.h
> index d257dca8fa..35d9c62a0b 100644
> --- a/CryptoPkg/Library/Include/CrtLibSupport.h
> +++ b/CryptoPkg/Library/Include/CrtLibSupport.h
> @@ -2,7 +2,7 @@
>    Root include file of C runtime library to support building the third-party
> 
>    cryptographic library.
> 
> 
> 
> -Copyright (c) 2010 - 2021, Intel Corporation. All rights reserved.<BR>
> 
> +Copyright (c) 2010 - 2022, Intel Corporation. All rights reserved.<BR>
> 
>  Copyright (c) 2020, Hewlett Packard Enterprise Development LP. All rights
> reserved.<BR>
> 
>  SPDX-License-Identifier: BSD-2-Clause-Patent
> 
> 
> 
> @@ -21,6 +21,8 @@ SPDX-License-Identifier: BSD-2-Clause-Patent
> 
> 
>  #define MAX_STRING_SIZE  0x1000
> 
> 
> 
> +#define PARALLELHASH_CUSTOMIZATION "ParallelHash"
> 
> +
> 
>  //
> 
>  // We already have "no-ui" in out Configure invocation.
> 
>  // but the code still fails to compile.
> 
> @@ -111,6 +113,7 @@ typedef UINT8   u_char;
>  typedef UINT32  uid_t;
> 
>  typedef UINT32  gid_t;
> 
>  typedef CHAR16  wchar_t;
> 
> +typedef UINT64  uint64_t;
> 
> 
> 
>  //
> 
>  // File operations are not required for EFI building,
> 
> diff --git a/CryptoPkg/Library/Include/sha3.h
> b/CryptoPkg/Library/Include/sha3.h
> new file mode 100644
> index 0000000000..71b4c75548
> --- /dev/null
> +++ b/CryptoPkg/Library/Include/sha3.h
> @@ -0,0 +1,32 @@
> +/** @file
> 
> +  SHA3 realted functions from OpenSSL.
> 
> +
> 
> +Copyright (c) 2022, Intel Corporation. All rights reserved.<BR>
> 
> +SPDX-License-Identifier: BSD-2-Clause-Patent
> 
> +
> 
> +Copyright 2017-2022 The OpenSSL Project Authors. All Rights Reserved.
> 
> +Licensed under the OpenSSL license (the "License").  You may not use
> 
> +this file except in compliance with the License.  You can obtain a copy
> 
> +in the file LICENSE in the source distribution or at
> 
> +https://www.openssl.org/source/license.html
> 
> +
> 
> +**/
> 
> +
> 
> +#include <CrtLibSupport.h>
> 
> +
> 
> +#define KECCAK1600_WIDTH 1600
> 
> +
> 
> +typedef struct {
> 
> +    uint64_t A[5][5];
> 
> +    size_t block_size;          /* cached ctx->digest->block_size */
> 
> +    size_t md_size;             /* output length, variable in XOF */
> 
> +    size_t num;                 /* used bytes in below buffer */
> 
> +    unsigned char buf[KECCAK1600_WIDTH / 8 - 32];
> 
> +    unsigned char pad;
> 
> +} KECCAK1600_CTX;
> 
> +
> 
> +int init(KECCAK1600_CTX *ctx, unsigned char pad, size_t bsz, size_t md_size);
> 
> +
> 
> +int sha3_update(KECCAK1600_CTX *ctx, const void *_inp, size_t len);
> 
> +
> 
> +int sha3_final(KECCAK1600_CTX *ctx, unsigned char *md);
> 
> diff --git a/CryptoPkg/Library/Include/xkcp.h
> b/CryptoPkg/Library/Include/xkcp.h
> new file mode 100644
> index 0000000000..b328d672e4
> --- /dev/null
> +++ b/CryptoPkg/Library/Include/xkcp.h
> @@ -0,0 +1,23 @@
> +/** @file
> 
> +  Encode realted functions from Xkcp.
> 
> +
> 
> +Copyright (c) 2022, Intel Corporation. All rights reserved.<BR>
> 
> +SPDX-License-Identifier: BSD-2-Clause-Patent
> 
> +
> 
> +The eXtended Keccak Code Package (XKCP)
> 
> +https://github.com/XKCP/XKCP
> 
> +Keccak, designed by Guido Bertoni, Joan Daemen, Michaël Peeters and Gilles
> Van Assche.
> 
> +Implementation by the designers, hereby denoted as "the implementer".
> 
> +For more information, feedback or questions, please refer to the Keccak Team
> website:
> 
> +https://keccak.team/
> 
> +To the extent possible under law, the implementer has waived all copyright
> 
> +and related or neighboring rights to the source code in this file.
> 
> +http://creativecommons.org/publicdomain/zero/1.0/
> 
> +
> 
> +**/
> 
> +
> 
> +#include <CrtLibSupport.h>
> 
> +
> 
> +unsigned int left_encode(unsigned char * encbuf, size_t value);
> 
> +
> 
> +unsigned int right_encode(unsigned char * encbuf, size_t value);
> 
> diff --git a/CryptoPkg/Test/UnitTest/Library/BaseCryptLib/TestBaseCryptLib.h
> b/CryptoPkg/Test/UnitTest/Library/BaseCryptLib/TestBaseCryptLib.h
> index a6b3482742..0bffd687c2 100644
> --- a/CryptoPkg/Test/UnitTest/Library/BaseCryptLib/TestBaseCryptLib.h
> +++ b/CryptoPkg/Test/UnitTest/Library/BaseCryptLib/TestBaseCryptLib.h
> @@ -1,7 +1,7 @@
>  /** @file
> 
>    Application for Cryptographic Primitives Validation.
> 
> 
> 
> -Copyright (c) 2009 - 2016, Intel Corporation. All rights reserved.<BR>
> 
> +Copyright (c) 2009 - 2022, Intel Corporation. All rights reserved.<BR>
> 
>  SPDX-License-Identifier: BSD-2-Clause-Patent
> 
> 
> 
>  **/
> 
> @@ -19,6 +19,7 @@ SPDX-License-Identifier: BSD-2-Clause-Patent
>  #include <Library/BaseLib.h>
> 
>  #include <Library/BaseMemoryLib.h>
> 
>  #include <Library/MemoryAllocationLib.h>
> 
> +#include <Library/PcdLib.h>
> 
>  // #include <UnitTestTypes.h>
> 
>  #include <Library/UnitTestLib.h>
> 
>  // #include <Library/UnitTestAssertLib.h>
> 
> diff --git
> a/CryptoPkg/Test/UnitTest/Library/BaseCryptLib/TestBaseCryptLibHost.inf
> b/CryptoPkg/Test/UnitTest/Library/BaseCryptLib/TestBaseCryptLibHost.inf
> index 00c8692650..61a59d6a47 100644
> --- a/CryptoPkg/Test/UnitTest/Library/BaseCryptLib/TestBaseCryptLibHost.inf
> +++ b/CryptoPkg/Test/UnitTest/Library/BaseCryptLib/TestBaseCryptLibHost.inf
> @@ -2,6 +2,7 @@
>  # Host-based UnitTest for BaseCryptLib
> 
>  #
> 
>  # Copyright (c) Microsoft Corporation.<BR>
> 
> +# Copyright (c) 2022, Intel Corporation. All rights reserved.<BR>
> 
>  # SPDX-License-Identifier: BSD-2-Clause-Patent
> 
>  ##
> 
> 
> 
> @@ -35,6 +36,7 @@
>    Pkcs7EkuTests.c
> 
>    OaepEncryptTests.c
> 
>    RsaPssTests.c
> 
> +  ParallelhashTests.c
> 
> 
> 
>  [Packages]
> 
>    MdePkg/MdePkg.dec
> 
> @@ -45,3 +47,8 @@
>    DebugLib
> 
>    BaseCryptLib
> 
>    UnitTestLib
> 
> +  PcdLib
> 
> +
> 
> +[Pcd]
> 
> +  gEfiCryptoPkgTokenSpaceGuid.PcdParallelHashBlockNumber
> 
> +
> 
> diff --git
> a/CryptoPkg/Test/UnitTest/Library/BaseCryptLib/TestBaseCryptLibShell.inf
> b/CryptoPkg/Test/UnitTest/Library/BaseCryptLib/TestBaseCryptLibShell.inf
> index ca789aa6ad..682f25a754 100644
> --- a/CryptoPkg/Test/UnitTest/Library/BaseCryptLib/TestBaseCryptLibShell.inf
> +++ b/CryptoPkg/Test/UnitTest/Library/BaseCryptLib/TestBaseCryptLibShell.inf
> @@ -2,6 +2,7 @@
>  # BaseCryptLib UnitTest built for execution in UEFI Shell.
> 
>  #
> 
>  # Copyright (c) Microsoft Corporation.<BR>
> 
> +# Copyright (c) 2022, Intel Corporation. All rights reserved.<BR>
> 
>  # SPDX-License-Identifier: BSD-2-Clause-Patent
> 
>  ##
> 
> 
> 
> @@ -36,6 +37,7 @@
>    Pkcs7EkuTests.c
> 
>    OaepEncryptTests.c
> 
>    RsaPssTests.c
> 
> +  ParallelhashTests.c
> 
> 
> 
>  [Packages]
> 
>    MdePkg/MdePkg.dec
> 
> @@ -48,3 +50,7 @@
>    UnitTestLib
> 
>    PrintLib
> 
>    BaseCryptLib
> 
> +  PcdLib
> 
> +
> 
> +[Pcd]
> 
> +  gEfiCryptoPkgTokenSpaceGuid.PcdParallelHashBlockNumber
> 
> --
> 2.26.2.windows.1