Crypto.c

Go to the documentation of this file.

 
#include <Base.h>
#include <Library/DebugLib.h>
#include <Library/BaseCryptLib.h>
#include <Library/TlsLib.h>
#include <Protocol/Crypto.h>
#include <Pcd/PcdCryptoServiceFamilyEnable.h>
 
#define EDKII_CRYPTO_PCD  ((const PCD_CRYPTO_SERVICE_FAMILY_ENABLE *)\
  (FixedPcdGetPtr (PcdCryptoServiceFamilyEnable)))
 
#define CALL_BASECRYPTLIB(Enable, Function, Args, ErrorReturnValue) \
  EDKII_CRYPTO_PCD->Enable                                          \
    ? Function Args                                                 \
    : (BaseCryptLibServiceNotEnabled (#Function), ErrorReturnValue)
 
#define CALL_VOID_BASECRYPTLIB(Enable, Function, Args)  \
  EDKII_CRYPTO_PCD->Enable                              \
    ? Function Args                                     \
    : BaseCryptLibServiceNotEnabled (#Function)
 
static
VOID
BaseCryptLibServiceNotEnabled (
  IN CONST CHAR8  *FunctionName
  )
{
  DEBUG ((DEBUG_ERROR, "[%a] Function %a() is not enabled\n", gEfiCallerBaseName, FunctionName));
  ASSERT_EFI_ERROR (EFI_UNSUPPORTED);
}
 
static
VOID
BaseCryptLibServiceDeprecated (
  IN CONST CHAR8  *FunctionName
  )
{
  DEBUG ((DEBUG_ERROR, "[%a] Function %a() is deprecated and unsupported any longer\n", gEfiCallerBaseName, FunctionName));
  ASSERT_EFI_ERROR (EFI_UNSUPPORTED);
}
 
UINTN
EFIAPI
CryptoServiceGetCryptoVersion (
  VOID
  )
{
  return EDKII_CRYPTO_VERSION;
}
 
// =====================================================================================
//    One-Way Cryptographic Hash Primitives
// =====================================================================================
 
UINTN
EFIAPI
DeprecatedCryptoServiceMd4GetContextSize (
  VOID
  )
{
  return BaseCryptLibServiceDeprecated ("Md4GetContextSize"), 0;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceMd4Init (
  OUT  VOID  *Md4Context
  )
{
  return BaseCryptLibServiceDeprecated ("Md4Init"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceMd4Duplicate (
  IN   CONST VOID  *Md4Context,
  OUT  VOID        *NewMd4Context
  )
{
  return BaseCryptLibServiceDeprecated ("Md4Duplicate"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceMd4Update (
  IN OUT  VOID        *Md4Context,
  IN      CONST VOID  *Data,
  IN      UINTN       DataSize
  )
{
  return BaseCryptLibServiceDeprecated ("Md4Update"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceMd4Final (
  IN OUT  VOID   *Md4Context,
  OUT     UINT8  *HashValue
  )
{
  return BaseCryptLibServiceDeprecated ("Md4Final"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceMd4HashAll (
  IN   CONST VOID  *Data,
  IN   UINTN       DataSize,
  OUT  UINT8       *HashValue
  )
{
  return BaseCryptLibServiceDeprecated ("Md4HashAll"), FALSE;
}
 
#ifndef ENABLE_MD5_DEPRECATED_INTERFACES
 
UINTN
EFIAPI
DeprecatedCryptoServiceMd5GetContextSize (
  VOID
  )
{
  return BaseCryptLibServiceDeprecated ("Md5GetContextSize"), 0;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceMd5Init (
  OUT  VOID  *Md5Context
  )
{
  return BaseCryptLibServiceDeprecated ("Md5Init"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceMd5Duplicate (
  IN   CONST VOID  *Md5Context,
  OUT  VOID        *NewMd5Context
  )
{
  return BaseCryptLibServiceDeprecated ("Md5Init"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceMd5Update (
  IN OUT  VOID        *Md5Context,
  IN      CONST VOID  *Data,
  IN      UINTN       DataSize
  )
{
  return BaseCryptLibServiceDeprecated ("Md5Init"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceMd5Final (
  IN OUT  VOID   *Md5Context,
  OUT     UINT8  *HashValue
  )
{
  return BaseCryptLibServiceDeprecated ("Md5Final"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceMd5HashAll (
  IN   CONST VOID  *Data,
  IN   UINTN       DataSize,
  OUT  UINT8       *HashValue
  )
{
  return BaseCryptLibServiceDeprecated ("Md5HashAll"), FALSE;
}
 
#else
 
UINTN
EFIAPI
CryptoServiceMd5GetContextSize (
  VOID
  )
{
  return CALL_BASECRYPTLIB (Md5.Services.GetContextSize, Md5GetContextSize, (), 0);
}
 
BOOLEAN
EFIAPI
CryptoServiceMd5Init (
  OUT  VOID  *Md5Context
  )
{
  return CALL_BASECRYPTLIB (Md5.Services.Init, Md5Init, (Md5Context), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceMd5Duplicate (
  IN   CONST VOID  *Md5Context,
  OUT  VOID        *NewMd5Context
  )
{
  return CALL_BASECRYPTLIB (Md5.Services.Duplicate, Md5Duplicate, (Md5Context, NewMd5Context), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceMd5Update (
  IN OUT  VOID        *Md5Context,
  IN      CONST VOID  *Data,
  IN      UINTN       DataSize
  )
{
  return CALL_BASECRYPTLIB (Md5.Services.Update, Md5Update, (Md5Context, Data, DataSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceMd5Final (
  IN OUT  VOID   *Md5Context,
  OUT     UINT8  *HashValue
  )
{
  return CALL_BASECRYPTLIB (Md5.Services.Final, Md5Final, (Md5Context, HashValue), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceMd5HashAll (
  IN   CONST VOID  *Data,
  IN   UINTN       DataSize,
  OUT  UINT8       *HashValue
  )
{
  return CALL_BASECRYPTLIB (Md5.Services.HashAll, Md5HashAll, (Data, DataSize, HashValue), FALSE);
}
 
#endif
 
#ifdef DISABLE_SHA1_DEPRECATED_INTERFACES
 
UINTN
EFIAPI
DeprecatedCryptoServiceSha1GetContextSize (
  VOID
  )
{
  return BaseCryptLibServiceDeprecated ("Sha1GetContextSize"), 0;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceSha1Init (
  OUT  VOID  *Sha1Context
  )
{
  return BaseCryptLibServiceDeprecated ("Sha1Init"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceSha1Duplicate (
  IN   CONST VOID  *Sha1Context,
  OUT  VOID        *NewSha1Context
  )
{
  return BaseCryptLibServiceDeprecated ("Sha1Duplicate"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceSha1Update (
  IN OUT  VOID        *Sha1Context,
  IN      CONST VOID  *Data,
  IN      UINTN       DataSize
  )
{
  return BaseCryptLibServiceDeprecated ("Sha1Update"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceSha1Final (
  IN OUT  VOID   *Sha1Context,
  OUT     UINT8  *HashValue
  )
{
  return BaseCryptLibServiceDeprecated ("Sha1Final"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceSha1HashAll (
  IN   CONST VOID  *Data,
  IN   UINTN       DataSize,
  OUT  UINT8       *HashValue
  )
{
  return BaseCryptLibServiceDeprecated ("Sha1HashAll"), FALSE;
}
 
#else
 
UINTN
EFIAPI
CryptoServiceSha1GetContextSize (
  VOID
  )
{
  return CALL_BASECRYPTLIB (Sha1.Services.GetContextSize, Sha1GetContextSize, (), 0);
}
 
BOOLEAN
EFIAPI
CryptoServiceSha1Init (
  OUT  VOID  *Sha1Context
  )
{
  return CALL_BASECRYPTLIB (Sha1.Services.Init, Sha1Init, (Sha1Context), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceSha1Duplicate (
  IN   CONST VOID  *Sha1Context,
  OUT  VOID        *NewSha1Context
  )
{
  return CALL_BASECRYPTLIB (Sha1.Services.Duplicate, Sha1Duplicate, (Sha1Context, NewSha1Context), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceSha1Update (
  IN OUT  VOID        *Sha1Context,
  IN      CONST VOID  *Data,
  IN      UINTN       DataSize
  )
{
  return CALL_BASECRYPTLIB (Sha1.Services.Update, Sha1Update, (Sha1Context, Data, DataSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceSha1Final (
  IN OUT  VOID   *Sha1Context,
  OUT     UINT8  *HashValue
  )
{
  return CALL_BASECRYPTLIB (Sha1.Services.Final, Sha1Final, (Sha1Context, HashValue), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceSha1HashAll (
  IN   CONST VOID  *Data,
  IN   UINTN       DataSize,
  OUT  UINT8       *HashValue
  )
{
  return CALL_BASECRYPTLIB (Sha1.Services.HashAll, Sha1HashAll, (Data, DataSize, HashValue), FALSE);
}
 
#endif
 
UINTN
EFIAPI
CryptoServiceSha256GetContextSize (
  VOID
  )
{
  return CALL_BASECRYPTLIB (Sha256.Services.GetContextSize, Sha256GetContextSize, (), 0);
}
 
BOOLEAN
EFIAPI
CryptoServiceSha256Init (
  OUT  VOID  *Sha256Context
  )
{
  return CALL_BASECRYPTLIB (Sha256.Services.Init, Sha256Init, (Sha256Context), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceSha256Duplicate (
  IN   CONST VOID  *Sha256Context,
  OUT  VOID        *NewSha256Context
  )
{
  return CALL_BASECRYPTLIB (Sha256.Services.Duplicate, Sha256Duplicate, (Sha256Context, NewSha256Context), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceSha256Update (
  IN OUT  VOID        *Sha256Context,
  IN      CONST VOID  *Data,
  IN      UINTN       DataSize
  )
{
  return CALL_BASECRYPTLIB (Sha256.Services.Update, Sha256Update, (Sha256Context, Data, DataSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceSha256Final (
  IN OUT  VOID   *Sha256Context,
  OUT     UINT8  *HashValue
  )
{
  return CALL_BASECRYPTLIB (Sha256.Services.Final, Sha256Final, (Sha256Context, HashValue), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceSha256HashAll (
  IN   CONST VOID  *Data,
  IN   UINTN       DataSize,
  OUT  UINT8       *HashValue
  )
{
  return CALL_BASECRYPTLIB (Sha256.Services.HashAll, Sha256HashAll, (Data, DataSize, HashValue), FALSE);
}
 
UINTN
EFIAPI
CryptoServiceSha384GetContextSize (
  VOID
  )
{
  return CALL_BASECRYPTLIB (Sha384.Services.GetContextSize, Sha384GetContextSize, (), 0);
}
 
BOOLEAN
EFIAPI
CryptoServiceSha384Init (
  OUT  VOID  *Sha384Context
  )
{
  return CALL_BASECRYPTLIB (Sha384.Services.Init, Sha384Init, (Sha384Context), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceSha384Duplicate (
  IN   CONST VOID  *Sha384Context,
  OUT  VOID        *NewSha384Context
  )
{
  return CALL_BASECRYPTLIB (Sha384.Services.Duplicate, Sha384Duplicate, (Sha384Context, NewSha384Context), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceSha384Update (
  IN OUT  VOID        *Sha384Context,
  IN      CONST VOID  *Data,
  IN      UINTN       DataSize
  )
{
  return CALL_BASECRYPTLIB (Sha384.Services.Update, Sha384Update, (Sha384Context, Data, DataSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceSha384Final (
  IN OUT  VOID   *Sha384Context,
  OUT     UINT8  *HashValue
  )
{
  return CALL_BASECRYPTLIB (Sha384.Services.Final, Sha384Final, (Sha384Context, HashValue), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceSha384HashAll (
  IN   CONST VOID  *Data,
  IN   UINTN       DataSize,
  OUT  UINT8       *HashValue
  )
{
  return CALL_BASECRYPTLIB (Sha384.Services.HashAll, Sha384HashAll, (Data, DataSize, HashValue), FALSE);
}
 
UINTN
EFIAPI
CryptoServiceSha512GetContextSize (
  VOID
  )
{
  return CALL_BASECRYPTLIB (Sha512.Services.GetContextSize, Sha512GetContextSize, (), 0);
}
 
BOOLEAN
EFIAPI
CryptoServiceSha512Init (
  OUT  VOID  *Sha512Context
  )
{
  return CALL_BASECRYPTLIB (Sha512.Services.Init, Sha512Init, (Sha512Context), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceSha512Duplicate (
  IN   CONST VOID  *Sha512Context,
  OUT  VOID        *NewSha512Context
  )
{
  return CALL_BASECRYPTLIB (Sha512.Services.Duplicate, Sha512Duplicate, (Sha512Context, NewSha512Context), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceSha512Update (
  IN OUT  VOID        *Sha512Context,
  IN      CONST VOID  *Data,
  IN      UINTN       DataSize
  )
{
  return CALL_BASECRYPTLIB (Sha512.Services.Update, Sha512Update, (Sha512Context, Data, DataSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceSha512Final (
  IN OUT  VOID   *Sha512Context,
  OUT     UINT8  *HashValue
  )
{
  return CALL_BASECRYPTLIB (Sha512.Services.Final, Sha512Final, (Sha512Context, HashValue), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceSha512HashAll (
  IN   CONST VOID  *Data,
  IN   UINTN       DataSize,
  OUT  UINT8       *HashValue
  )
{
  return CALL_BASECRYPTLIB (Sha512.Services.HashAll, Sha512HashAll, (Data, DataSize, HashValue), FALSE);
}
 
UINTN
EFIAPI
CryptoServiceSm3GetContextSize (
  VOID
  )
{
  return CALL_BASECRYPTLIB (Sm3.Services.GetContextSize, Sm3GetContextSize, (), 0);
}
 
BOOLEAN
EFIAPI
CryptoServiceSm3Init (
  OUT  VOID  *Sm3Context
  )
{
  return CALL_BASECRYPTLIB (Sm3.Services.Init, Sm3Init, (Sm3Context), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceSm3Duplicate (
  IN   CONST VOID  *Sm3Context,
  OUT  VOID        *NewSm3Context
  )
{
  return CALL_BASECRYPTLIB (Sm3.Services.Duplicate, Sm3Duplicate, (Sm3Context, NewSm3Context), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceSm3Update (
  IN OUT  VOID        *Sm3Context,
  IN      CONST VOID  *Data,
  IN      UINTN       DataSize
  )
{
  return CALL_BASECRYPTLIB (Sm3.Services.Update, Sm3Update, (Sm3Context, Data, DataSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceSm3Final (
  IN OUT  VOID   *Sm3Context,
  OUT     UINT8  *HashValue
  )
{
  return CALL_BASECRYPTLIB (Sm3.Services.Final, Sm3Final, (Sm3Context, HashValue), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceSm3HashAll (
  IN   CONST VOID  *Data,
  IN   UINTN       DataSize,
  OUT  UINT8       *HashValue
  )
{
  return CALL_BASECRYPTLIB (Sm3.Services.HashAll, Sm3HashAll, (Data, DataSize, HashValue), FALSE);
}
 
// =====================================================================================
//    MAC (Message Authentication Code) Primitive
// =====================================================================================
 
VOID *
EFIAPI
DeprecatedCryptoServiceHmacMd5New (
  VOID
  )
{
  return BaseCryptLibServiceDeprecated ("HmacMd5New"), NULL;
}
 
VOID
EFIAPI
DeprecatedCryptoServiceHmacMd5Free (
  IN  VOID  *HmacMd5Ctx
  )
{
  BaseCryptLibServiceDeprecated ("HmacMd5Free");
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceHmacMd5SetKey (
  OUT  VOID         *HmacMd5Context,
  IN   CONST UINT8  *Key,
  IN   UINTN        KeySize
  )
{
  return BaseCryptLibServiceDeprecated ("HmacMd5SetKey"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceHmacMd5Duplicate (
  IN   CONST VOID  *HmacMd5Context,
  OUT  VOID        *NewHmacMd5Context
  )
{
  return BaseCryptLibServiceDeprecated ("HmacMd5Duplicate"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceHmacMd5Update (
  IN OUT  VOID        *HmacMd5Context,
  IN      CONST VOID  *Data,
  IN      UINTN       DataSize
  )
{
  return BaseCryptLibServiceDeprecated ("HmacMd5Update"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceHmacMd5Final (
  IN OUT  VOID   *HmacMd5Context,
  OUT     UINT8  *HmacValue
  )
{
  return BaseCryptLibServiceDeprecated ("HmacMd5Final"), FALSE;
}
 
VOID *
EFIAPI
DeprecatedCryptoServiceHmacSha1New (
  VOID
  )
{
  return BaseCryptLibServiceDeprecated ("HmacSha1New"), NULL;
}
 
VOID
EFIAPI
DeprecatedCryptoServiceHmacSha1Free (
  IN  VOID  *HmacSha1Ctx
  )
{
  BaseCryptLibServiceDeprecated ("HmacSha1Free");
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceHmacSha1SetKey (
  OUT  VOID         *HmacSha1Context,
  IN   CONST UINT8  *Key,
  IN   UINTN        KeySize
  )
{
  return BaseCryptLibServiceDeprecated ("HmacSha1SetKey"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceHmacSha1Duplicate (
  IN   CONST VOID  *HmacSha1Context,
  OUT  VOID        *NewHmacSha1Context
  )
{
  return BaseCryptLibServiceDeprecated ("HmacSha1Duplicate"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceHmacSha1Update (
  IN OUT  VOID        *HmacSha1Context,
  IN      CONST VOID  *Data,
  IN      UINTN       DataSize
  )
{
  return BaseCryptLibServiceDeprecated ("HmacSha1Update"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceHmacSha1Final (
  IN OUT  VOID   *HmacSha1Context,
  OUT     UINT8  *HmacValue
  )
{
  return BaseCryptLibServiceDeprecated ("HmacSha1Final"), FALSE;
}
 
VOID *
EFIAPI
CryptoServiceHmacSha256New (
  VOID
  )
{
  return CALL_BASECRYPTLIB (HmacSha256.Services.New, HmacSha256New, (), NULL);
}
 
VOID
EFIAPI
CryptoServiceHmacSha256Free (
  IN  VOID  *HmacSha256Ctx
  )
{
  CALL_VOID_BASECRYPTLIB (HmacSha256.Services.Free, HmacSha256Free, (HmacSha256Ctx));
}
 
BOOLEAN
EFIAPI
CryptoServiceHmacSha256SetKey (
  OUT  VOID         *HmacSha256Context,
  IN   CONST UINT8  *Key,
  IN   UINTN        KeySize
  )
{
  return CALL_BASECRYPTLIB (HmacSha256.Services.SetKey, HmacSha256SetKey, (HmacSha256Context, Key, KeySize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceHmacSha256Duplicate (
  IN   CONST VOID  *HmacSha256Context,
  OUT  VOID        *NewHmacSha256Context
  )
{
  return CALL_BASECRYPTLIB (HmacSha256.Services.Duplicate, HmacSha256Duplicate, (HmacSha256Context, NewHmacSha256Context), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceHmacSha256Update (
  IN OUT  VOID        *HmacSha256Context,
  IN      CONST VOID  *Data,
  IN      UINTN       DataSize
  )
{
  return CALL_BASECRYPTLIB (HmacSha256.Services.Update, HmacSha256Update, (HmacSha256Context, Data, DataSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceHmacSha256Final (
  IN OUT  VOID   *HmacSha256Context,
  OUT     UINT8  *HmacValue
  )
{
  return CALL_BASECRYPTLIB (HmacSha256.Services.Final, HmacSha256Final, (HmacSha256Context, HmacValue), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceHmacSha256All (
  IN   CONST VOID   *Data,
  IN   UINTN        DataSize,
  IN   CONST UINT8  *Key,
  IN   UINTN        KeySize,
  OUT  UINT8        *HmacValue
  )
{
  return CALL_BASECRYPTLIB (HmacSha256.Services.All, HmacSha256All, (Data, DataSize, Key, KeySize, HmacValue), FALSE);
}
 
VOID *
EFIAPI
CryptoServiceHmacSha384New (
  VOID
  )
{
  return CALL_BASECRYPTLIB (HmacSha384.Services.New, HmacSha384New, (), NULL);
}
 
VOID
EFIAPI
CryptoServiceHmacSha384Free (
  IN  VOID  *HmacSha384Ctx
  )
{
  CALL_VOID_BASECRYPTLIB (HmacSha384.Services.Free, HmacSha384Free, (HmacSha384Ctx));
}
 
BOOLEAN
EFIAPI
CryptoServiceHmacSha384SetKey (
  OUT  VOID         *HmacSha384Context,
  IN   CONST UINT8  *Key,
  IN   UINTN        KeySize
  )
{
  return CALL_BASECRYPTLIB (HmacSha384.Services.SetKey, HmacSha384SetKey, (HmacSha384Context, Key, KeySize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceHmacSha384Duplicate (
  IN   CONST VOID  *HmacSha384Context,
  OUT  VOID        *NewHmacSha384Context
  )
{
  return CALL_BASECRYPTLIB (HmacSha384.Services.Duplicate, HmacSha256Duplicate, (HmacSha384Context, NewHmacSha384Context), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceHmacSha384Update (
  IN OUT  VOID        *HmacSha384Context,
  IN      CONST VOID  *Data,
  IN      UINTN       DataSize
  )
{
  return CALL_BASECRYPTLIB (HmacSha384.Services.Update, HmacSha384Update, (HmacSha384Context, Data, DataSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceHmacSha384Final (
  IN OUT  VOID   *HmacSha384Context,
  OUT     UINT8  *HmacValue
  )
{
  return CALL_BASECRYPTLIB (HmacSha384.Services.Final, HmacSha384Final, (HmacSha384Context, HmacValue), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceHmacSha384All (
  IN   CONST VOID   *Data,
  IN   UINTN        DataSize,
  IN   CONST UINT8  *Key,
  IN   UINTN        KeySize,
  OUT  UINT8        *HmacValue
  )
{
  return CALL_BASECRYPTLIB (HmacSha384.Services.All, HmacSha384All, (Data, DataSize, Key, KeySize, HmacValue), FALSE);
}
 
// =====================================================================================
//    Symmetric Cryptography Primitive
// =====================================================================================
 
UINTN
EFIAPI
DeprecatedCryptoServiceTdesGetContextSize (
  VOID
  )
{
  return BaseCryptLibServiceDeprecated ("TdesGetContextSize"), 0;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceTdesInit (
  OUT  VOID         *TdesContext,
  IN   CONST UINT8  *Key,
  IN   UINTN        KeyLength
  )
{
  return BaseCryptLibServiceDeprecated ("TdesInit"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceTdesEcbEncrypt (
  IN   VOID         *TdesContext,
  IN   CONST UINT8  *Input,
  IN   UINTN        InputSize,
  OUT  UINT8        *Output
  )
{
  return BaseCryptLibServiceDeprecated ("TdesEcbEncrypt"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceTdesEcbDecrypt (
  IN   VOID         *TdesContext,
  IN   CONST UINT8  *Input,
  IN   UINTN        InputSize,
  OUT  UINT8        *Output
  )
{
  return BaseCryptLibServiceDeprecated ("TdesEcbDecrypt"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceTdesCbcEncrypt (
  IN   VOID         *TdesContext,
  IN   CONST UINT8  *Input,
  IN   UINTN        InputSize,
  IN   CONST UINT8  *Ivec,
  OUT  UINT8        *Output
  )
{
  return BaseCryptLibServiceDeprecated ("TdesCbcEncrypt"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceTdesCbcDecrypt (
  IN   VOID         *TdesContext,
  IN   CONST UINT8  *Input,
  IN   UINTN        InputSize,
  IN   CONST UINT8  *Ivec,
  OUT  UINT8        *Output
  )
{
  return BaseCryptLibServiceDeprecated ("TdesCbcDecrypt"), FALSE;
}
 
UINTN
EFIAPI
CryptoServiceAesGetContextSize (
  VOID
  )
{
  return CALL_BASECRYPTLIB (Aes.Services.GetContextSize, AesGetContextSize, (), 0);
}
 
BOOLEAN
EFIAPI
CryptoServiceAesInit (
  OUT  VOID         *AesContext,
  IN   CONST UINT8  *Key,
  IN   UINTN        KeyLength
  )
{
  return CALL_BASECRYPTLIB (Aes.Services.Init, AesInit, (AesContext, Key, KeyLength), FALSE);
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceAesEcbEncrypt (
  IN   VOID         *AesContext,
  IN   CONST UINT8  *Input,
  IN   UINTN        InputSize,
  OUT  UINT8        *Output
  )
{
  return BaseCryptLibServiceDeprecated ("AesEcbEncrypt"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceAesEcbDecrypt (
  IN   VOID         *AesContext,
  IN   CONST UINT8  *Input,
  IN   UINTN        InputSize,
  OUT  UINT8        *Output
  )
{
  return BaseCryptLibServiceDeprecated ("AesEcbDecrypt"), FALSE;
}
 
BOOLEAN
EFIAPI
CryptoServiceAesCbcEncrypt (
  IN   VOID         *AesContext,
  IN   CONST UINT8  *Input,
  IN   UINTN        InputSize,
  IN   CONST UINT8  *Ivec,
  OUT  UINT8        *Output
  )
{
  return CALL_BASECRYPTLIB (Aes.Services.CbcEncrypt, AesCbcEncrypt, (AesContext, Input, InputSize, Ivec, Output), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceAesCbcDecrypt (
  IN   VOID         *AesContext,
  IN   CONST UINT8  *Input,
  IN   UINTN        InputSize,
  IN   CONST UINT8  *Ivec,
  OUT  UINT8        *Output
  )
{
  return CALL_BASECRYPTLIB (Aes.Services.CbcDecrypt, AesCbcDecrypt, (AesContext, Input, InputSize, Ivec, Output), FALSE);
}
 
UINTN
EFIAPI
DeprecatedCryptoServiceArc4GetContextSize (
  VOID
  )
{
  return BaseCryptLibServiceDeprecated ("Arc4GetContextSize"), 0;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceArc4Init (
  OUT  VOID         *Arc4Context,
  IN   CONST UINT8  *Key,
  IN   UINTN        KeySize
  )
{
  return BaseCryptLibServiceDeprecated ("Arc4Init"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceArc4Encrypt (
  IN OUT  VOID         *Arc4Context,
  IN      CONST UINT8  *Input,
  IN      UINTN        InputSize,
  OUT     UINT8        *Output
  )
{
  return BaseCryptLibServiceDeprecated ("Arc4Encrypt"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceArc4Decrypt (
  IN OUT  VOID   *Arc4Context,
  IN      UINT8  *Input,
  IN      UINTN  InputSize,
  OUT     UINT8  *Output
  )
{
  return BaseCryptLibServiceDeprecated ("Arc4Decrypt"), FALSE;
}
 
BOOLEAN
EFIAPI
DeprecatedCryptoServiceArc4Reset (
  IN OUT  VOID  *Arc4Context
  )
{
  return BaseCryptLibServiceDeprecated ("Arc4Reset"), FALSE;
}
 
// =====================================================================================
//    Asymmetric Cryptography Primitive
// =====================================================================================
 
VOID *
EFIAPI
CryptoServiceRsaNew (
  VOID
  )
{
  return CALL_BASECRYPTLIB (Rsa.Services.New, RsaNew, (), NULL);
}
 
VOID
EFIAPI
CryptoServiceRsaFree (
  IN  VOID  *RsaContext
  )
{
  CALL_VOID_BASECRYPTLIB (Rsa.Services.Free, RsaFree, (RsaContext));
}
 
BOOLEAN
EFIAPI
CryptoServiceRsaSetKey (
  IN OUT  VOID         *RsaContext,
  IN      RSA_KEY_TAG  KeyTag,
  IN      CONST UINT8  *BigNumber,
  IN      UINTN        BnSize
  )
{
  return CALL_BASECRYPTLIB (Rsa.Services.SetKey, RsaSetKey, (RsaContext, KeyTag, BigNumber, BnSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceRsaGetKey (
  IN OUT  VOID         *RsaContext,
  IN      RSA_KEY_TAG  KeyTag,
  OUT     UINT8        *BigNumber,
  IN OUT  UINTN        *BnSize
  )
{
  return CALL_BASECRYPTLIB (Rsa.Services.GetKey, RsaGetKey, (RsaContext, KeyTag, BigNumber, BnSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceRsaGenerateKey (
  IN OUT  VOID         *RsaContext,
  IN      UINTN        ModulusLength,
  IN      CONST UINT8  *PublicExponent,
  IN      UINTN        PublicExponentSize
  )
{
  return CALL_BASECRYPTLIB (Rsa.Services.GenerateKey, RsaGenerateKey, (RsaContext, ModulusLength, PublicExponent, PublicExponentSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceRsaCheckKey (
  IN  VOID  *RsaContext
  )
{
  return CALL_BASECRYPTLIB (Rsa.Services.CheckKey, RsaCheckKey, (RsaContext), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceRsaPkcs1Sign (
  IN      VOID         *RsaContext,
  IN      CONST UINT8  *MessageHash,
  IN      UINTN        HashSize,
  OUT     UINT8        *Signature,
  IN OUT  UINTN        *SigSize
  )
{
  return CALL_BASECRYPTLIB (Rsa.Services.Pkcs1Sign, RsaPkcs1Sign, (RsaContext, MessageHash, HashSize, Signature, SigSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceRsaPkcs1Verify (
  IN  VOID         *RsaContext,
  IN  CONST UINT8  *MessageHash,
  IN  UINTN        HashSize,
  IN  CONST UINT8  *Signature,
  IN  UINTN        SigSize
  )
{
  return CALL_BASECRYPTLIB (Rsa.Services.Pkcs1Verify, RsaPkcs1Verify, (RsaContext, MessageHash, HashSize, Signature, SigSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceRsaGetPrivateKeyFromPem (
  IN   CONST UINT8  *PemData,
  IN   UINTN        PemSize,
  IN   CONST CHAR8  *Password,
  OUT  VOID         **RsaContext
  )
{
  return CALL_BASECRYPTLIB (Rsa.Services.GetPrivateKeyFromPem, RsaGetPrivateKeyFromPem, (PemData, PemSize, Password, RsaContext), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceRsaGetPublicKeyFromX509 (
  IN   CONST UINT8  *Cert,
  IN   UINTN        CertSize,
  OUT  VOID         **RsaContext
  )
{
  return CALL_BASECRYPTLIB (Rsa.Services.GetPublicKeyFromX509, RsaGetPublicKeyFromX509, (Cert, CertSize, RsaContext), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceX509GetSubjectName (
  IN      CONST UINT8  *Cert,
  IN      UINTN        CertSize,
  OUT     UINT8        *CertSubject,
  IN OUT  UINTN        *SubjectSize
  )
{
  return CALL_BASECRYPTLIB (X509.Services.GetSubjectName, X509GetSubjectName, (Cert, CertSize, CertSubject, SubjectSize), FALSE);
}
 
RETURN_STATUS
EFIAPI
CryptoServiceX509GetCommonName (
  IN      CONST UINT8  *Cert,
  IN      UINTN        CertSize,
  OUT     CHAR8        *CommonName   OPTIONAL,
  IN OUT  UINTN        *CommonNameSize
  )
{
  return CALL_BASECRYPTLIB (X509.Services.GetCommonName, X509GetCommonName, (Cert, CertSize, CommonName, CommonNameSize), RETURN_UNSUPPORTED);
}
 
RETURN_STATUS
EFIAPI
CryptoServiceX509GetOrganizationName (
  IN      CONST UINT8  *Cert,
  IN      UINTN        CertSize,
  OUT     CHAR8        *NameBuffer   OPTIONAL,
  IN OUT  UINTN        *NameBufferSize
  )
{
  return CALL_BASECRYPTLIB (X509.Services.GetOrganizationName, X509GetOrganizationName, (Cert, CertSize, NameBuffer, NameBufferSize), RETURN_UNSUPPORTED);
}
 
BOOLEAN
EFIAPI
CryptoServiceX509VerifyCert (
  IN  CONST UINT8  *Cert,
  IN  UINTN        CertSize,
  IN  CONST UINT8  *CACert,
  IN  UINTN        CACertSize
  )
{
  return CALL_BASECRYPTLIB (X509.Services.VerifyCert, X509VerifyCert, (Cert, CertSize, CACert, CACertSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceX509ConstructCertificate (
  IN   CONST UINT8  *Cert,
  IN   UINTN        CertSize,
  OUT  UINT8        **SingleX509Cert
  )
{
  return CALL_BASECRYPTLIB (X509.Services.ConstructCertificate, X509ConstructCertificate, (Cert, CertSize, SingleX509Cert), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceX509ConstructCertificateStackV (
  IN OUT  UINT8    **X509Stack,
  IN      VA_LIST  Args
  )
{
  return CALL_BASECRYPTLIB (X509.Services.ConstructCertificateStackV, X509ConstructCertificateStackV, (X509Stack, Args), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceX509ConstructCertificateStack (
  IN OUT  UINT8  **X509Stack,
  ...
  )
{
  VA_LIST  Args;
  BOOLEAN  Result;
 
  VA_START (Args, X509Stack);
  Result = CryptoServiceX509ConstructCertificateStackV (X509Stack, Args);
  VA_END (Args);
  return Result;
}
 
VOID
EFIAPI
CryptoServiceX509Free (
  IN  VOID  *X509Cert
  )
{
  CALL_VOID_BASECRYPTLIB (X509.Services.Free, X509Free, (X509Cert));
}
 
VOID
EFIAPI
CryptoServiceX509StackFree (
  IN  VOID  *X509Stack
  )
{
  CALL_VOID_BASECRYPTLIB (X509.Services.StackFree, X509StackFree, (X509Stack));
}
 
BOOLEAN
EFIAPI
CryptoServiceX509GetTBSCert (
  IN  CONST UINT8  *Cert,
  IN  UINTN        CertSize,
  OUT UINT8        **TBSCert,
  OUT UINTN        *TBSCertSize
  )
{
  return CALL_BASECRYPTLIB (X509.Services.GetTBSCert, X509GetTBSCert, (Cert, CertSize, TBSCert, TBSCertSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceX509GetVersion (
  IN      CONST UINT8  *Cert,
  IN      UINTN        CertSize,
  OUT     UINTN        *Version
  )
{
  return CALL_BASECRYPTLIB (X509.Services.GetVersion, X509GetVersion, (Cert, CertSize, Version), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceX509GetSerialNumber (
  IN      CONST UINT8 *Cert,
  IN      UINTN CertSize,
  OUT     UINT8 *SerialNumber, OPTIONAL
  IN OUT  UINTN         *SerialNumberSize
  )
{
  return CALL_BASECRYPTLIB (X509.Services.GetSerialNumber, X509GetSerialNumber, (Cert, CertSize, SerialNumber, SerialNumberSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceX509GetIssuerName (
  IN      CONST UINT8  *Cert,
  IN      UINTN        CertSize,
  OUT     UINT8        *CertIssuer,
  IN OUT  UINTN        *CertIssuerSize
  )
{
  return CALL_BASECRYPTLIB (X509.Services.GetIssuerName, X509GetIssuerName, (Cert, CertSize, CertIssuer, CertIssuerSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceX509GetSignatureAlgorithm (
  IN CONST UINT8 *Cert,
  IN       UINTN CertSize,
  OUT   UINT8 *Oid, OPTIONAL
  IN OUT   UINTN       *OidSize
  )
{
  return CALL_BASECRYPTLIB (X509.Services.GetSignatureAlgorithm, X509GetSignatureAlgorithm, (Cert, CertSize, Oid, OidSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceX509GetExtensionData (
  IN     CONST UINT8  *Cert,
  IN     UINTN        CertSize,
  IN     CONST UINT8  *Oid,
  IN     UINTN        OidSize,
  OUT UINT8           *ExtensionData,
  IN OUT UINTN        *ExtensionDataSize
  )
{
  return CALL_BASECRYPTLIB (X509.Services.GetExtensionData, X509GetExtensionData, (Cert, CertSize, Oid, OidSize, ExtensionData, ExtensionDataSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceX509GetExtendedKeyUsage (
  IN     CONST UINT8  *Cert,
  IN     UINTN        CertSize,
  OUT UINT8           *Usage,
  IN OUT UINTN        *UsageSize
  )
{
  return CALL_BASECRYPTLIB (X509.Services.GetExtendedKeyUsage, X509GetExtendedKeyUsage, (Cert, CertSize, Usage, UsageSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceX509GetValidity  (
  IN     CONST UINT8  *Cert,
  IN     UINTN        CertSize,
  IN     UINT8        *From,
  IN OUT UINTN        *FromSize,
  IN     UINT8        *To,
  IN OUT UINTN        *ToSize
  )
{
  return CALL_BASECRYPTLIB (X509.Services.GetValidity, X509GetValidity, (Cert, CertSize, From, FromSize, To, ToSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceX509FormatDateTime (
  IN CONST CHAR8  *DateTimeStr,
  OUT VOID        *DateTime,
  IN OUT UINTN    *DateTimeSize
  )
{
  return CALL_BASECRYPTLIB (X509.Services.FormatDateTime, X509FormatDateTime, (DateTimeStr, DateTime, DateTimeSize), FALSE);
}
 
INT32
EFIAPI
CryptoServiceX509CompareDateTime (
  IN  CONST VOID  *DateTime1,
  IN  CONST VOID  *DateTime2
  )
{
  return CALL_BASECRYPTLIB (X509.Services.CompareDateTime, X509CompareDateTime, (DateTime1, DateTime2), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceX509GetKeyUsage (
  IN    CONST UINT8  *Cert,
  IN    UINTN        CertSize,
  OUT   UINTN        *Usage
  )
{
  return CALL_BASECRYPTLIB (X509.Services.GetKeyUsage, X509GetKeyUsage, (Cert, CertSize, Usage), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceX509VerifyCertChain (
  IN CONST UINT8  *RootCert,
  IN UINTN        RootCertLength,
  IN CONST UINT8  *CertChain,
  IN UINTN        CertChainLength
  )
{
  return CALL_BASECRYPTLIB (X509.Services.VerifyCertChain, X509VerifyCertChain, (RootCert, RootCertLength, CertChain, CertChainLength), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceX509GetCertFromCertChain (
  IN CONST UINT8   *CertChain,
  IN UINTN         CertChainLength,
  IN CONST INT32   CertIndex,
  OUT CONST UINT8  **Cert,
  OUT UINTN        *CertLength
  )
{
  return CALL_BASECRYPTLIB (X509.Services.GetCertFromCertChain, X509GetCertFromCertChain, (CertChain, CertChainLength, CertIndex, Cert, CertLength), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceAsn1GetTag (
  IN OUT UINT8    **Ptr,
  IN CONST UINT8  *End,
  OUT UINTN       *Length,
  IN     UINT32   Tag
  )
{
  return CALL_BASECRYPTLIB (X509.Services.Asn1GetTag, Asn1GetTag, (Ptr, End, Length, Tag), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceX509GetExtendedBasicConstraints             (
  CONST UINT8  *Cert,
  UINTN        CertSize,
  UINT8        *BasicConstraints,
  UINTN        *BasicConstraintsSize
  )
{
  return CALL_BASECRYPTLIB (X509.Services.GetExtendedBasicConstraints, X509GetExtendedBasicConstraints, (Cert, CertSize, BasicConstraints, BasicConstraintsSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServicePkcs5HashPassword (
  IN  UINTN        PasswordLength,
  IN  CONST CHAR8  *Password,
  IN  UINTN        SaltLength,
  IN  CONST UINT8  *Salt,
  IN  UINTN        IterationCount,
  IN  UINTN        DigestSize,
  IN  UINTN        KeyLength,
  OUT UINT8        *OutKey
  )
{
  return CALL_BASECRYPTLIB (Pkcs.Services.Pkcs5HashPassword, Pkcs5HashPassword, (PasswordLength, Password, SaltLength, Salt, IterationCount, DigestSize, KeyLength, OutKey), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServicePkcs1v2Encrypt (
  IN   CONST UINT8  *PublicKey,
  IN   UINTN        PublicKeySize,
  IN   UINT8        *InData,
  IN   UINTN        InDataSize,
  IN   CONST UINT8  *PrngSeed   OPTIONAL,
  IN   UINTN        PrngSeedSize   OPTIONAL,
  OUT  UINT8        **EncryptedData,
  OUT  UINTN        *EncryptedDataSize
  )
{
  return CALL_BASECRYPTLIB (Pkcs.Services.Pkcs1v2Encrypt, Pkcs1v2Encrypt, (PublicKey, PublicKeySize, InData, InDataSize, PrngSeed, PrngSeedSize, EncryptedData, EncryptedDataSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceRsaOaepEncrypt (
  IN   VOID         *RsaContext,
  IN   UINT8        *InData,
  IN   UINTN        InDataSize,
  IN   CONST UINT8  *PrngSeed   OPTIONAL,
  IN   UINTN        PrngSeedSize   OPTIONAL,
  IN   UINT16       DigestLen   OPTIONAL,
  OUT  UINT8        **EncryptedData,
  OUT  UINTN        *EncryptedDataSize
  )
{
  return CALL_BASECRYPTLIB (Rsa.Services.RsaOaepEncrypt, RsaOaepEncrypt, (RsaContext, InData, InDataSize, PrngSeed, PrngSeedSize, DigestLen, EncryptedData, EncryptedDataSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServicePkcs1v2Decrypt (
  IN   CONST UINT8  *PrivateKey,
  IN   UINTN        PrivateKeySize,
  IN   UINT8        *EncryptedData,
  IN   UINTN        EncryptedDataSize,
  OUT  UINT8        **OutData,
  OUT  UINTN        *OutDataSize
  )
{
  return CALL_BASECRYPTLIB (Pkcs.Services.Pkcs1v2Decrypt, Pkcs1v2Decrypt, (PrivateKey, PrivateKeySize, EncryptedData, EncryptedDataSize, OutData, OutDataSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceRsaOaepDecrypt (
  IN   VOID    *RsaContext,
  IN   UINT8   *EncryptedData,
  IN   UINTN   EncryptedDataSize,
  IN   UINT16  DigestLen   OPTIONAL,
  OUT  UINT8   **OutData,
  OUT  UINTN   *OutDataSize
  )
{
  return CALL_BASECRYPTLIB (Rsa.Services.RsaOaepDecrypt, RsaOaepDecrypt, (RsaContext, EncryptedData, EncryptedDataSize, DigestLen, OutData, OutDataSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServicePkcs7GetSigners (
  IN  CONST UINT8  *P7Data,
  IN  UINTN        P7Length,
  OUT UINT8        **CertStack,
  OUT UINTN        *StackLength,
  OUT UINT8        **TrustedCert,
  OUT UINTN        *CertLength
  )
{
  return CALL_BASECRYPTLIB (Pkcs.Services.Pkcs7GetSigners, Pkcs7GetSigners, (P7Data, P7Length, CertStack, StackLength, TrustedCert, CertLength), FALSE);
}
 
VOID
EFIAPI
CryptoServicePkcs7FreeSigners (
  IN  UINT8  *Certs
  )
{
  CALL_VOID_BASECRYPTLIB (Pkcs.Services.Pkcs7FreeSigners, Pkcs7FreeSigners, (Certs));
}
 
BOOLEAN
EFIAPI
CryptoServicePkcs7GetCertificatesList (
  IN  CONST UINT8  *P7Data,
  IN  UINTN        P7Length,
  OUT UINT8        **SignerChainCerts,
  OUT UINTN        *ChainLength,
  OUT UINT8        **UnchainCerts,
  OUT UINTN        *UnchainLength
  )
{
  return CALL_BASECRYPTLIB (Pkcs.Services.Pkcs7GetCertificatesList, Pkcs7GetCertificatesList, (P7Data, P7Length, SignerChainCerts, ChainLength, UnchainCerts, UnchainLength), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServicePkcs7Sign (
  IN   CONST UINT8  *PrivateKey,
  IN   UINTN        PrivateKeySize,
  IN   CONST UINT8  *KeyPassword,
  IN   UINT8        *InData,
  IN   UINTN        InDataSize,
  IN   UINT8        *SignCert,
  IN   UINT8        *OtherCerts      OPTIONAL,
  OUT  UINT8        **SignedData,
  OUT  UINTN        *SignedDataSize
  )
{
  return CALL_BASECRYPTLIB (Pkcs.Services.Pkcs7Sign, Pkcs7Sign, (PrivateKey, PrivateKeySize, KeyPassword, InData, InDataSize, SignCert, OtherCerts, SignedData, SignedDataSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServicePkcs7Verify (
  IN  CONST UINT8  *P7Data,
  IN  UINTN        P7Length,
  IN  CONST UINT8  *TrustedCert,
  IN  UINTN        CertLength,
  IN  CONST UINT8  *InData,
  IN  UINTN        DataLength
  )
{
  return CALL_BASECRYPTLIB (Pkcs.Services.Pkcs7Verify, Pkcs7Verify, (P7Data, P7Length, TrustedCert, CertLength, InData, DataLength), FALSE);
}
 
RETURN_STATUS
EFIAPI
CryptoServiceVerifyEKUsInPkcs7Signature (
  IN  CONST UINT8   *Pkcs7Signature,
  IN  CONST UINT32  SignatureSize,
  IN  CONST CHAR8   *RequiredEKUs[],
  IN  CONST UINT32  RequiredEKUsSize,
  IN  BOOLEAN       RequireAllPresent
  )
{
  return CALL_BASECRYPTLIB (Pkcs.Services.VerifyEKUsInPkcs7Signature, VerifyEKUsInPkcs7Signature, (Pkcs7Signature, SignatureSize, RequiredEKUs, RequiredEKUsSize, RequireAllPresent), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServicePkcs7GetAttachedContent (
  IN  CONST UINT8  *P7Data,
  IN  UINTN        P7Length,
  OUT VOID         **Content,
  OUT UINTN        *ContentSize
  )
{
  return CALL_BASECRYPTLIB (Pkcs.Services.Pkcs7GetAttachedContent, Pkcs7GetAttachedContent, (P7Data, P7Length, Content, ContentSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceAuthenticodeVerify (
  IN  CONST UINT8  *AuthData,
  IN  UINTN        DataSize,
  IN  CONST UINT8  *TrustedCert,
  IN  UINTN        CertSize,
  IN  CONST UINT8  *ImageHash,
  IN  UINTN        HashSize
  )
{
  return CALL_BASECRYPTLIB (Pkcs.Services.AuthenticodeVerify, AuthenticodeVerify, (AuthData, DataSize, TrustedCert, CertSize, ImageHash, HashSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceImageTimestampVerify (
  IN  CONST UINT8  *AuthData,
  IN  UINTN        DataSize,
  IN  CONST UINT8  *TsaCert,
  IN  UINTN        CertSize,
  OUT EFI_TIME     *SigningTime
  )
{
  return CALL_BASECRYPTLIB (Pkcs.Services.ImageTimestampVerify, ImageTimestampVerify, (AuthData, DataSize, TsaCert, CertSize, SigningTime), FALSE);
}
 
// =====================================================================================
//    DH Key Exchange Primitive
// =====================================================================================
 
VOID *
EFIAPI
CryptoServiceDhNew (
  VOID
  )
{
  return CALL_BASECRYPTLIB (Dh.Services.New, DhNew, (), NULL);
}
 
VOID
EFIAPI
CryptoServiceDhFree (
  IN  VOID  *DhContext
  )
{
  CALL_VOID_BASECRYPTLIB (Dh.Services.Free, DhFree, (DhContext));
}
 
BOOLEAN
EFIAPI
CryptoServiceDhGenerateParameter (
  IN OUT  VOID   *DhContext,
  IN      UINTN  Generator,
  IN      UINTN  PrimeLength,
  OUT     UINT8  *Prime
  )
{
  return CALL_BASECRYPTLIB (Dh.Services.GenerateParameter, DhGenerateParameter, (DhContext, Generator, PrimeLength, Prime), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceDhSetParameter (
  IN OUT  VOID         *DhContext,
  IN      UINTN        Generator,
  IN      UINTN        PrimeLength,
  IN      CONST UINT8  *Prime
  )
{
  return CALL_BASECRYPTLIB (Dh.Services.SetParameter, DhSetParameter, (DhContext, Generator, PrimeLength, Prime), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceDhGenerateKey (
  IN OUT  VOID   *DhContext,
  OUT     UINT8  *PublicKey,
  IN OUT  UINTN  *PublicKeySize
  )
{
  return CALL_BASECRYPTLIB (Dh.Services.GenerateKey, DhGenerateKey, (DhContext, PublicKey, PublicKeySize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceDhComputeKey (
  IN OUT  VOID         *DhContext,
  IN      CONST UINT8  *PeerPublicKey,
  IN      UINTN        PeerPublicKeySize,
  OUT     UINT8        *Key,
  IN OUT  UINTN        *KeySize
  )
{
  return CALL_BASECRYPTLIB (Dh.Services.ComputeKey, DhComputeKey, (DhContext, PeerPublicKey, PeerPublicKeySize, Key, KeySize), FALSE);
}
 
// =====================================================================================
//    Pseudo-Random Generation Primitive
// =====================================================================================
 
BOOLEAN
EFIAPI
CryptoServiceRandomSeed (
  IN  CONST  UINT8  *Seed  OPTIONAL,
  IN  UINTN         SeedSize
  )
{
  return CALL_BASECRYPTLIB (Random.Services.Seed, RandomSeed, (Seed, SeedSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceRandomBytes (
  OUT  UINT8  *Output,
  IN   UINTN  Size
  )
{
  return CALL_BASECRYPTLIB (Random.Services.Bytes, RandomBytes, (Output, Size), FALSE);
}
 
// =====================================================================================
//    Key Derivation Function Primitive
// =====================================================================================
 
BOOLEAN
EFIAPI
CryptoServiceHkdfSha256ExtractAndExpand (
  IN   CONST UINT8  *Key,
  IN   UINTN        KeySize,
  IN   CONST UINT8  *Salt,
  IN   UINTN        SaltSize,
  IN   CONST UINT8  *Info,
  IN   UINTN        InfoSize,
  OUT  UINT8        *Out,
  IN   UINTN        OutSize
  )
{
  return CALL_BASECRYPTLIB (Hkdf.Services.Sha256ExtractAndExpand, HkdfSha256ExtractAndExpand, (Key, KeySize, Salt, SaltSize, Info, InfoSize, Out, OutSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceHkdfSha256Extract (
  IN CONST UINT8  *Key,
  IN UINTN        KeySize,
  IN CONST UINT8  *Salt,
  IN UINTN        SaltSize,
  OUT UINT8       *PrkOut,
  UINTN           PrkOutSize
  )
{
  return CALL_BASECRYPTLIB (Hkdf.Services.Sha256Extract, HkdfSha256Extract, (Key, KeySize, Salt, SaltSize, PrkOut, PrkOutSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceHkdfSha256Expand (
  IN   CONST UINT8  *Prk,
  IN   UINTN        PrkSize,
  IN   CONST UINT8  *Info,
  IN   UINTN        InfoSize,
  OUT  UINT8        *Out,
  IN   UINTN        OutSize
  )
{
  return CALL_BASECRYPTLIB (Hkdf.Services.Sha256Expand, HkdfSha256Expand, (Prk, PrkSize, Info, InfoSize, Out, OutSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceHkdfSha384ExtractAndExpand (
  IN   CONST UINT8  *Key,
  IN   UINTN        KeySize,
  IN   CONST UINT8  *Salt,
  IN   UINTN        SaltSize,
  IN   CONST UINT8  *Info,
  IN   UINTN        InfoSize,
  OUT  UINT8        *Out,
  IN   UINTN        OutSize
  )
{
  return CALL_BASECRYPTLIB (Hkdf.Services.Sha384ExtractAndExpand, HkdfSha384ExtractAndExpand, (Key, KeySize, Salt, SaltSize, Info, InfoSize, Out, OutSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceHkdfSha384Extract (
  IN CONST UINT8  *Key,
  IN UINTN        KeySize,
  IN CONST UINT8  *Salt,
  IN UINTN        SaltSize,
  OUT UINT8       *PrkOut,
  UINTN           PrkOutSize
  )
{
  return CALL_BASECRYPTLIB (Hkdf.Services.Sha384Extract, HkdfSha384Extract, (Key, KeySize, Salt, SaltSize, PrkOut, PrkOutSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceHkdfSha384Expand (
  IN   CONST UINT8  *Prk,
  IN   UINTN        PrkSize,
  IN   CONST UINT8  *Info,
  IN   UINTN        InfoSize,
  OUT  UINT8        *Out,
  IN   UINTN        OutSize
  )
{
  return CALL_BASECRYPTLIB (Hkdf.Services.Sha384Expand, HkdfSha384Expand, (Prk, PrkSize, Info, InfoSize, Out, OutSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceTlsInitialize (
  VOID
  )
{
  return CALL_BASECRYPTLIB (Tls.Services.Initialize, TlsInitialize, (), FALSE);
}
 
VOID
EFIAPI
CryptoServiceTlsCtxFree (
  IN   VOID  *TlsCtx
  )
{
  CALL_VOID_BASECRYPTLIB (Tls.Services.CtxFree, TlsCtxFree, (TlsCtx));
}
 
VOID *
EFIAPI
CryptoServiceTlsCtxNew (
  IN     UINT8  MajorVer,
  IN     UINT8  MinorVer
  )
{
  return CALL_BASECRYPTLIB (Tls.Services.CtxNew, TlsCtxNew, (MajorVer, MinorVer), NULL);
}
 
VOID
EFIAPI
CryptoServiceTlsFree (
  IN     VOID  *Tls
  )
{
  CALL_VOID_BASECRYPTLIB (Tls.Services.Free, TlsFree, (Tls));
}
 
VOID *
EFIAPI
CryptoServiceTlsNew (
  IN     VOID  *TlsCtx
  )
{
  return CALL_BASECRYPTLIB (Tls.Services.New, TlsNew, (TlsCtx), NULL);
}
 
BOOLEAN
EFIAPI
CryptoServiceTlsInHandshake (
  IN     VOID  *Tls
  )
{
  return CALL_BASECRYPTLIB (Tls.Services.InHandshake, TlsInHandshake, (Tls), FALSE);
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsDoHandshake (
  IN     VOID   *Tls,
  IN     UINT8  *BufferIn  OPTIONAL,
  IN     UINTN  BufferInSize  OPTIONAL,
  OUT UINT8     *BufferOut  OPTIONAL,
  IN OUT UINTN  *BufferOutSize
  )
{
  return CALL_BASECRYPTLIB (Tls.Services.DoHandshake, TlsDoHandshake, (Tls, BufferIn, BufferInSize, BufferOut, BufferOutSize), EFI_UNSUPPORTED);
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsHandleAlert (
  IN     VOID   *Tls,
  IN     UINT8  *BufferIn  OPTIONAL,
  IN     UINTN  BufferInSize  OPTIONAL,
  OUT UINT8     *BufferOut  OPTIONAL,
  IN OUT UINTN  *BufferOutSize
  )
{
  return CALL_BASECRYPTLIB (Tls.Services.HandleAlert, TlsHandleAlert, (Tls, BufferIn, BufferInSize, BufferOut, BufferOutSize), EFI_UNSUPPORTED);
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsCloseNotify (
  IN     VOID   *Tls,
  IN OUT UINT8  *Buffer,
  IN OUT UINTN  *BufferSize
  )
{
  return CALL_BASECRYPTLIB (Tls.Services.CloseNotify, TlsCloseNotify, (Tls, Buffer, BufferSize), EFI_UNSUPPORTED);
}
 
INTN
EFIAPI
CryptoServiceTlsCtrlTrafficOut (
  IN     VOID   *Tls,
  IN OUT VOID   *Buffer,
  IN     UINTN  BufferSize
  )
{
  return CALL_BASECRYPTLIB (Tls.Services.CtrlTrafficOut, TlsCtrlTrafficOut, (Tls, Buffer, BufferSize), 0);
}
 
INTN
EFIAPI
CryptoServiceTlsCtrlTrafficIn (
  IN     VOID   *Tls,
  IN     VOID   *Buffer,
  IN     UINTN  BufferSize
  )
{
  return CALL_BASECRYPTLIB (Tls.Services.CtrlTrafficIn, TlsCtrlTrafficIn, (Tls, Buffer, BufferSize), 0);
}
 
INTN
EFIAPI
CryptoServiceTlsRead (
  IN     VOID   *Tls,
  IN OUT VOID   *Buffer,
  IN     UINTN  BufferSize
  )
{
  return CALL_BASECRYPTLIB (Tls.Services.Read, TlsRead, (Tls, Buffer, BufferSize), 0);
}
 
INTN
EFIAPI
CryptoServiceTlsWrite (
  IN     VOID   *Tls,
  IN     VOID   *Buffer,
  IN     UINTN  BufferSize
  )
{
  return CALL_BASECRYPTLIB (Tls.Services.Write, TlsWrite, (Tls, Buffer, BufferSize), 0);
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsShutdown (
  IN     VOID  *Tls
  )
{
  return CALL_BASECRYPTLIB (Tls.Services.Shutdown, TlsShutdown, (Tls), EFI_UNSUPPORTED);
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsSetVersion (
  IN     VOID   *Tls,
  IN     UINT8  MajorVer,
  IN     UINT8  MinorVer
  )
{
  return CALL_BASECRYPTLIB (TlsSet.Services.Version, TlsSetVersion, (Tls, MajorVer, MinorVer), EFI_UNSUPPORTED);
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsSetConnectionEnd (
  IN     VOID     *Tls,
  IN     BOOLEAN  IsServer
  )
{
  return CALL_BASECRYPTLIB (TlsSet.Services.ConnectionEnd, TlsSetConnectionEnd, (Tls, IsServer), EFI_UNSUPPORTED);
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsSetCipherList (
  IN     VOID    *Tls,
  IN     UINT16  *CipherId,
  IN     UINTN   CipherNum
  )
{
  return CALL_BASECRYPTLIB (TlsSet.Services.CipherList, TlsSetCipherList, (Tls, CipherId, CipherNum), EFI_UNSUPPORTED);
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsSetCompressionMethod (
  IN     UINT8  CompMethod
  )
{
  return CALL_BASECRYPTLIB (TlsSet.Services.CompressionMethod, TlsSetCompressionMethod, (CompMethod), EFI_UNSUPPORTED);
}
 
VOID
EFIAPI
CryptoServiceTlsSetVerify (
  IN     VOID    *Tls,
  IN     UINT32  VerifyMode
  )
{
  CALL_VOID_BASECRYPTLIB (TlsSet.Services.Verify, TlsSetVerify, (Tls, VerifyMode));
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsSetVerifyHost (
  IN     VOID    *Tls,
  IN     UINT32  Flags,
  IN     CHAR8   *HostName
  )
{
  return CALL_BASECRYPTLIB (TlsSet.Services.VerifyHost, TlsSetVerifyHost, (Tls, Flags, HostName), EFI_UNSUPPORTED);
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsSetSessionId (
  IN     VOID    *Tls,
  IN     UINT8   *SessionId,
  IN     UINT16  SessionIdLen
  )
{
  return CALL_BASECRYPTLIB (TlsSet.Services.SessionId, TlsSetSessionId, (Tls, SessionId, SessionIdLen), EFI_UNSUPPORTED);
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsSetCaCertificate (
  IN     VOID   *Tls,
  IN     VOID   *Data,
  IN     UINTN  DataSize
  )
{
  return CALL_BASECRYPTLIB (TlsSet.Services.CaCertificate, TlsSetCaCertificate, (Tls, Data, DataSize), EFI_UNSUPPORTED);
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsSetHostPublicCert (
  IN     VOID   *Tls,
  IN     VOID   *Data,
  IN     UINTN  DataSize
  )
{
  return CALL_BASECRYPTLIB (TlsSet.Services.HostPublicCert, TlsSetHostPublicCert, (Tls, Data, DataSize), EFI_UNSUPPORTED);
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsSetHostPrivateKeyEx (
  IN     VOID   *Tls,
  IN     VOID   *Data,
  IN     UINTN  DataSize,
  IN     VOID   *Password  OPTIONAL
  )
{
  return CALL_BASECRYPTLIB (TlsSet.Services.HostPrivateKeyEx, TlsSetHostPrivateKeyEx, (Tls, Data, DataSize, Password), EFI_UNSUPPORTED);
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsSetHostPrivateKey (
  IN     VOID   *Tls,
  IN     VOID   *Data,
  IN     UINTN  DataSize
  )
{
  return CALL_BASECRYPTLIB (TlsSet.Services.HostPrivateKey, TlsSetHostPrivateKey, (Tls, Data, DataSize), EFI_UNSUPPORTED);
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsSetCertRevocationList (
  IN     VOID   *Data,
  IN     UINTN  DataSize
  )
{
  return CALL_BASECRYPTLIB (TlsSet.Services.CertRevocationList, TlsSetCertRevocationList, (Data, DataSize), EFI_UNSUPPORTED);
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsSetSignatureAlgoList (
  IN     VOID   *Tls,
  IN     UINT8  *Data,
  IN     UINTN  DataSize
  )
{
  return CALL_BASECRYPTLIB (TlsSet.Services.SignatureAlgoList, TlsSetSignatureAlgoList, (Tls, Data, DataSize), EFI_UNSUPPORTED);
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsSetEcCurve (
  IN     VOID   *Tls,
  IN     UINT8  *Data,
  IN     UINTN  DataSize
  )
{
  return CALL_BASECRYPTLIB (TlsSet.Services.EcCurve, TlsSetEcCurve, (Tls, Data, DataSize), EFI_UNSUPPORTED);
}
 
UINT16
EFIAPI
CryptoServiceTlsGetVersion (
  IN     VOID  *Tls
  )
{
  return CALL_BASECRYPTLIB (TlsGet.Services.Version, TlsGetVersion, (Tls), 0);
}
 
UINT8
EFIAPI
CryptoServiceTlsGetConnectionEnd (
  IN     VOID  *Tls
  )
{
  return CALL_BASECRYPTLIB (TlsGet.Services.ConnectionEnd, TlsGetConnectionEnd, (Tls), 0);
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsGetCurrentCipher (
  IN     VOID    *Tls,
  IN OUT UINT16  *CipherId
  )
{
  return CALL_BASECRYPTLIB (TlsGet.Services.CurrentCipher, TlsGetCurrentCipher, (Tls, CipherId), EFI_UNSUPPORTED);
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsGetCurrentCompressionId (
  IN     VOID   *Tls,
  IN OUT UINT8  *CompressionId
  )
{
  return CALL_BASECRYPTLIB (TlsGet.Services.CurrentCompressionId, TlsGetCurrentCompressionId, (Tls, CompressionId), EFI_UNSUPPORTED);
}
 
UINT32
EFIAPI
CryptoServiceTlsGetVerify (
  IN     VOID  *Tls
  )
{
  return CALL_BASECRYPTLIB (TlsGet.Services.Verify, TlsGetVerify, (Tls), 0);
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsGetSessionId (
  IN     VOID    *Tls,
  IN OUT UINT8   *SessionId,
  IN OUT UINT16  *SessionIdLen
  )
{
  return CALL_BASECRYPTLIB (TlsGet.Services.SessionId, TlsGetSessionId, (Tls, SessionId, SessionIdLen), EFI_UNSUPPORTED);
}
 
VOID
EFIAPI
CryptoServiceTlsGetClientRandom (
  IN     VOID   *Tls,
  IN OUT UINT8  *ClientRandom
  )
{
  CALL_VOID_BASECRYPTLIB (TlsGet.Services.ClientRandom, TlsGetClientRandom, (Tls, ClientRandom));
}
 
VOID
EFIAPI
CryptoServiceTlsGetServerRandom (
  IN     VOID   *Tls,
  IN OUT UINT8  *ServerRandom
  )
{
  CALL_VOID_BASECRYPTLIB (TlsGet.Services.ServerRandom, TlsGetServerRandom, (Tls, ServerRandom));
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsGetKeyMaterial (
  IN     VOID   *Tls,
  IN OUT UINT8  *KeyMaterial
  )
{
  return CALL_BASECRYPTLIB (TlsGet.Services.KeyMaterial, TlsGetKeyMaterial, (Tls, KeyMaterial), EFI_UNSUPPORTED);
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsGetCaCertificate (
  IN     VOID   *Tls,
  OUT    VOID   *Data,
  IN OUT UINTN  *DataSize
  )
{
  return CALL_BASECRYPTLIB (TlsGet.Services.CaCertificate, TlsGetCaCertificate, (Tls, Data, DataSize), EFI_UNSUPPORTED);
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsGetHostPublicCert (
  IN     VOID   *Tls,
  OUT    VOID   *Data,
  IN OUT UINTN  *DataSize
  )
{
  return CALL_BASECRYPTLIB (TlsGet.Services.HostPublicCert, TlsGetHostPublicCert, (Tls, Data, DataSize), EFI_UNSUPPORTED);
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsGetHostPrivateKey (
  IN     VOID   *Tls,
  OUT    VOID   *Data,
  IN OUT UINTN  *DataSize
  )
{
  return CALL_BASECRYPTLIB (TlsGet.Services.HostPrivateKey, TlsGetHostPrivateKey, (Tls, Data, DataSize), EFI_UNSUPPORTED);
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsGetCertRevocationList (
  OUT    VOID   *Data,
  IN OUT UINTN  *DataSize
  )
{
  return CALL_BASECRYPTLIB (TlsGet.Services.CertRevocationList, TlsGetCertRevocationList, (Data, DataSize), EFI_UNSUPPORTED);
}
 
EFI_STATUS
EFIAPI
CryptoServiceTlsGetExportKey (
  IN     VOID        *Tls,
  IN     CONST VOID  *Label,
  IN     CONST VOID  *Context,
  IN     UINTN       ContextLen,
  OUT    VOID        *KeyBuffer,
  IN     UINTN       KeyBufferLen
  )
{
  return CALL_BASECRYPTLIB (
           TlsGet.Services.ExportKey,
           TlsGetExportKey,
           (Tls, Label, Context, ContextLen,
            KeyBuffer, KeyBufferLen),
           EFI_UNSUPPORTED
           );
}
 
BOOLEAN
EFIAPI
CryptoServiceRsaPssSign (
  IN      VOID         *RsaContext,
  IN      CONST UINT8  *Message,
  IN      UINTN        MsgSize,
  IN      UINT16       DigestLen,
  IN      UINT16       SaltLen,
  OUT     UINT8        *Signature,
  IN OUT  UINTN        *SigSize
  )
{
  return CALL_BASECRYPTLIB (RsaPss.Services.Sign, RsaPssSign, (RsaContext, Message, MsgSize, DigestLen, SaltLen, Signature, SigSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceRsaPssVerify (
  IN  VOID         *RsaContext,
  IN  CONST UINT8  *Message,
  IN  UINTN        MsgSize,
  IN  CONST UINT8  *Signature,
  IN  UINTN        SigSize,
  IN  UINT16       DigestLen,
  IN  UINT16       SaltLen
  )
{
  return CALL_BASECRYPTLIB (RsaPss.Services.Verify, RsaPssVerify, (RsaContext, Message, MsgSize, Signature, SigSize, DigestLen, SaltLen), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceParallelHash256HashAll (
  IN CONST VOID   *Input,
  IN       UINTN  InputByteLen,
  IN       UINTN  BlockSize,
  OUT      VOID   *Output,
  IN       UINTN  OutputByteLen,
  IN CONST VOID   *Customization,
  IN       UINTN  CustomByteLen
  )
{
  return CALL_BASECRYPTLIB (ParallelHash.Services.HashAll, ParallelHash256HashAll, (Input, InputByteLen, BlockSize, Output, OutputByteLen, Customization, CustomByteLen), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceAeadAesGcmEncrypt (
  IN   CONST UINT8  *Key,
  IN   UINTN        KeySize,
  IN   CONST UINT8  *Iv,
  IN   UINTN        IvSize,
  IN   CONST UINT8  *AData,
  IN   UINTN        ADataSize,
  IN   CONST UINT8  *DataIn,
  IN   UINTN        DataInSize,
  OUT  UINT8        *TagOut,
  IN   UINTN        TagSize,
  OUT  UINT8        *DataOut,
  OUT  UINTN        *DataOutSize
  )
{
  return CALL_BASECRYPTLIB (AeadAesGcm.Services.Encrypt, AeadAesGcmEncrypt, (Key, KeySize, Iv, IvSize, AData, ADataSize, DataIn, DataInSize, TagOut, TagSize, DataOut, DataOutSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceAeadAesGcmDecrypt (
  IN   CONST UINT8  *Key,
  IN   UINTN        KeySize,
  IN   CONST UINT8  *Iv,
  IN   UINTN        IvSize,
  IN   CONST UINT8  *AData,
  IN   UINTN        ADataSize,
  IN   CONST UINT8  *DataIn,
  IN   UINTN        DataInSize,
  IN   CONST UINT8  *Tag,
  IN   UINTN        TagSize,
  OUT  UINT8        *DataOut,
  OUT  UINTN        *DataOutSize
  )
{
  return CALL_BASECRYPTLIB (AeadAesGcm.Services.Decrypt, AeadAesGcmDecrypt, (Key, KeySize, Iv, IvSize, AData, ADataSize, DataIn, DataInSize, Tag, TagSize, DataOut, DataOutSize), FALSE);
}
 
// =====================================================================================
//    Big number primitives
// =====================================================================================
 
VOID *
EFIAPI
CryptoServiceBigNumInit (
  VOID
  )
{
  return CALL_BASECRYPTLIB (Bn.Services.Init, BigNumInit, (), NULL);
}
 
VOID *
EFIAPI
CryptoServiceBigNumFromBin (
  IN CONST UINT8  *Buf,
  IN UINTN        Len
  )
{
  return CALL_BASECRYPTLIB (Bn.Services.FromBin, BigNumFromBin, (Buf, Len), NULL);
}
 
INTN
EFIAPI
CryptoServiceBigNumToBin (
  IN CONST VOID  *Bn,
  OUT UINT8      *Buf
  )
{
  return CALL_BASECRYPTLIB (Bn.Services.ToBin, BigNumToBin, (Bn, Buf), -1);
}
 
VOID
EFIAPI
CryptoServiceBigNumFree (
  IN VOID     *Bn,
  IN BOOLEAN  Clear
  )
{
  CALL_VOID_BASECRYPTLIB (Bn.Services.Free, BigNumFree, (Bn, Clear));
}
 
BOOLEAN
EFIAPI
CryptoServiceBigNumAdd (
  IN CONST VOID  *BnA,
  IN CONST VOID  *BnB,
  OUT VOID       *BnRes
  )
{
  return CALL_BASECRYPTLIB (Bn.Services.Add, BigNumAdd, (BnA, BnB, BnRes), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceBigNumSub (
  IN CONST VOID  *BnA,
  IN CONST VOID  *BnB,
  OUT VOID       *BnRes
  )
{
  return CALL_BASECRYPTLIB (Bn.Services.Sub, BigNumSub, (BnA, BnB, BnRes), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceBigNumMod (
  IN CONST VOID  *BnA,
  IN CONST VOID  *BnB,
  OUT VOID       *BnRes
  )
{
  return CALL_BASECRYPTLIB (Bn.Services.Mod, BigNumMod, (BnA, BnB, BnRes), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceBigNumExpMod (
  IN CONST VOID  *BnA,
  IN CONST VOID  *BnP,
  IN CONST VOID  *BnM,
  OUT VOID       *BnRes
  )
{
  return CALL_BASECRYPTLIB (Bn.Services.ExpMod, BigNumExpMod, (BnA, BnP, BnM, BnRes), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceBigNumInverseMod (
  IN CONST VOID  *BnA,
  IN CONST VOID  *BnM,
  OUT VOID       *BnRes
  )
{
  return CALL_BASECRYPTLIB (Bn.Services.InverseMod, BigNumInverseMod, (BnA, BnM, BnRes), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceBigNumDiv (
  IN CONST VOID  *BnA,
  IN CONST VOID  *BnB,
  OUT VOID       *BnRes
  )
{
  return CALL_BASECRYPTLIB (Bn.Services.Div, BigNumDiv, (BnA, BnB, BnRes), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceBigNumMulMod (
  IN CONST VOID  *BnA,
  IN CONST VOID  *BnB,
  IN CONST VOID  *BnM,
  OUT VOID       *BnRes
  )
{
  return CALL_BASECRYPTLIB (Bn.Services.MulMod, BigNumMulMod, (BnA, BnB, BnM, BnRes), FALSE);
}
 
INTN
EFIAPI
CryptoServiceBigNumCmp (
  IN CONST VOID  *BnA,
  IN CONST VOID  *BnB
  )
{
  return CALL_BASECRYPTLIB (Bn.Services.Cmp, BigNumCmp, (BnA, BnB), 0);
}
 
UINTN
EFIAPI
CryptoServiceBigNumBits (
  IN CONST VOID  *Bn
  )
{
  return CALL_BASECRYPTLIB (Bn.Services.Bits, BigNumBits, (Bn), 0);
}
 
UINTN
EFIAPI
CryptoServiceBigNumBytes (
  IN CONST VOID  *Bn
  )
{
  return CALL_BASECRYPTLIB (Bn.Services.Bytes, BigNumBytes, (Bn), 0);
}
 
BOOLEAN
EFIAPI
CryptoServiceBigNumIsWord (
  IN CONST VOID  *Bn,
  IN UINTN       Num
  )
{
  return CALL_BASECRYPTLIB (Bn.Services.IsWord, BigNumIsWord, (Bn, Num), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceBigNumIsOdd (
  IN CONST VOID  *Bn
  )
{
  return CALL_BASECRYPTLIB (Bn.Services.IsOdd, BigNumIsOdd, (Bn), FALSE);
}
 
VOID *
EFIAPI
CryptoServiceBigNumCopy (
  OUT VOID       *BnDst,
  IN CONST VOID  *BnSrc
  )
{
  return CALL_BASECRYPTLIB (Bn.Services.Copy, BigNumCopy, (BnDst, BnSrc), NULL);
}
 
CONST VOID *
EFIAPI
CryptoServiceBigNumValueOne (
  VOID
  )
{
  return CALL_BASECRYPTLIB (Bn.Services.ValueOne, BigNumValueOne, (), NULL);
}
 
BOOLEAN
EFIAPI
CryptoServiceBigNumRShift (
  IN CONST VOID  *Bn,
  IN UINTN       N,
  OUT VOID       *BnRes
  )
{
  return CALL_BASECRYPTLIB (Bn.Services.RShift, BigNumRShift, (Bn, N, BnRes), FALSE);
}
 
VOID
EFIAPI
CryptoServiceBigNumConstTime (
  IN VOID  *Bn
  )
{
  CALL_VOID_BASECRYPTLIB (Bn.Services.ConstTime, BigNumConstTime, (Bn));
}
 
BOOLEAN
EFIAPI
CryptoServiceBigNumSqrMod (
  IN CONST VOID  *BnA,
  IN CONST VOID  *BnM,
  OUT VOID       *BnRes
  )
{
  return CALL_BASECRYPTLIB (Bn.Services.SqrMod, BigNumSqrMod, (BnA, BnM, BnRes), FALSE);
}
 
VOID *
EFIAPI
CryptoServiceBigNumNewContext (
  VOID
  )
{
  return CALL_BASECRYPTLIB (Bn.Services.NewContext, BigNumNewContext, (), NULL);
}
 
VOID
EFIAPI
CryptoServiceBigNumContextFree (
  IN VOID  *BnCtx
  )
{
  CALL_VOID_BASECRYPTLIB (Bn.Services.ContextFree, BigNumContextFree, (BnCtx));
}
 
BOOLEAN
EFIAPI
CryptoServiceBigNumSetUint (
  IN VOID   *Bn,
  IN UINTN  Val
  )
{
  return CALL_BASECRYPTLIB (Bn.Services.SetUint, BigNumSetUint, (Bn, Val), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceBigNumAddMod (
  IN CONST VOID  *BnA,
  IN CONST VOID  *BnB,
  IN CONST VOID  *BnM,
  OUT VOID       *BnRes
  )
{
  return CALL_BASECRYPTLIB (Bn.Services.AddMod, BigNumAddMod, (BnA, BnB, BnM, BnRes), FALSE);
}
 
// =====================================================================================
//    Basic Elliptic Curve Primitives
// =====================================================================================
 
VOID *
EFIAPI
CryptoServiceEcGroupInit (
  IN UINTN  CryptoNid
  )
{
  return CALL_BASECRYPTLIB (Ec.Services.GroupInit, EcGroupInit, (CryptoNid), NULL);
}
 
BOOLEAN
EFIAPI
CryptoServiceEcGroupGetCurve (
  IN CONST VOID  *EcGroup,
  OUT VOID       *BnPrime,
  OUT VOID       *BnA,
  OUT VOID       *BnB,
  IN VOID        *BnCtx
  )
{
  return CALL_BASECRYPTLIB (Ec.Services.GroupGetCurve, EcGroupGetCurve, (EcGroup, BnPrime, BnA, BnB, BnCtx), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceEcGroupGetOrder (
  IN VOID   *EcGroup,
  OUT VOID  *BnOrder
  )
{
  return CALL_BASECRYPTLIB (Ec.Services.GroupGetOrder, EcGroupGetOrder, (EcGroup, BnOrder), FALSE);
}
 
VOID
EFIAPI
CryptoServiceEcGroupFree (
  IN VOID  *EcGroup
  )
{
  CALL_VOID_BASECRYPTLIB (Ec.Services.GroupFree, EcGroupFree, (EcGroup));
}
 
VOID *
EFIAPI
CryptoServiceEcPointInit (
  IN CONST VOID  *EcGroup
  )
{
  return CALL_BASECRYPTLIB (Ec.Services.PointInit, EcPointInit, (EcGroup), NULL);
}
 
VOID
EFIAPI
CryptoServiceEcPointDeInit (
  IN VOID     *EcPoint,
  IN BOOLEAN  Clear
  )
{
  CALL_VOID_BASECRYPTLIB (Ec.Services.PointDeInit, EcPointDeInit, (EcPoint, Clear));
}
 
BOOLEAN
EFIAPI
CryptoServiceEcPointGetAffineCoordinates (
  IN CONST VOID  *EcGroup,
  IN CONST VOID  *EcPoint,
  OUT VOID       *BnX,
  OUT VOID       *BnY,
  IN VOID        *BnCtx
  )
{
  return CALL_BASECRYPTLIB (Ec.Services.PointGetAffineCoordinates, EcPointGetAffineCoordinates, (EcGroup, EcPoint, BnX, BnY, BnCtx), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceEcPointSetAffineCoordinates (
  IN CONST VOID  *EcGroup,
  IN VOID        *EcPoint,
  IN CONST VOID  *BnX,
  IN CONST VOID  *BnY,
  IN VOID        *BnCtx
  )
{
  return CALL_BASECRYPTLIB (Ec.Services.PointSetAffineCoordinates, EcPointSetAffineCoordinates, (EcGroup, EcPoint, BnX, BnY, BnCtx), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceEcPointAdd (
  IN CONST VOID  *EcGroup,
  OUT VOID       *EcPointResult,
  IN CONST VOID  *EcPointA,
  IN CONST VOID  *EcPointB,
  IN VOID        *BnCtx
  )
{
  return CALL_BASECRYPTLIB (Ec.Services.PointAdd, EcPointAdd, (EcGroup, EcPointResult, EcPointA, EcPointB, BnCtx), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceEcPointMul (
  IN CONST VOID  *EcGroup,
  OUT VOID       *EcPointResult,
  IN CONST VOID  *EcPoint,
  IN CONST VOID  *BnPScalar,
  IN VOID        *BnCtx
  )
{
  return CALL_BASECRYPTLIB (Ec.Services.PointMul, EcPointMul, (EcGroup, EcPointResult, EcPoint, BnPScalar, BnCtx), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceEcPointInvert (
  IN CONST VOID  *EcGroup,
  IN OUT VOID    *EcPoint,
  IN VOID        *BnCtx
  )
{
  return CALL_BASECRYPTLIB (Ec.Services.PointInvert, EcPointInvert, (EcGroup, EcPoint, BnCtx), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceEcPointIsOnCurve (
  IN CONST VOID  *EcGroup,
  IN CONST VOID  *EcPoint,
  IN VOID        *BnCtx
  )
{
  return CALL_BASECRYPTLIB (Ec.Services.PointIsOnCurve, EcPointIsOnCurve, (EcGroup, EcPoint, BnCtx), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceEcPointIsAtInfinity (
  IN CONST VOID  *EcGroup,
  IN CONST VOID  *EcPoint
  )
{
  return CALL_BASECRYPTLIB (Ec.Services.PointIsAtInfinity, EcPointIsAtInfinity, (EcGroup, EcPoint), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceEcPointEqual (
  IN CONST VOID  *EcGroup,
  IN CONST VOID  *EcPointA,
  IN CONST VOID  *EcPointB,
  IN VOID        *BnCtx
  )
{
  return CALL_BASECRYPTLIB (Ec.Services.PointEqual, EcPointEqual, (EcGroup, EcPointA, EcPointB, BnCtx), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceEcPointSetCompressedCoordinates (
  IN CONST VOID  *EcGroup,
  IN VOID        *EcPoint,
  IN CONST VOID  *BnX,
  IN UINT8       YBit,
  IN VOID        *BnCtx
  )
{
  return CALL_BASECRYPTLIB (Ec.Services.PointSetCompressedCoordinates, EcPointSetCompressedCoordinates, (EcGroup, EcPoint, BnX, YBit, BnCtx), FALSE);
}
 
// =====================================================================================
//    Elliptic Curve Diffie Hellman Primitives
// =====================================================================================
 
VOID *
EFIAPI
CryptoServiceEcNewByNid (
  IN UINTN  Nid
  )
{
  return CALL_BASECRYPTLIB (Ec.Services.NewByNid, EcNewByNid, (Nid), NULL);
}
 
VOID
EFIAPI
CryptoServiceEcFree (
  IN  VOID  *EcContext
  )
{
  CALL_VOID_BASECRYPTLIB (Ec.Services.Free, EcFree, (EcContext));
}
 
BOOLEAN
EFIAPI
CryptoServiceEcGenerateKey (
  IN OUT  VOID   *EcContext,
  OUT     UINT8  *PublicKey,
  IN OUT  UINTN  *PublicKeySize
  )
{
  return CALL_BASECRYPTLIB (Ec.Services.GenerateKey, EcGenerateKey, (EcContext, PublicKey, PublicKeySize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceEcGetPubKey (
  IN OUT  VOID   *EcContext,
  OUT     UINT8  *PublicKey,
  IN OUT  UINTN  *PublicKeySize
  )
{
  return CALL_BASECRYPTLIB (Ec.Services.GetPubKey, EcGetPubKey, (EcContext, PublicKey, PublicKeySize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceEcDhComputeKey (
  IN OUT  VOID         *EcContext,
  IN      CONST UINT8  *PeerPublic,
  IN      UINTN        PeerPublicSize,
  IN      CONST INT32  *CompressFlag,
  OUT     UINT8        *Key,
  IN OUT  UINTN        *KeySize
  )
{
  return CALL_BASECRYPTLIB (Ec.Services.DhComputeKey, EcDhComputeKey, (EcContext, PeerPublic, PeerPublicSize, CompressFlag, Key, KeySize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceEcGetPublicKeyFromX509 (
  IN   CONST UINT8  *Cert,
  IN   UINTN        CertSize,
  OUT  VOID         **EcContext
  )
{
  return CALL_BASECRYPTLIB (Ec.Services.GetPublicKeyFromX509, EcGetPublicKeyFromX509, (Cert, CertSize, EcContext), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceEcGetPrivateKeyFromPem (
  IN   CONST UINT8  *PemData,
  IN   UINTN        PemSize,
  IN   CONST CHAR8  *Password,
  OUT  VOID         **EcContext
  )
{
  return CALL_BASECRYPTLIB (Ec.Services.GetPrivateKeyFromPem, EcGetPrivateKeyFromPem, (PemData, PemSize, Password, EcContext), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceEcDsaSign (
  IN      VOID         *EcContext,
  IN      UINTN        HashNid,
  IN      CONST UINT8  *MessageHash,
  IN      UINTN        HashSize,
  OUT     UINT8        *Signature,
  IN OUT  UINTN        *SigSize
  )
{
  return CALL_BASECRYPTLIB (Ec.Services.DsaSign, EcDsaSign, (EcContext, HashNid, MessageHash, HashSize, Signature, SigSize), FALSE);
}
 
BOOLEAN
EFIAPI
CryptoServiceEcDsaVerify (
  IN  VOID         *EcContext,
  IN  UINTN        HashNid,
  IN  CONST UINT8  *MessageHash,
  IN  UINTN        HashSize,
  IN  CONST UINT8  *Signature,
  IN  UINTN        SigSize
  )
{
  return CALL_BASECRYPTLIB (Ec.Services.DsaVerify, EcDsaVerify, (EcContext, HashNid, MessageHash, HashSize, Signature, SigSize), FALSE);
}
 
const EDKII_CRYPTO_PROTOCOL  mEdkiiCrypto = {
  CryptoServiceGetCryptoVersion,
  DeprecatedCryptoServiceHmacMd5New,
  DeprecatedCryptoServiceHmacMd5Free,
  DeprecatedCryptoServiceHmacMd5SetKey,
  DeprecatedCryptoServiceHmacMd5Duplicate,
  DeprecatedCryptoServiceHmacMd5Update,
  DeprecatedCryptoServiceHmacMd5Final,
  DeprecatedCryptoServiceHmacSha1New,
  DeprecatedCryptoServiceHmacSha1Free,
  DeprecatedCryptoServiceHmacSha1SetKey,
  DeprecatedCryptoServiceHmacSha1Duplicate,
  DeprecatedCryptoServiceHmacSha1Update,
  DeprecatedCryptoServiceHmacSha1Final,
  CryptoServiceHmacSha256New,
  CryptoServiceHmacSha256Free,
  CryptoServiceHmacSha256SetKey,
  CryptoServiceHmacSha256Duplicate,
  CryptoServiceHmacSha256Update,
  CryptoServiceHmacSha256Final,
  DeprecatedCryptoServiceMd4GetContextSize,
  DeprecatedCryptoServiceMd4Init,
  DeprecatedCryptoServiceMd4Duplicate,
  DeprecatedCryptoServiceMd4Update,
  DeprecatedCryptoServiceMd4Final,
  DeprecatedCryptoServiceMd4HashAll,
 #ifndef ENABLE_MD5_DEPRECATED_INTERFACES
  DeprecatedCryptoServiceMd5GetContextSize,
  DeprecatedCryptoServiceMd5Init,
  DeprecatedCryptoServiceMd5Duplicate,
  DeprecatedCryptoServiceMd5Update,
  DeprecatedCryptoServiceMd5Final,
  DeprecatedCryptoServiceMd5HashAll,
 #else
  CryptoServiceMd5GetContextSize,
  CryptoServiceMd5Init,
  CryptoServiceMd5Duplicate,
  CryptoServiceMd5Update,
  CryptoServiceMd5Final,
  CryptoServiceMd5HashAll,
 #endif
  CryptoServicePkcs1v2Encrypt,
  CryptoServicePkcs5HashPassword,
  CryptoServicePkcs7Verify,
  CryptoServiceVerifyEKUsInPkcs7Signature,
  CryptoServicePkcs7GetSigners,
  CryptoServicePkcs7FreeSigners,
  CryptoServicePkcs7Sign,
  CryptoServicePkcs7GetAttachedContent,
  CryptoServicePkcs7GetCertificatesList,
  CryptoServiceAuthenticodeVerify,
  CryptoServiceImageTimestampVerify,
  CryptoServiceDhNew,
  CryptoServiceDhFree,
  CryptoServiceDhGenerateParameter,
  CryptoServiceDhSetParameter,
  CryptoServiceDhGenerateKey,
  CryptoServiceDhComputeKey,
  CryptoServiceRandomSeed,
  CryptoServiceRandomBytes,
  CryptoServiceRsaPkcs1Verify,
  CryptoServiceRsaNew,
  CryptoServiceRsaFree,
  CryptoServiceRsaSetKey,
  CryptoServiceRsaGetKey,
  CryptoServiceRsaGenerateKey,
  CryptoServiceRsaCheckKey,
  CryptoServiceRsaPkcs1Sign,
  CryptoServiceRsaPkcs1Verify,
  CryptoServiceRsaGetPrivateKeyFromPem,
  CryptoServiceRsaGetPublicKeyFromX509,
 #ifdef DISABLE_SHA1_DEPRECATED_INTERFACES
  DeprecatedCryptoServiceSha1GetContextSize,
  DeprecatedCryptoServiceSha1Init,
  DeprecatedCryptoServiceSha1Duplicate,
  DeprecatedCryptoServiceSha1Update,
  DeprecatedCryptoServiceSha1Final,
  DeprecatedCryptoServiceSha1HashAll,
 #else
  CryptoServiceSha1GetContextSize,
  CryptoServiceSha1Init,
  CryptoServiceSha1Duplicate,
  CryptoServiceSha1Update,
  CryptoServiceSha1Final,
  CryptoServiceSha1HashAll,
 #endif
  CryptoServiceSha256GetContextSize,
  CryptoServiceSha256Init,
  CryptoServiceSha256Duplicate,
  CryptoServiceSha256Update,
  CryptoServiceSha256Final,
  CryptoServiceSha256HashAll,
  CryptoServiceSha384GetContextSize,
  CryptoServiceSha384Init,
  CryptoServiceSha384Duplicate,
  CryptoServiceSha384Update,
  CryptoServiceSha384Final,
  CryptoServiceSha384HashAll,
  CryptoServiceSha512GetContextSize,
  CryptoServiceSha512Init,
  CryptoServiceSha512Duplicate,
  CryptoServiceSha512Update,
  CryptoServiceSha512Final,
  CryptoServiceSha512HashAll,
  CryptoServiceX509GetSubjectName,
  CryptoServiceX509GetCommonName,
  CryptoServiceX509GetOrganizationName,
  CryptoServiceX509VerifyCert,
  CryptoServiceX509ConstructCertificate,
  CryptoServiceX509ConstructCertificateStack,
  CryptoServiceX509Free,
  CryptoServiceX509StackFree,
  CryptoServiceX509GetTBSCert,
  DeprecatedCryptoServiceTdesGetContextSize,
  DeprecatedCryptoServiceTdesInit,
  DeprecatedCryptoServiceTdesEcbEncrypt,
  DeprecatedCryptoServiceTdesEcbDecrypt,
  DeprecatedCryptoServiceTdesCbcEncrypt,
  DeprecatedCryptoServiceTdesCbcDecrypt,
  CryptoServiceAesGetContextSize,
  CryptoServiceAesInit,
  DeprecatedCryptoServiceAesEcbEncrypt,
  DeprecatedCryptoServiceAesEcbDecrypt,
  CryptoServiceAesCbcEncrypt,
  CryptoServiceAesCbcDecrypt,
  DeprecatedCryptoServiceArc4GetContextSize,
  DeprecatedCryptoServiceArc4Init,
  DeprecatedCryptoServiceArc4Encrypt,
  DeprecatedCryptoServiceArc4Decrypt,
  DeprecatedCryptoServiceArc4Reset,
  CryptoServiceSm3GetContextSize,
  CryptoServiceSm3Init,
  CryptoServiceSm3Duplicate,
  CryptoServiceSm3Update,
  CryptoServiceSm3Final,
  CryptoServiceSm3HashAll,
  CryptoServiceHkdfSha256ExtractAndExpand,
  CryptoServiceX509ConstructCertificateStackV,
  CryptoServiceTlsInitialize,
  CryptoServiceTlsCtxFree,
  CryptoServiceTlsCtxNew,
  CryptoServiceTlsFree,
  CryptoServiceTlsNew,
  CryptoServiceTlsInHandshake,
  CryptoServiceTlsDoHandshake,
  CryptoServiceTlsHandleAlert,
  CryptoServiceTlsCloseNotify,
  CryptoServiceTlsCtrlTrafficOut,
  CryptoServiceTlsCtrlTrafficIn,
  CryptoServiceTlsRead,
  CryptoServiceTlsWrite,
  CryptoServiceTlsSetVersion,
  CryptoServiceTlsSetConnectionEnd,
  CryptoServiceTlsSetCipherList,
  CryptoServiceTlsSetCompressionMethod,
  CryptoServiceTlsSetVerify,
  CryptoServiceTlsSetVerifyHost,
  CryptoServiceTlsSetSessionId,
  CryptoServiceTlsSetCaCertificate,
  CryptoServiceTlsSetHostPublicCert,
  CryptoServiceTlsSetHostPrivateKey,
  CryptoServiceTlsSetCertRevocationList,
  CryptoServiceTlsGetVersion,
  CryptoServiceTlsGetConnectionEnd,
  CryptoServiceTlsGetCurrentCipher,
  CryptoServiceTlsGetCurrentCompressionId,
  CryptoServiceTlsGetVerify,
  CryptoServiceTlsGetSessionId,
  CryptoServiceTlsGetClientRandom,
  CryptoServiceTlsGetServerRandom,
  CryptoServiceTlsGetKeyMaterial,
  CryptoServiceTlsGetCaCertificate,
  CryptoServiceTlsGetHostPublicCert,
  CryptoServiceTlsGetHostPrivateKey,
  CryptoServiceTlsGetCertRevocationList,
  CryptoServiceRsaPssSign,
  CryptoServiceRsaPssVerify,
  CryptoServiceParallelHash256HashAll,
  CryptoServiceHmacSha256All,
  CryptoServiceHmacSha384New,
  CryptoServiceHmacSha384Free,
  CryptoServiceHmacSha384SetKey,
  CryptoServiceHmacSha384Duplicate,
  CryptoServiceHmacSha384Update,
  CryptoServiceHmacSha384Final,
  CryptoServiceHmacSha384All,
  CryptoServiceHkdfSha256Extract,
  CryptoServiceHkdfSha256Expand,
  CryptoServiceHkdfSha384ExtractAndExpand,
  CryptoServiceHkdfSha384Extract,
  CryptoServiceHkdfSha384Expand,
  CryptoServiceAeadAesGcmEncrypt,
  CryptoServiceAeadAesGcmDecrypt,
  CryptoServiceBigNumInit,
  CryptoServiceBigNumFromBin,
  CryptoServiceBigNumToBin,
  CryptoServiceBigNumFree,
  CryptoServiceBigNumAdd,
  CryptoServiceBigNumSub,
  CryptoServiceBigNumMod,
  CryptoServiceBigNumExpMod,
  CryptoServiceBigNumInverseMod,
  CryptoServiceBigNumDiv,
  CryptoServiceBigNumMulMod,
  CryptoServiceBigNumCmp,
  CryptoServiceBigNumBits,
  CryptoServiceBigNumBytes,
  CryptoServiceBigNumIsWord,
  CryptoServiceBigNumIsOdd,
  CryptoServiceBigNumCopy,
  CryptoServiceBigNumValueOne,
  CryptoServiceBigNumRShift,
  CryptoServiceBigNumConstTime,
  CryptoServiceBigNumSqrMod,
  CryptoServiceBigNumNewContext,
  CryptoServiceBigNumContextFree,
  CryptoServiceBigNumSetUint,
  CryptoServiceBigNumAddMod,
  CryptoServiceEcGroupInit,
  CryptoServiceEcGroupGetCurve,
  CryptoServiceEcGroupGetOrder,
  CryptoServiceEcGroupFree,
  CryptoServiceEcPointInit,
  CryptoServiceEcPointDeInit,
  CryptoServiceEcPointGetAffineCoordinates,
  CryptoServiceEcPointSetAffineCoordinates,
  CryptoServiceEcPointAdd,
  CryptoServiceEcPointMul,
  CryptoServiceEcPointInvert,
  CryptoServiceEcPointIsOnCurve,
  CryptoServiceEcPointIsAtInfinity,
  CryptoServiceEcPointEqual,
  CryptoServiceEcPointSetCompressedCoordinates,
  CryptoServiceEcNewByNid,
  CryptoServiceEcFree,
  CryptoServiceEcGenerateKey,
  CryptoServiceEcGetPubKey,
  CryptoServiceEcDhComputeKey,
  CryptoServiceTlsShutdown,
  CryptoServiceTlsSetHostPrivateKeyEx,
  CryptoServiceTlsSetSignatureAlgoList,
  CryptoServiceTlsSetEcCurve,
  CryptoServiceTlsGetExportKey,
  CryptoServiceEcGetPublicKeyFromX509,
  CryptoServiceEcGetPrivateKeyFromPem,
  CryptoServiceEcDsaSign,
  CryptoServiceEcDsaVerify,
  CryptoServiceX509GetVersion,
  CryptoServiceX509GetSerialNumber,
  CryptoServiceX509GetIssuerName,
  CryptoServiceX509GetSignatureAlgorithm,
  CryptoServiceX509GetExtensionData,
  CryptoServiceX509GetExtendedKeyUsage,
  CryptoServiceX509GetValidity,
  CryptoServiceX509FormatDateTime,
  CryptoServiceX509CompareDateTime,
  CryptoServiceX509GetKeyUsage,
  CryptoServiceX509VerifyCertChain,
  CryptoServiceX509GetCertFromCertChain,
  CryptoServiceAsn1GetTag,
  CryptoServiceX509GetExtendedBasicConstraints,
  CryptoServicePkcs1v2Decrypt,
  CryptoServiceRsaOaepEncrypt,
  CryptoServiceRsaOaepDecrypt,
};