CryptoPkg: Add BigNum support

REF: https://bugzilla.tianocore.org/show_bug.cgi?id=3828

This patch is used to add CryptBn library, which is wrapped
over OpenSSL.

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>
Signed-off-by: Yi Li <yi1.li@intel.com>
Reviewed-by: Jiewen Yao <jiewen.yao@intel.com>

diff --git a/CryptoPkg/Include/Library/BaseCryptLib.h b/CryptoPkg/Include/Library/BaseCryptLib.h
index 9436fe0f19b20e01cba00713e928e37f66126296..3026299e2953057d00c991e16bc26a17cc7fa921 100644 (file)
--- a/CryptoPkg/Include/Library/BaseCryptLib.h
+++ b/CryptoPkg/Include/Library/BaseCryptLib.h
@@ -2836,4 +2836,422 @@ HkdfSha384Expand (
   IN   UINTN        OutSize\r
   );\r
 \r
+// =====================================================================================\r
+//    Big number primitives\r
+// =====================================================================================\r
+\r
+/**\r
+  Allocate new Big Number.\r
+\r
+  @retval New BigNum opaque structure or NULL on failure.\r
+**/\r
+VOID *\r
+EFIAPI\r
+BigNumInit (\r
+  VOID\r
+  );\r
+\r
+/**\r
+  Allocate new Big Number and assign the provided value to it.\r
+\r
+  @param[in]   Buf    Big endian encoded buffer.\r
+  @param[in]   Len    Buffer length.\r
+\r
+  @retval New BigNum opaque structure or NULL on failure.\r
+**/\r
+VOID *\r
+EFIAPI\r
+BigNumFromBin (\r
+  IN CONST UINT8  *Buf,\r
+  IN UINTN        Len\r
+  );\r
+\r
+/**\r
+  Convert the absolute value of Bn into big-endian form and store it at Buf.\r
+  The Buf array should have at least BigNumBytes() in it.\r
+\r
+  @param[in]   Bn     Big number to convert.\r
+  @param[out]  Buf    Output buffer.\r
+\r
+  @retval The length of the big-endian number placed at Buf or -1 on error.\r
+**/\r
+INTN\r
+EFIAPI\r
+BigNumToBin (\r
+  IN CONST VOID  *Bn,\r
+  OUT UINT8      *Buf\r
+  );\r
+\r
+/**\r
+  Free the Big Number.\r
+\r
+  @param[in]   Bn      Big number to free.\r
+  @param[in]   Clear   TRUE if the buffer should be cleared.\r
+**/\r
+VOID\r
+EFIAPI\r
+BigNumFree (\r
+  IN VOID     *Bn,\r
+  IN BOOLEAN  Clear\r
+  );\r
+\r
+/**\r
+  Calculate the sum of two Big Numbers.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnB     Big number.\r
+  @param[out]  BnRes   The result of BnA + BnB.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumAdd (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB,\r
+  OUT VOID       *BnRes\r
+  );\r
+\r
+/**\r
+  Subtract two Big Numbers.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnB     Big number.\r
+  @param[out]  BnRes   The result of BnA - BnB.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumSub (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB,\r
+  OUT VOID       *BnRes\r
+  );\r
+\r
+/**\r
+  Calculate remainder: BnRes = BnA % BnB.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnB     Big number.\r
+  @param[out]  BnRes   The result of BnA % BnB.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumMod (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB,\r
+  OUT VOID       *BnRes\r
+  );\r
+\r
+/**\r
+  Compute BnA to the BnP-th power modulo BnM.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnP     Big number (power).\r
+  @param[in]   BnM     Big number (modulo).\r
+  @param[out]  BnRes   The result of (BnA ^ BnP) % BnM.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumExpMod (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnP,\r
+  IN CONST VOID  *BnM,\r
+  OUT VOID       *BnRes\r
+  );\r
+\r
+/**\r
+  Compute BnA inverse modulo BnM.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnM     Big number (modulo).\r
+  @param[out]  BnRes   The result, such that (BnA * BnRes) % BnM == 1.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumInverseMod (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnM,\r
+  OUT VOID       *BnRes\r
+  );\r
+\r
+/**\r
+  Divide two Big Numbers.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnB     Big number.\r
+  @param[out]  BnRes   The result, such that BnA / BnB.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumDiv (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB,\r
+  OUT VOID       *BnRes\r
+  );\r
+\r
+/**\r
+  Multiply two Big Numbers modulo BnM.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnB     Big number.\r
+  @param[in]   BnM     Big number (modulo).\r
+  @param[out]  BnRes   The result, such that (BnA * BnB) % BnM.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumMulMod (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB,\r
+  IN CONST VOID  *BnM,\r
+  OUT VOID       *BnRes\r
+  );\r
+\r
+/**\r
+  Compare two Big Numbers.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnB     Big number.\r
+\r
+  @retval 0          BnA == BnB.\r
+  @retval 1          BnA > BnB.\r
+  @retval -1         BnA < BnB.\r
+**/\r
+INTN\r
+EFIAPI\r
+BigNumCmp (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB\r
+  );\r
+\r
+/**\r
+  Get number of bits in Bn.\r
+\r
+  @param[in]   Bn     Big number.\r
+\r
+  @retval Number of bits.\r
+**/\r
+\r
+UINTN\r
+EFIAPI\r
+BigNumBits (\r
+  IN CONST VOID  *Bn\r
+  );\r
+\r
+/**\r
+  Get number of bytes in Bn.\r
+\r
+  @param[in]   Bn     Big number.\r
+\r
+  @retval Number of bytes.\r
+**/\r
+UINTN\r
+EFIAPI\r
+BigNumBytes (\r
+  IN CONST VOID  *Bn\r
+  );\r
+\r
+/**\r
+  Checks if Big Number equals to the given Num.\r
+\r
+  @param[in]   Bn     Big number.\r
+  @param[in]   Num    Number.\r
+\r
+  @retval TRUE   iff Bn == Num.\r
+  @retval FALSE  otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumIsWord (\r
+  IN CONST VOID  *Bn,\r
+  IN UINTN       Num\r
+  );\r
+\r
+/**\r
+  Checks if Big Number is odd.\r
+\r
+  @param[in]   Bn     Big number.\r
+\r
+  @retval TRUE   Bn is odd (Bn % 2 == 1).\r
+  @retval FALSE  otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumIsOdd (\r
+  IN CONST VOID  *Bn\r
+  );\r
+\r
+/**\r
+  Copy Big number.\r
+\r
+  @param[out]  BnDst     Destination.\r
+  @param[in]   BnSrc     Source.\r
+\r
+  @retval BnDst on success.\r
+  @retval NULL otherwise.\r
+**/\r
+VOID *\r
+EFIAPI\r
+BigNumCopy (\r
+  OUT VOID       *BnDst,\r
+  IN CONST VOID  *BnSrc\r
+  );\r
+\r
+/**\r
+  Get constant Big number with value of "1".\r
+  This may be used to save expensive allocations.\r
+\r
+  @retval Big Number with value of 1.\r
+**/\r
+CONST VOID *\r
+EFIAPI\r
+BigNumValueOne (\r
+  VOID\r
+  );\r
+\r
+/**\r
+  Shift right Big Number.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   Bn      Big number.\r
+  @param[in]   N       Number of bits to shift.\r
+  @param[out]  BnRes   The result.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumRShift (\r
+  IN CONST VOID  *Bn,\r
+  IN UINTN       N,\r
+  OUT VOID       *BnRes\r
+  );\r
+\r
+/**\r
+  Mark Big Number for constant time computations.\r
+  This function should be called before any constant time computations are\r
+  performed on the given Big number.\r
+\r
+  @param[in]   Bn     Big number.\r
+**/\r
+VOID\r
+EFIAPI\r
+BigNumConstTime (\r
+  IN VOID  *Bn\r
+  );\r
+\r
+/**\r
+  Calculate square modulo.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnM     Big number (modulo).\r
+  @param[out]  BnRes   The result, such that (BnA ^ 2) % BnM.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumSqrMod (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnM,\r
+  OUT VOID       *BnRes\r
+  );\r
+\r
+/**\r
+  Create new Big Number computation context. This is an opaque structure\r
+  which should be passed to any function that requires it. The BN context is\r
+  needed to optimize calculations and expensive allocations.\r
+\r
+  @retval Big Number context struct or NULL on failure.\r
+**/\r
+VOID *\r
+EFIAPI\r
+BigNumNewContext (\r
+  VOID\r
+  );\r
+\r
+/**\r
+  Free Big Number context that was allocated with BigNumNewContext().\r
+\r
+  @param[in]   BnCtx     Big number context to free.\r
+**/\r
+VOID\r
+EFIAPI\r
+BigNumContextFree (\r
+  IN VOID  *BnCtx\r
+  );\r
+\r
+/**\r
+  Set Big Number to a given value.\r
+\r
+  @param[in]   Bn     Big number to set.\r
+  @param[in]   Val    Value to set.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumSetUint (\r
+  IN VOID   *Bn,\r
+  IN UINTN  Val\r
+  );\r
+\r
+/**\r
+  Add two Big Numbers modulo BnM.\r
+\r
+  @param[in]   BnA       Big number.\r
+  @param[in]   BnB       Big number.\r
+  @param[in]   BnM       Big number (modulo).\r
+  @param[out]  BnRes     The result, such that (BnA + BnB) % BnM.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumAddMod (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB,\r
+  IN CONST VOID  *BnM,\r
+  OUT VOID       *BnRes\r
+  );\r
+\r
 #endif // __BASE_CRYPT_LIB_H__\r

diff --git a/CryptoPkg/Library/BaseCryptLib/BaseCryptLib.inf b/CryptoPkg/Library/BaseCryptLib/BaseCryptLib.inf
index a1785f3423c41e7b6c17c2c380c6b5975495b267..0208d706b8737135ce08210821dfce76bbd15261 100644 (file)
--- a/CryptoPkg/Library/BaseCryptLib/BaseCryptLib.inf
+++ b/CryptoPkg/Library/BaseCryptLib/BaseCryptLib.inf
@@ -54,6 +54,7 @@
   Pk/CryptRsaPss.c\r
   Pk/CryptRsaPssSign.c\r
   Pem/CryptPem.c\r
+  Bn/CryptBn.c\r
 \r
   SysCall/CrtWrapper.c\r
   SysCall/TimerWrapper.c\r

diff --git a/CryptoPkg/Library/BaseCryptLib/Bn/CryptBn.c b/CryptoPkg/Library/BaseCryptLib/Bn/CryptBn.c
new file mode 100644 (file)
index 0000000..282926d
--- /dev/null
+++ b/CryptoPkg/Library/BaseCryptLib/Bn/CryptBn.c
@@ -0,0 +1,581 @@
+/** @file  Big number API implementation based on OpenSSL\r
+\r
+  Copyright (c) 2022, Intel Corporation. All rights reserved.<BR>\r
+  SPDX-License-Identifier: BSD-2-Clause-Patent\r
+\r
+**/\r
+\r
+#include "InternalCryptLib.h"\r
+#include <openssl/bn.h>\r
+\r
+/**\r
+  Allocate new Big Number.\r
+\r
+  @retval New BigNum opaque structure or NULL on failure.\r
+**/\r
+VOID *\r
+EFIAPI\r
+BigNumInit (\r
+  VOID\r
+  )\r
+{\r
+  return BN_new ();\r
+}\r
+\r
+/**\r
+  Allocate new Big Number and assign the provided value to it.\r
+\r
+  @param[in]   Buf    Big endian encoded buffer.\r
+  @param[in]   Len    Buffer length.\r
+\r
+  @retval New BigNum opaque structure or NULL on failure.\r
+**/\r
+VOID *\r
+EFIAPI\r
+BigNumFromBin (\r
+  IN CONST UINT8  *Buf,\r
+  IN UINTN        Len\r
+  )\r
+{\r
+  return BN_bin2bn (Buf, (INT32)Len, NULL);\r
+}\r
+\r
+/**\r
+  Convert the absolute value of Bn into big-endian form and store it at Buf.\r
+  The Buf array should have at least BigNumBytes() in it.\r
+\r
+  @param[in]   Bn     Big number to convert.\r
+  @param[out]  Buf    Output buffer.\r
+\r
+  @retval The length of the big-endian number placed at Buf or -1 on error.\r
+**/\r
+INTN\r
+EFIAPI\r
+BigNumToBin (\r
+  IN CONST VOID  *Bn,\r
+  OUT UINT8      *Buf\r
+  )\r
+{\r
+  return BN_bn2bin (Bn, Buf);\r
+}\r
+\r
+/**\r
+  Free the Big Number.\r
+\r
+  @param[in]   Bn      Big number to free.\r
+  @param[in]   Clear   TRUE if the buffer should be cleared.\r
+**/\r
+VOID\r
+EFIAPI\r
+BigNumFree (\r
+  IN VOID     *Bn,\r
+  IN BOOLEAN  Clear\r
+  )\r
+{\r
+  if (Clear) {\r
+    BN_clear_free (Bn);\r
+  } else {\r
+    BN_free (Bn);\r
+  }\r
+}\r
+\r
+/**\r
+  Calculate the sum of two Big Numbers.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnB     Big number.\r
+  @param[out]  BnRes   The result of BnA + BnB.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumAdd (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  return (BOOLEAN)BN_add (BnRes, BnA, BnB);\r
+}\r
+\r
+/**\r
+  Subtract two Big Numbers.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnB     Big number.\r
+  @param[out]  BnRes   The result of BnA - BnB.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumSub (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  return (BOOLEAN)BN_sub (BnRes, BnA, BnB);\r
+}\r
+\r
+/**\r
+  Calculate remainder: BnRes = BnA % BnB.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnB     Big number.\r
+  @param[out]  BnRes   The result of BnA % BnB.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumMod (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  BOOLEAN  RetVal;\r
+  BN_CTX   *Ctx;\r
+\r
+  Ctx = BN_CTX_new ();\r
+  if (Ctx == NULL) {\r
+    return FALSE;\r
+  }\r
+\r
+  RetVal = (BOOLEAN)BN_mod (BnRes, BnA, BnB, Ctx);\r
+  BN_CTX_free (Ctx);\r
+\r
+  return RetVal;\r
+}\r
+\r
+/**\r
+  Compute BnA to the BnP-th power modulo BnM.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnP     Big number (power).\r
+  @param[in]   BnM     Big number (modulo).\r
+  @param[out]  BnRes   The result of (BnA ^ BnP) % BnM.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumExpMod (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnP,\r
+  IN CONST VOID  *BnM,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  BOOLEAN  RetVal;\r
+  BN_CTX   *Ctx;\r
+\r
+  Ctx = BN_CTX_new ();\r
+  if (Ctx == NULL) {\r
+    return FALSE;\r
+  }\r
+\r
+  RetVal = (BOOLEAN)BN_mod_exp (BnRes, BnA, BnP, BnM, Ctx);\r
+\r
+  BN_CTX_free (Ctx);\r
+  return RetVal;\r
+}\r
+\r
+/**\r
+  Compute BnA inverse modulo BnM.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnM     Big number (modulo).\r
+  @param[out]  BnRes   The result, such that (BnA * BnRes) % BnM == 1.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumInverseMod (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnM,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  BOOLEAN  RetVal;\r
+  BN_CTX   *Ctx;\r
+\r
+  Ctx = BN_CTX_new ();\r
+  if (Ctx == NULL) {\r
+    return FALSE;\r
+  }\r
+\r
+  RetVal = FALSE;\r
+  if (BN_mod_inverse (BnRes, BnA, BnM, Ctx) != NULL) {\r
+    RetVal = TRUE;\r
+  }\r
+\r
+  BN_CTX_free (Ctx);\r
+  return RetVal;\r
+}\r
+\r
+/**\r
+  Divide two Big Numbers.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnB     Big number.\r
+  @param[out]  BnRes   The result, such that BnA / BnB.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumDiv (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  BOOLEAN  RetVal;\r
+  BN_CTX   *Ctx;\r
+\r
+  Ctx = BN_CTX_new ();\r
+  if (Ctx == NULL) {\r
+    return FALSE;\r
+  }\r
+\r
+  RetVal = (BOOLEAN)BN_div (BnRes, NULL, BnA, BnB, Ctx);\r
+  BN_CTX_free (Ctx);\r
+\r
+  return RetVal;\r
+}\r
+\r
+/**\r
+  Multiply two Big Numbers modulo BnM.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnB     Big number.\r
+  @param[in]   BnM     Big number (modulo).\r
+  @param[out]  BnRes   The result, such that (BnA * BnB) % BnM.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumMulMod (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB,\r
+  IN CONST VOID  *BnM,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  BOOLEAN  RetVal;\r
+  BN_CTX   *Ctx;\r
+\r
+  Ctx = BN_CTX_new ();\r
+  if (Ctx == NULL) {\r
+    return FALSE;\r
+  }\r
+\r
+  RetVal = (BOOLEAN)BN_mod_mul (BnRes, BnA, BnB, BnM, Ctx);\r
+  BN_CTX_free (Ctx);\r
+\r
+  return RetVal;\r
+}\r
+\r
+/**\r
+  Compare two Big Numbers.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnB     Big number.\r
+\r
+  @retval 0          BnA == BnB.\r
+  @retval 1          BnA > BnB.\r
+  @retval -1         BnA < BnB.\r
+**/\r
+INTN\r
+EFIAPI\r
+BigNumCmp (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB\r
+  )\r
+{\r
+  return BN_cmp (BnA, BnB);\r
+}\r
+\r
+/**\r
+  Get number of bits in Bn.\r
+\r
+  @param[in]   Bn     Big number.\r
+\r
+  @retval Number of bits.\r
+**/\r
+UINTN\r
+EFIAPI\r
+BigNumBits (\r
+  IN CONST VOID  *Bn\r
+  )\r
+{\r
+  return BN_num_bits (Bn);\r
+}\r
+\r
+/**\r
+  Get number of bytes in Bn.\r
+\r
+  @param[in]   Bn     Big number.\r
+\r
+  @retval Number of bytes.\r
+**/\r
+UINTN\r
+EFIAPI\r
+BigNumBytes (\r
+  IN CONST VOID  *Bn\r
+  )\r
+{\r
+  return BN_num_bytes (Bn);\r
+}\r
+\r
+/**\r
+  Checks if Big Number equals to the given Num.\r
+\r
+  @param[in]   Bn     Big number.\r
+  @param[in]   Num    Number.\r
+\r
+  @retval TRUE   iff Bn == Num.\r
+  @retval FALSE  otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumIsWord (\r
+  IN CONST VOID  *Bn,\r
+  IN UINTN       Num\r
+  )\r
+{\r
+  return (BOOLEAN)BN_is_word (Bn, Num);\r
+}\r
+\r
+/**\r
+  Checks if Big Number is odd.\r
+\r
+  @param[in]   Bn     Big number.\r
+\r
+  @retval TRUE   Bn is odd (Bn % 2 == 1).\r
+  @retval FALSE  otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumIsOdd (\r
+  IN CONST VOID  *Bn\r
+  )\r
+{\r
+  return (BOOLEAN)BN_is_odd (Bn);\r
+}\r
+\r
+/**\r
+  Copy Big number.\r
+\r
+  @param[out]  BnDst     Destination.\r
+  @param[in]   BnSrc     Source.\r
+\r
+  @retval BnDst on success.\r
+  @retval NULL otherwise.\r
+**/\r
+VOID *\r
+EFIAPI\r
+BigNumCopy (\r
+  OUT VOID       *BnDst,\r
+  IN CONST VOID  *BnSrc\r
+  )\r
+{\r
+  return BN_copy (BnDst, BnSrc);\r
+}\r
+\r
+/**\r
+  Get constant Big number with value of "1".\r
+  This may be used to save expensive allocations.\r
+\r
+  @retval Big Number with value of 1.\r
+**/\r
+CONST VOID *\r
+EFIAPI\r
+BigNumValueOne (\r
+  VOID\r
+  )\r
+{\r
+  return BN_value_one ();\r
+}\r
+\r
+/**\r
+  Shift right Big Number.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   Bn      Big number.\r
+  @param[in]   N       Number of bits to shift.\r
+  @param[out]  BnRes   The result.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumRShift (\r
+  IN CONST VOID  *Bn,\r
+  IN UINTN       N,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  return (BOOLEAN)BN_rshift (BnRes, Bn, (INT32)N);\r
+}\r
+\r
+/**\r
+  Mark Big Number for constant time computations.\r
+  This function should be called before any constant time computations are\r
+  performed on the given Big number.\r
+\r
+  @param[in]   Bn     Big number\r
+**/\r
+VOID\r
+EFIAPI\r
+BigNumConstTime (\r
+  IN VOID  *Bn\r
+  )\r
+{\r
+  BN_set_flags (Bn, BN_FLG_CONSTTIME);\r
+}\r
+\r
+/**\r
+  Calculate square modulo.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnM     Big number (modulo).\r
+  @param[out]  BnRes   The result, such that (BnA ^ 2) % BnM.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumSqrMod (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnM,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  BOOLEAN  RetVal;\r
+  BN_CTX   *Ctx;\r
+\r
+  Ctx = BN_CTX_new ();\r
+  if (Ctx == NULL) {\r
+    return FALSE;\r
+  }\r
+\r
+  RetVal = (BOOLEAN)BN_mod_sqr (BnRes, BnA, BnM, Ctx);\r
+  BN_CTX_free (Ctx);\r
+\r
+  return RetVal;\r
+}\r
+\r
+/**\r
+  Create new Big Number computation context. This is an opaque structure\r
+  which should be passed to any function that requires it. The BN context is\r
+  needed to optimize calculations and expensive allocations.\r
+\r
+  @retval Big Number context struct or NULL on failure.\r
+**/\r
+VOID *\r
+EFIAPI\r
+BigNumNewContext (\r
+  VOID\r
+  )\r
+{\r
+  return BN_CTX_new ();\r
+}\r
+\r
+/**\r
+  Free Big Number context that was allocated with BigNumNewContext().\r
+\r
+  @param[in]   BnCtx     Big number context to free.\r
+**/\r
+VOID\r
+EFIAPI\r
+BigNumContextFree (\r
+  IN VOID  *BnCtx\r
+  )\r
+{\r
+  BN_CTX_free (BnCtx);\r
+}\r
+\r
+/**\r
+  Set Big Number to a given value.\r
+\r
+  @param[in]   Bn     Big number to set.\r
+  @param[in]   Val    Value to set.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumSetUint (\r
+  IN VOID   *Bn,\r
+  IN UINTN  Val\r
+  )\r
+{\r
+  return (BOOLEAN)BN_set_word (Bn, Val);\r
+}\r
+\r
+/**\r
+  Add two Big Numbers modulo BnM.\r
+\r
+  @param[in]   BnA       Big number.\r
+  @param[in]   BnB       Big number.\r
+  @param[in]   BnM       Big number (modulo).\r
+  @param[out]  BnRes     The result, such that (BnA + BnB) % BnM.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumAddMod (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB,\r
+  IN CONST VOID  *BnM,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  BOOLEAN  RetVal;\r
+  BN_CTX   *Ctx;\r
+\r
+  Ctx = BN_CTX_new ();\r
+  if (Ctx == NULL) {\r
+    return FALSE;\r
+  }\r
+\r
+  RetVal = (BOOLEAN)BN_mod_add (BnRes, BnA, BnB, BnM, Ctx);\r
+  BN_CTX_free (Ctx);\r
+\r
+  return RetVal;\r
+}\r

diff --git a/CryptoPkg/Library/BaseCryptLib/Bn/CryptBnNull.c b/CryptoPkg/Library/BaseCryptLib/Bn/CryptBnNull.c
new file mode 100644 (file)
index 0000000..547401f
--- /dev/null
+++ b/CryptoPkg/Library/BaseCryptLib/Bn/CryptBnNull.c
@@ -0,0 +1,520 @@
+/** @file\r
+  Big number API implementation based on OpenSSL\r
+\r
+  Copyright (c) 2022, Intel Corporation. All rights reserved.<BR>\r
+  SPDX-License-Identifier: BSD-2-Clause-Patent\r
+\r
+**/\r
+\r
+#include <Library/BaseCryptLib.h>\r
+#include <Library/DebugLib.h>\r
+\r
+/**\r
+  Allocate new Big Number.\r
+\r
+  @retval New BigNum opaque structure or NULL on failure.\r
+**/\r
+VOID *\r
+EFIAPI\r
+BigNumInit (\r
+  VOID\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return NULL;\r
+}\r
+\r
+/**\r
+  Allocate new Big Number and assign the provided value to it.\r
+\r
+  @param[in]   Buf    Big endian encoded buffer.\r
+  @param[in]   Len    Buffer length.\r
+\r
+  @retval New BigNum opaque structure or NULL on failure.\r
+**/\r
+VOID *\r
+EFIAPI\r
+BigNumFromBin (\r
+  IN CONST UINT8  *Buf,\r
+  IN UINTN        Len\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return NULL;\r
+}\r
+\r
+/**\r
+  Convert the absolute value of Bn into big-endian form and store it at Buf.\r
+  The Buf array should have at least BigNumBytes() in it.\r
+\r
+  @param[in]   Bn     Big number to convert.\r
+  @param[out]  Buf    Output buffer.\r
+\r
+  @retval The length of the big-endian number placed at Buf or -1 on error.\r
+**/\r
+INTN\r
+EFIAPI\r
+BigNumToBin (\r
+  IN CONST VOID  *Bn,\r
+  OUT UINT8      *Buf\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return -1;\r
+}\r
+\r
+/**\r
+  Free the Big Number.\r
+\r
+  @param[in]   Bn      Big number to free.\r
+  @param[in]   Clear   TRUE if the buffer should be cleared.\r
+**/\r
+VOID\r
+EFIAPI\r
+BigNumFree (\r
+  IN VOID     *Bn,\r
+  IN BOOLEAN  Clear\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+}\r
+\r
+/**\r
+  Calculate the sum of two Big Numbers.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnB     Big number.\r
+  @param[out]  BnRes   The result of BnA + BnB.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumAdd (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r
+\r
+/**\r
+  Subtract two Big Numbers.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnB     Big number.\r
+  @param[out]  BnRes   The result of BnA - BnB.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumSub (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r
+\r
+/**\r
+  Calculate remainder: BnRes = BnA % BnB.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnB     Big number.\r
+  @param[out]  BnRes   The result of BnA % BnB.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumMod (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r
+\r
+/**\r
+  Compute BnA to the BnP-th power modulo BnM.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnP     Big number (power).\r
+  @param[in]   BnM     Big number (modulo).\r
+  @param[out]  BnRes   The result of (BnA ^ BnP) % BnM.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumExpMod (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnP,\r
+  IN CONST VOID  *BnM,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r
+\r
+/**\r
+  Compute BnA inverse modulo BnM.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnM     Big number (modulo).\r
+  @param[out]  BnRes   The result, such that (BnA * BnRes) % BnM == 1.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumInverseMod (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnM,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r
+\r
+/**\r
+  Divide two Big Numbers.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnB     Big number.\r
+  @param[out]  BnRes   The result, such that BnA / BnB.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumDiv (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r
+\r
+/**\r
+  Multiply two Big Numbers modulo BnM.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnB     Big number.\r
+  @param[in]   BnM     Big number (modulo).\r
+  @param[out]  BnRes   The result, such that (BnA * BnB) % BnM.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumMulMod (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB,\r
+  IN CONST VOID  *BnM,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r
+\r
+/**\r
+  Compare two Big Numbers.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnB     Big number.\r
+\r
+  @retval 0          BnA == BnB.\r
+  @retval 1          BnA > BnB.\r
+  @retval -1         BnA < BnB.\r
+**/\r
+INTN\r
+EFIAPI\r
+BigNumCmp (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return 0;\r
+}\r
+\r
+/**\r
+  Get number of bits in Bn.\r
+\r
+  @param[in]   Bn     Big number.\r
+\r
+  @retval Number of bits.\r
+**/\r
+UINTN\r
+EFIAPI\r
+BigNumBits (\r
+  IN CONST VOID  *Bn\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return 0;\r
+}\r
+\r
+/**\r
+  Get number of bytes in Bn.\r
+\r
+  @param[in]   Bn     Big number.\r
+\r
+  @retval Number of bytes.\r
+**/\r
+UINTN\r
+EFIAPI\r
+BigNumBytes (\r
+  IN CONST VOID  *Bn\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return 0;\r
+}\r
+\r
+/**\r
+  Checks if Big Number equals to the given Num.\r
+\r
+  @param[in]   Bn     Big number.\r
+  @param[in]   Num    Number.\r
+\r
+  @retval TRUE   iff Bn == Num.\r
+  @retval FALSE  otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumIsWord (\r
+  IN CONST VOID  *Bn,\r
+  IN UINTN       Num\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r
+\r
+/**\r
+  Checks if Big Number is odd.\r
+\r
+  @param[in]   Bn     Big number.\r
+\r
+  @retval TRUE   Bn is odd (Bn % 2 == 1).\r
+  @retval FALSE  otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumIsOdd (\r
+  IN CONST VOID  *Bn\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r
+\r
+/**\r
+  Copy Big number.\r
+\r
+  @param[out]  BnDst     Destination.\r
+  @param[in]   BnSrc     Source.\r
+\r
+  @retval BnDst on success.\r
+  @retval NULL otherwise.\r
+**/\r
+VOID *\r
+EFIAPI\r
+BigNumCopy (\r
+  OUT VOID       *BnDst,\r
+  IN CONST VOID  *BnSrc\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return NULL;\r
+}\r
+\r
+/**\r
+  Get constant Big number with value of "1".\r
+  This may be used to save expensive allocations.\r
+\r
+  @retval Big Number with value of 1.\r
+**/\r
+CONST VOID *\r
+EFIAPI\r
+BigNumValueOne (\r
+  VOID\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return NULL;\r
+}\r
+\r
+/**\r
+  Shift right Big Number.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   Bn      Big number.\r
+  @param[in]   N       Number of bits to shift.\r
+  @param[out]  BnRes   The result.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumRShift (\r
+  IN CONST VOID  *Bn,\r
+  IN UINTN       N,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r
+\r
+/**\r
+  Mark Big Number for constant time computations.\r
+  This function should be called before any constant time computations are\r
+  performed on the given Big number.\r
+\r
+  @param[in]   Bn     Big number\r
+**/\r
+VOID\r
+EFIAPI\r
+BigNumConstTime (\r
+  IN VOID  *Bn\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+}\r
+\r
+/**\r
+  Calculate square modulo.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnM     Big number (modulo).\r
+  @param[out]  BnRes   The result, such that (BnA ^ 2) % BnM.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumSqrMod (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnM,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r
+\r
+/**\r
+  Create new Big Number computation context. This is an opaque structure\r
+  which should be passed to any function that requires it. The BN context is\r
+  needed to optimize calculations and expensive allocations.\r
+\r
+  @retval Big Number context struct or NULL on failure.\r
+**/\r
+VOID *\r
+EFIAPI\r
+BigNumNewContext (\r
+  VOID\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return NULL;\r
+}\r
+\r
+/**\r
+  Free Big Number context that was allocated with BigNumNewContext().\r
+\r
+  @param[in]   BnCtx     Big number context to free.\r
+**/\r
+VOID\r
+EFIAPI\r
+BigNumContextFree (\r
+  IN VOID  *BnCtx\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+}\r
+\r
+/**\r
+  Set Big Number to a given value.\r
+\r
+  @param[in]   Bn     Big number to set.\r
+  @param[in]   Val    Value to set.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumSetUint (\r
+  IN VOID   *Bn,\r
+  IN UINTN  Val\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r
+\r
+/**\r
+  Add two Big Numbers modulo BnM.\r
+\r
+  @param[in]   BnA       Big number.\r
+  @param[in]   BnB       Big number.\r
+  @param[in]   BnM       Big number (modulo).\r
+  @param[out]  BnRes     The result, such that (BnA + BnB) % BnM.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumAddMod (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB,\r
+  IN CONST VOID  *BnM,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r

diff --git a/CryptoPkg/Library/BaseCryptLib/PeiCryptLib.inf b/CryptoPkg/Library/BaseCryptLib/PeiCryptLib.inf
index 84efeb246e6919e1dd0e38c08f1198f0d12fc78b..82b97bc6d3055361969c27b5a4ab91711c1f25c5 100644 (file)
--- a/CryptoPkg/Library/BaseCryptLib/PeiCryptLib.inf
+++ b/CryptoPkg/Library/BaseCryptLib/PeiCryptLib.inf
@@ -61,6 +61,7 @@
   Pk/CryptRsaPssSignNull.c\r
   Pem/CryptPemNull.c\r
   Rand/CryptRandNull.c\r
+  Bn/CryptBnNull.c\r
 \r
   SysCall/CrtWrapper.c\r
   SysCall/ConstantTimeClock.c\r

diff --git a/CryptoPkg/Library/BaseCryptLib/SmmCryptLib.inf b/CryptoPkg/Library/BaseCryptLib/SmmCryptLib.inf
index c81e9d5bb4fc66ffe170d9f33b6b2ac6169d0576..986581319c867bc1f73da0e2be8b61e038a1bf43 100644 (file)
--- a/CryptoPkg/Library/BaseCryptLib/SmmCryptLib.inf
+++ b/CryptoPkg/Library/BaseCryptLib/SmmCryptLib.inf
@@ -61,6 +61,7 @@
   Pk/CryptRsaPss.c\r
   Pk/CryptRsaPssSignNull.c\r
   Pem/CryptPem.c\r
+  Bn/CryptBnNull.c\r
 \r
   SysCall/CrtWrapper.c\r
   SysCall/ConstantTimeClock.c\r

diff --git a/CryptoPkg/Library/BaseCryptLibNull/BaseCryptLibNull.inf b/CryptoPkg/Library/BaseCryptLibNull/BaseCryptLibNull.inf
index 80a432dfe111bbb70ebe2ea751a23a818a8f25bc..88ada0430d44c7d6edd4ea0433b52bbecc70f87b 100644 (file)
--- a/CryptoPkg/Library/BaseCryptLibNull/BaseCryptLibNull.inf
+++ b/CryptoPkg/Library/BaseCryptLibNull/BaseCryptLibNull.inf
@@ -54,6 +54,7 @@
   Rand/CryptRandNull.c\r
   Pk/CryptRsaPssNull.c\r
   Pk/CryptRsaPssSignNull.c\r
+  Bn/CryptBnNull.c\r
 \r
 [Packages]\r
   MdePkg/MdePkg.dec\r

diff --git a/CryptoPkg/Library/BaseCryptLibNull/Bn/CryptBnNull.c b/CryptoPkg/Library/BaseCryptLibNull/Bn/CryptBnNull.c
new file mode 100644 (file)
index 0000000..547401f
--- /dev/null
+++ b/CryptoPkg/Library/BaseCryptLibNull/Bn/CryptBnNull.c
@@ -0,0 +1,520 @@
+/** @file\r
+  Big number API implementation based on OpenSSL\r
+\r
+  Copyright (c) 2022, Intel Corporation. All rights reserved.<BR>\r
+  SPDX-License-Identifier: BSD-2-Clause-Patent\r
+\r
+**/\r
+\r
+#include <Library/BaseCryptLib.h>\r
+#include <Library/DebugLib.h>\r
+\r
+/**\r
+  Allocate new Big Number.\r
+\r
+  @retval New BigNum opaque structure or NULL on failure.\r
+**/\r
+VOID *\r
+EFIAPI\r
+BigNumInit (\r
+  VOID\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return NULL;\r
+}\r
+\r
+/**\r
+  Allocate new Big Number and assign the provided value to it.\r
+\r
+  @param[in]   Buf    Big endian encoded buffer.\r
+  @param[in]   Len    Buffer length.\r
+\r
+  @retval New BigNum opaque structure or NULL on failure.\r
+**/\r
+VOID *\r
+EFIAPI\r
+BigNumFromBin (\r
+  IN CONST UINT8  *Buf,\r
+  IN UINTN        Len\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return NULL;\r
+}\r
+\r
+/**\r
+  Convert the absolute value of Bn into big-endian form and store it at Buf.\r
+  The Buf array should have at least BigNumBytes() in it.\r
+\r
+  @param[in]   Bn     Big number to convert.\r
+  @param[out]  Buf    Output buffer.\r
+\r
+  @retval The length of the big-endian number placed at Buf or -1 on error.\r
+**/\r
+INTN\r
+EFIAPI\r
+BigNumToBin (\r
+  IN CONST VOID  *Bn,\r
+  OUT UINT8      *Buf\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return -1;\r
+}\r
+\r
+/**\r
+  Free the Big Number.\r
+\r
+  @param[in]   Bn      Big number to free.\r
+  @param[in]   Clear   TRUE if the buffer should be cleared.\r
+**/\r
+VOID\r
+EFIAPI\r
+BigNumFree (\r
+  IN VOID     *Bn,\r
+  IN BOOLEAN  Clear\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+}\r
+\r
+/**\r
+  Calculate the sum of two Big Numbers.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnB     Big number.\r
+  @param[out]  BnRes   The result of BnA + BnB.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumAdd (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r
+\r
+/**\r
+  Subtract two Big Numbers.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnB     Big number.\r
+  @param[out]  BnRes   The result of BnA - BnB.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumSub (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r
+\r
+/**\r
+  Calculate remainder: BnRes = BnA % BnB.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnB     Big number.\r
+  @param[out]  BnRes   The result of BnA % BnB.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumMod (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r
+\r
+/**\r
+  Compute BnA to the BnP-th power modulo BnM.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnP     Big number (power).\r
+  @param[in]   BnM     Big number (modulo).\r
+  @param[out]  BnRes   The result of (BnA ^ BnP) % BnM.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumExpMod (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnP,\r
+  IN CONST VOID  *BnM,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r
+\r
+/**\r
+  Compute BnA inverse modulo BnM.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnM     Big number (modulo).\r
+  @param[out]  BnRes   The result, such that (BnA * BnRes) % BnM == 1.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumInverseMod (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnM,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r
+\r
+/**\r
+  Divide two Big Numbers.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnB     Big number.\r
+  @param[out]  BnRes   The result, such that BnA / BnB.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumDiv (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r
+\r
+/**\r
+  Multiply two Big Numbers modulo BnM.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnB     Big number.\r
+  @param[in]   BnM     Big number (modulo).\r
+  @param[out]  BnRes   The result, such that (BnA * BnB) % BnM.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumMulMod (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB,\r
+  IN CONST VOID  *BnM,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r
+\r
+/**\r
+  Compare two Big Numbers.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnB     Big number.\r
+\r
+  @retval 0          BnA == BnB.\r
+  @retval 1          BnA > BnB.\r
+  @retval -1         BnA < BnB.\r
+**/\r
+INTN\r
+EFIAPI\r
+BigNumCmp (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return 0;\r
+}\r
+\r
+/**\r
+  Get number of bits in Bn.\r
+\r
+  @param[in]   Bn     Big number.\r
+\r
+  @retval Number of bits.\r
+**/\r
+UINTN\r
+EFIAPI\r
+BigNumBits (\r
+  IN CONST VOID  *Bn\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return 0;\r
+}\r
+\r
+/**\r
+  Get number of bytes in Bn.\r
+\r
+  @param[in]   Bn     Big number.\r
+\r
+  @retval Number of bytes.\r
+**/\r
+UINTN\r
+EFIAPI\r
+BigNumBytes (\r
+  IN CONST VOID  *Bn\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return 0;\r
+}\r
+\r
+/**\r
+  Checks if Big Number equals to the given Num.\r
+\r
+  @param[in]   Bn     Big number.\r
+  @param[in]   Num    Number.\r
+\r
+  @retval TRUE   iff Bn == Num.\r
+  @retval FALSE  otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumIsWord (\r
+  IN CONST VOID  *Bn,\r
+  IN UINTN       Num\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r
+\r
+/**\r
+  Checks if Big Number is odd.\r
+\r
+  @param[in]   Bn     Big number.\r
+\r
+  @retval TRUE   Bn is odd (Bn % 2 == 1).\r
+  @retval FALSE  otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumIsOdd (\r
+  IN CONST VOID  *Bn\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r
+\r
+/**\r
+  Copy Big number.\r
+\r
+  @param[out]  BnDst     Destination.\r
+  @param[in]   BnSrc     Source.\r
+\r
+  @retval BnDst on success.\r
+  @retval NULL otherwise.\r
+**/\r
+VOID *\r
+EFIAPI\r
+BigNumCopy (\r
+  OUT VOID       *BnDst,\r
+  IN CONST VOID  *BnSrc\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return NULL;\r
+}\r
+\r
+/**\r
+  Get constant Big number with value of "1".\r
+  This may be used to save expensive allocations.\r
+\r
+  @retval Big Number with value of 1.\r
+**/\r
+CONST VOID *\r
+EFIAPI\r
+BigNumValueOne (\r
+  VOID\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return NULL;\r
+}\r
+\r
+/**\r
+  Shift right Big Number.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   Bn      Big number.\r
+  @param[in]   N       Number of bits to shift.\r
+  @param[out]  BnRes   The result.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumRShift (\r
+  IN CONST VOID  *Bn,\r
+  IN UINTN       N,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r
+\r
+/**\r
+  Mark Big Number for constant time computations.\r
+  This function should be called before any constant time computations are\r
+  performed on the given Big number.\r
+\r
+  @param[in]   Bn     Big number\r
+**/\r
+VOID\r
+EFIAPI\r
+BigNumConstTime (\r
+  IN VOID  *Bn\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+}\r
+\r
+/**\r
+  Calculate square modulo.\r
+  Please note, all "out" Big number arguments should be properly initialized\r
+  by calling to BigNumInit() or BigNumFromBin() functions.\r
+\r
+  @param[in]   BnA     Big number.\r
+  @param[in]   BnM     Big number (modulo).\r
+  @param[out]  BnRes   The result, such that (BnA ^ 2) % BnM.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumSqrMod (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnM,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r
+\r
+/**\r
+  Create new Big Number computation context. This is an opaque structure\r
+  which should be passed to any function that requires it. The BN context is\r
+  needed to optimize calculations and expensive allocations.\r
+\r
+  @retval Big Number context struct or NULL on failure.\r
+**/\r
+VOID *\r
+EFIAPI\r
+BigNumNewContext (\r
+  VOID\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return NULL;\r
+}\r
+\r
+/**\r
+  Free Big Number context that was allocated with BigNumNewContext().\r
+\r
+  @param[in]   BnCtx     Big number context to free.\r
+**/\r
+VOID\r
+EFIAPI\r
+BigNumContextFree (\r
+  IN VOID  *BnCtx\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+}\r
+\r
+/**\r
+  Set Big Number to a given value.\r
+\r
+  @param[in]   Bn     Big number to set.\r
+  @param[in]   Val    Value to set.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumSetUint (\r
+  IN VOID   *Bn,\r
+  IN UINTN  Val\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r
+\r
+/**\r
+  Add two Big Numbers modulo BnM.\r
+\r
+  @param[in]   BnA       Big number.\r
+  @param[in]   BnB       Big number.\r
+  @param[in]   BnM       Big number (modulo).\r
+  @param[out]  BnRes     The result, such that (BnA + BnB) % BnM.\r
+\r
+  @retval TRUE          On success.\r
+  @retval FALSE         Otherwise.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+BigNumAddMod (\r
+  IN CONST VOID  *BnA,\r
+  IN CONST VOID  *BnB,\r
+  IN CONST VOID  *BnM,\r
+  OUT VOID       *BnRes\r
+  )\r
+{\r
+  ASSERT (FALSE);\r
+  return FALSE;\r
+}\r