AlgorithmCap.c

// This file was extracted from the TCG Published
// Trusted Platform Module Library
// Part 4: Supporting Routines
// Family "2.0"
// Level 00 Revision 01.16
// October 30, 2014

#include "InternalRoutines.h"
typedef struct
{
   TPM_ALG_ID          algID;
   TPMA_ALGORITHM      attributes;
} ALGORITHM;
static const ALGORITHM    s_algorithms[]      =
{
#ifdef TPM_ALG_RSA
   {TPM_ALG_RSA,           {1, 0, 0, 1,       0, 0, 0, 0, 0}},
#endif
#ifdef TPM_ALG_DES
   {TPM_ALG_DES,           {0, 1, 0, 0,       0, 0, 0, 0, 0}},
#endif
#ifdef TPM_ALG_3DES
   {TPM_ALG__3DES,         {0, 1, 0, 0,       0, 0, 0, 0, 0}},
#endif
#ifdef TPM_ALG_SHA1
   {TPM_ALG_SHA1,          {0, 0, 1, 0,       0, 0, 0, 0, 0}},
#endif
#ifdef TPM_ALG_HMAC
   {TPM_ALG_HMAC,          {0, 0, 1, 0,       0, 1, 0, 0, 0}},
#endif
#ifdef TPM_ALG_AES
   {TPM_ALG_AES,           {0, 1, 0, 0,       0, 0, 0, 0, 0}},
#endif
#ifdef TPM_ALG_MGF1
   {TPM_ALG_MGF1,          {0, 0, 1, 0,       0, 0, 0, 1, 0}},
#endif
     {TPM_ALG_KEYEDHASH,         {0, 0, 1, 1, 0, 1, 1, 0, 0}},
#ifdef TPM_ALG_XOR
   {TPM_ALG_XOR,                 {0, 1, 1, 0, 0, 0, 0, 0, 0}},
#endif
#ifdef TPM_ALG_SHA256
   {TPM_ALG_SHA256,              {0, 0, 1, 0, 0, 0, 0, 0, 0}},
#endif
#ifdef TPM_ALG_SHA384
   {TPM_ALG_SHA384,              {0, 0, 1, 0, 0, 0, 0, 0, 0}},
#endif
#ifdef TPM_ALG_SHA512
   {TPM_ALG_SHA512,              {0, 0, 1, 0, 0, 0, 0, 0, 0}},
#endif
#ifdef TPM_ALG_WHIRLPOOL512
   {TPM_ALG_WHIRLPOOL512,        {0, 0, 1, 0, 0, 0, 0, 0, 0}},
#endif
#ifdef TPM_ALG_SM3_256
   {TPM_ALG_SM3_256,             {0, 0, 1, 0, 0, 0, 0, 0, 0}},
#endif
#ifdef TPM_ALG_SM4
   {TPM_ALG_SM4,          {0, 1, 0, 0, 0, 0, 0, 0, 0}},
#endif
#ifdef TPM_ALG_RSASSA
   {TPM_ALG_RSASSA,        {1, 0, 0, 0, 0, 1, 0, 0, 0}},
#endif
#ifdef TPM_ALG_RSAES
   {TPM_ALG_RSAES,         {1, 0, 0, 0, 0, 0, 1, 0, 0}},
#endif
#ifdef TPM_ALG_RSAPSS
   {TPM_ALG_RSAPSS,        {1, 0, 0, 0, 0, 1, 0, 0, 0}},
#endif
#ifdef TPM_ALG_OAEP
   {TPM_ALG_OAEP,          {1, 0, 0, 0, 0, 0, 1, 0, 0}},
#endif
#ifdef TPM_ALG_ECDSA
   {TPM_ALG_ECDSA,         {1, 0, 0, 0, 0, 1, 0, 1, 0}},
#endif
#ifdef TPM_ALG_ECDH
   {TPM_ALG_ECDH,          {1, 0, 0, 0, 0, 0, 0, 1, 0}},
#endif
#ifdef TPM_ALG_ECDAA
   {TPM_ALG_ECDAA,         {1, 0, 0, 0, 0, 1, 0, 0, 0}},
#endif
#ifdef TPM_ALG_ECSCHNORR
   {TPM_ALG_ECSCHNORR,     {1, 0, 0, 0, 0, 1, 0, 0, 0}},
#endif
#ifdef TPM_ALG_KDF1_SP800_56A
   {TPM_ALG_KDF1_SP800_56A,{0, 0, 1, 0, 0, 0, 0, 1, 0}},
#endif
#ifdef TPM_ALG_KDF2
   {TPM_ALG_KDF2,          {0, 0, 1, 0, 0, 0, 0, 1, 0}},
#endif
#ifdef TPM_ALG_KDF1_SP800_108
   {TPM_ALG_KDF1_SP800_108,{0, 0, 1, 0, 0, 0, 0, 1, 0}},
#endif
#ifdef TPM_ALG_ECC
   {TPM_ALG_ECC,           {1, 0, 0, 1, 0, 0, 0, 0, 0}},
#endif
   {TPM_ALG_SYMCIPHER,           {0, 0, 0, 1, 0, 0, 0, 0, 0}},
#ifdef TPM_ALG_CTR
   {TPM_ALG_CTR,                 {0, 1, 0, 0, 0, 0, 1, 0, 0}},
#endif
#ifdef TPM_ALG_OFB
   {TPM_ALG_OFB,                 {0, 1, 0, 0, 0, 0, 1, 0, 0}},
#endif
#ifdef TPM_ALG_CBC
   {TPM_ALG_CBC,                 {0, 1, 0, 0, 0, 0, 1, 0, 0}},
#endif
#ifdef TPM_ALG_CFB
   {TPM_ALG_CFB,                 {0, 1, 0, 0, 0, 0, 1, 0, 0}},
#endif
#ifdef TPM_ALG_ECB
   {TPM_ALG_ECB,                 {0, 1, 0, 0, 0, 0, 1, 0, 0}},
#endif
};
//
//
//          AlgorithmCapGetImplemented()
//
//      This function is used by TPM2_GetCapability() to return a list of the implemented algorithms.
//
//
//
//
//      Return Value                      Meaning
//
//      YES                               more algorithms to report
//      NO                                no more algorithms to report
//
TPMI_YES_NO
AlgorithmCapGetImplemented(
     TPM_ALG_ID                          algID,         // IN: the starting algorithm ID
     UINT32                              count,         // IN: count of returned algorithms
     TPML_ALG_PROPERTY                  *algList        // OUT: algorithm list
)
{
     TPMI_YES_NO      more = NO;
     UINT32           i;
     UINT32           algNum;
     // initialize output algorithm list
     algList->count = 0;
     // The maximum count of algorithms we may return is MAX_CAP_ALGS.
     if(count > MAX_CAP_ALGS)
         count = MAX_CAP_ALGS;
     // Compute how many algorithms are defined in s_algorithms array.
     algNum = sizeof(s_algorithms) / sizeof(s_algorithms[0]);
     // Scan the implemented algorithm list to see if there is a match to 'algID'.
     for(i = 0; i < algNum; i++)
     {
         // If algID is less than the starting algorithm ID, skip it
         if(s_algorithms[i].algID < algID)
              continue;
         if(algList->count < count)
         {
              // If we have not filled up the return list, add more algorithms
              // to it
              algList->algProperties[algList->count].alg = s_algorithms[i].algID;
              algList->algProperties[algList->count].algProperties =
                  s_algorithms[i].attributes;
              algList->count++;
         }
         else
         {
              // If the return list is full but we still have algorithms
              // available, report this and stop scanning.
              more = YES;
              break;
         }
     }
     return more;
}
LIB_EXPORT
void
AlgorithmGetImplementedVector(
     ALGORITHM_VECTOR      *implemented            // OUT: the implemented bits are SET
     )
{
     int                            index;
     // Nothing implemented until we say it is
     MemorySet(implemented, 0, sizeof(ALGORITHM_VECTOR));
     for(index = (sizeof(s_algorithms) / sizeof(s_algorithms[0])) - 1;
         index >= 0;
         index--)
             SET_BIT(s_algorithms[index].algID, *implemented);
     return;
}