/* Microsoft Reference Implementation for TPM 2.0
 *
 *  The copyright in this software is being made available under the BSD License,
 *  included below. This software may be subject to other third party and
 *  contributor rights, including patent rights, and no such rights are granted
 *  under this license.
 *
 *  Copyright (c) Microsoft Corporation
 *
 *  All rights reserved.
 *
 *  BSD License
 *
 *  Redistribution and use in source and binary forms, with or without modification,
 *  are permitted provided that the following conditions are met:
 *
 *  Redistributions of source code must retain the above copyright notice, this list
 *  of conditions and the following disclaimer.
 *
 *  Redistributions in binary form must reproduce the above copyright notice, this
 *  list of conditions and the following disclaimer in the documentation and/or
 *  other materials provided with the distribution.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS""
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
 *  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 *  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 *  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/*(Auto-generated)
 *  Created by TpmStructures; Version 4.4 Mar 26, 2019
 *  Date: Feb 28, 2020  Time: 03:04:46PM
 */

#ifndef _TPM_ALGORITHM_DEFINES_H_
#define _TPM_ALGORITHM_DEFINES_H_

// Table 2:3 - Definition of Base Types
// Base Types are in BaseTypes.h

#define ECC_CURVES                      \
            {TPM_ECC_BN_P256,   TPM_ECC_BN_P638,   TPM_ECC_NIST_P192,              \
             TPM_ECC_NIST_P224, TPM_ECC_NIST_P256, TPM_ECC_NIST_P384,              \
             TPM_ECC_NIST_P521, TPM_ECC_SM2_P256}
#define ECC_CURVE_COUNT                 \
            (ECC_BN_P256   + ECC_BN_P638   + ECC_NIST_P192 + ECC_NIST_P224 +       \
             ECC_NIST_P256 + ECC_NIST_P384 + ECC_NIST_P521 + ECC_SM2_P256)
#define MAX_ECC_KEY_BITS                \
            MAX(ECC_BN_P256 * 256,   MAX(ECC_BN_P638 * 638,                        \
            MAX(ECC_NIST_P192 * 192, MAX(ECC_NIST_P224 * 224,                      \
            MAX(ECC_NIST_P256 * 256, MAX(ECC_NIST_P384 * 384,                      \
            MAX(ECC_NIST_P521 * 521, MAX(ECC_SM2_P256 * 256,                       \
            0))))))))
#define MAX_ECC_KEY_BYTES               BITS_TO_BYTES(MAX_ECC_KEY_BITS)

// Table 0:6 - Defines for PLATFORM Values
#define PLATFORM_FAMILY         TPM_SPEC_FAMILY
#define PLATFORM_LEVEL          TPM_SPEC_LEVEL
#define PLATFORM_VERSION        TPM_SPEC_VERSION
#define PLATFORM_YEAR           TPM_SPEC_YEAR
#define PLATFORM_DAY_OF_YEAR    TPM_SPEC_DAY_OF_YEAR

// Table 1:3 - Defines for RSA Asymmetric Cipher Algorithm Constants
#define RSA_KEY_SIZES_BITS          \
            (1024 * RSA_1024),  (2048 * RSA_2048), (3072 * RSA_3072),              \
             (4096 * RSA_4096), (16384 * RSA_16384)
#if   RSA_16384
#   define RSA_MAX_KEY_SIZE_BITS    16384
#elif RSA_4096
#   define RSA_MAX_KEY_SIZE_BITS    4096
#elif RSA_3072
#   define RSA_MAX_KEY_SIZE_BITS    3072
#elif RSA_2048
#   define RSA_MAX_KEY_SIZE_BITS    2048
#elif RSA_1024
#   define RSA_MAX_KEY_SIZE_BITS    1024
#else
#   define RSA_MAX_KEY_SIZE_BITS    0
#endif
#define MAX_RSA_KEY_BITS            RSA_MAX_KEY_SIZE_BITS
#define MAX_RSA_KEY_BYTES           ((RSA_MAX_KEY_SIZE_BITS + 7) / 8)

// Table 1:13 - Defines for SHA1 Hash Values
#define SHA1_DIGEST_SIZE    20
#define SHA1_BLOCK_SIZE     64

// Table 1:14 - Defines for SHA256 Hash Values
#define SHA256_DIGEST_SIZE  32
#define SHA256_BLOCK_SIZE   64

// Table 1:15 - Defines for SHA384 Hash Values
#define SHA384_DIGEST_SIZE  48
#define SHA384_BLOCK_SIZE   128

// Table 1:16 - Defines for SHA512 Hash Values
#define SHA512_DIGEST_SIZE  64
#define SHA512_BLOCK_SIZE   128

// Table 1:17 - Defines for SM3_256 Hash Values
#define SM3_256_DIGEST_SIZE     32
#define SM3_256_BLOCK_SIZE      64

// Table 1:18 - Defines for SHA3_256 Hash Values
#define SHA3_256_DIGEST_SIZE    32
#define SHA3_256_BLOCK_SIZE     136

// Table 1:19 - Defines for SHA3_384 Hash Values
#define SHA3_384_DIGEST_SIZE    48
#define SHA3_384_BLOCK_SIZE     104

// Table 1:20 - Defines for SHA3_512 Hash Values
#define SHA3_512_DIGEST_SIZE    64
#define SHA3_512_BLOCK_SIZE     72

// Table 1:21 - Defines for AES Symmetric Cipher Algorithm Constants
#define AES_KEY_SIZES_BITS          \
            (128 * AES_128), (192 * AES_192), (256 * AES_256)
#if   AES_256
#   define AES_MAX_KEY_SIZE_BITS    256
#elif AES_192
#   define AES_MAX_KEY_SIZE_BITS    192
#elif AES_128
#   define AES_MAX_KEY_SIZE_BITS    128
#else
#   define AES_MAX_KEY_SIZE_BITS    0
#endif
#define MAX_AES_KEY_BITS            AES_MAX_KEY_SIZE_BITS
#define MAX_AES_KEY_BYTES           ((AES_MAX_KEY_SIZE_BITS + 7) / 8)
#define AES_128_BLOCK_SIZE_BYTES    (AES_128 * 16)
#define AES_192_BLOCK_SIZE_BYTES    (AES_192 * 16)
#define AES_256_BLOCK_SIZE_BYTES    (AES_256 * 16)
#define AES_BLOCK_SIZES             \
            AES_128_BLOCK_SIZE_BYTES, AES_192_BLOCK_SIZE_BYTES,                    \
            AES_256_BLOCK_SIZE_BYTES
#if   ALG_AES
#   define AES_MAX_BLOCK_SIZE       16
#else
#   define AES_MAX_BLOCK_SIZE       0
#endif
#define MAX_AES_BLOCK_SIZE_BYTES    AES_MAX_BLOCK_SIZE

// Table 1:22 - Defines for SM4 Symmetric Cipher Algorithm Constants
#define SM4_KEY_SIZES_BITS          (128 * SM4_128)
#if   SM4_128
#   define SM4_MAX_KEY_SIZE_BITS    128
#else
#   define SM4_MAX_KEY_SIZE_BITS    0
#endif
#define MAX_SM4_KEY_BITS            SM4_MAX_KEY_SIZE_BITS
#define MAX_SM4_KEY_BYTES           ((SM4_MAX_KEY_SIZE_BITS + 7) / 8)
#define SM4_128_BLOCK_SIZE_BYTES    (SM4_128 * 16)
#define SM4_BLOCK_SIZES             SM4_128_BLOCK_SIZE_BYTES
#if   ALG_SM4
#   define SM4_MAX_BLOCK_SIZE       16
#else
#   define SM4_MAX_BLOCK_SIZE       0
#endif
#define MAX_SM4_BLOCK_SIZE_BYTES    SM4_MAX_BLOCK_SIZE

// Table 1:23 - Defines for CAMELLIA Symmetric Cipher Algorithm Constants
#define CAMELLIA_KEY_SIZES_BITS         \
            (128 * CAMELLIA_128), (192 * CAMELLIA_192), (256 * CAMELLIA_256)
#if   CAMELLIA_256
#   define CAMELLIA_MAX_KEY_SIZE_BITS   256
#elif CAMELLIA_192
#   define CAMELLIA_MAX_KEY_SIZE_BITS   192
#elif CAMELLIA_128
#   define CAMELLIA_MAX_KEY_SIZE_BITS   128
#else
#   define CAMELLIA_MAX_KEY_SIZE_BITS   0
#endif
#define MAX_CAMELLIA_KEY_BITS           CAMELLIA_MAX_KEY_SIZE_BITS
#define MAX_CAMELLIA_KEY_BYTES          ((CAMELLIA_MAX_KEY_SIZE_BITS + 7) / 8)
#define CAMELLIA_128_BLOCK_SIZE_BYTES   (CAMELLIA_128 * 16)
#define CAMELLIA_192_BLOCK_SIZE_BYTES   (CAMELLIA_192 * 16)
#define CAMELLIA_256_BLOCK_SIZE_BYTES   (CAMELLIA_256 * 16)
#define CAMELLIA_BLOCK_SIZES            \
            CAMELLIA_128_BLOCK_SIZE_BYTES, CAMELLIA_192_BLOCK_SIZE_BYTES,          \
            CAMELLIA_256_BLOCK_SIZE_BYTES
#if   ALG_CAMELLIA
#   define CAMELLIA_MAX_BLOCK_SIZE      16
#else
#   define CAMELLIA_MAX_BLOCK_SIZE      0
#endif
#define MAX_CAMELLIA_BLOCK_SIZE_BYTES   CAMELLIA_MAX_BLOCK_SIZE

// Table 1:24 - Defines for TDES Symmetric Cipher Algorithm Constants
#define TDES_KEY_SIZES_BITS         (128 * TDES_128), (192 * TDES_192)
#if   TDES_192
#   define TDES_MAX_KEY_SIZE_BITS   192
#elif TDES_128
#   define TDES_MAX_KEY_SIZE_BITS   128
#else
#   define TDES_MAX_KEY_SIZE_BITS   0
#endif
#define MAX_TDES_KEY_BITS           TDES_MAX_KEY_SIZE_BITS
#define MAX_TDES_KEY_BYTES          ((TDES_MAX_KEY_SIZE_BITS + 7) / 8)
#define TDES_128_BLOCK_SIZE_BYTES   (TDES_128 * 8)
#define TDES_192_BLOCK_SIZE_BYTES   (TDES_192 * 8)
#define TDES_BLOCK_SIZES            \
            TDES_128_BLOCK_SIZE_BYTES, TDES_192_BLOCK_SIZE_BYTES
#if   ALG_TDES
#   define TDES_MAX_BLOCK_SIZE      8
#else
#   define TDES_MAX_BLOCK_SIZE      0
#endif
#define MAX_TDES_BLOCK_SIZE_BYTES   TDES_MAX_BLOCK_SIZE

// Additional values for benefit of code
#define TPM_CC_FIRST                        0x0000011F
#define TPM_CC_LAST                         0x0000019A

   
#if COMPRESSED_LISTS
#define ADD_FILL            0
#else
#define ADD_FILL            1
#endif

// Size the array of library commands based on whether or not
// the array is packed (only defined commands) or dense
// (having entries for unimplemented commands)
#define LIBRARY_COMMAND_ARRAY_SIZE       (0      \
    + (ADD_FILL || CC_NV_UndefineSpaceSpecial)              /* 0x0000011F */       \
    + (ADD_FILL || CC_EvictControl)                         /* 0x00000120 */       \
    + (ADD_FILL || CC_HierarchyControl)                     /* 0x00000121 */       \
    + (ADD_FILL || CC_NV_UndefineSpace)                     /* 0x00000122 */       \
    +  ADD_FILL                                             /* 0x00000123 */       \
    + (ADD_FILL || CC_ChangeEPS)                            /* 0x00000124 */       \
    + (ADD_FILL || CC_ChangePPS)                            /* 0x00000125 */       \
    + (ADD_FILL || CC_Clear)                                /* 0x00000126 */       \
    + (ADD_FILL || CC_ClearControl)                         /* 0x00000127 */       \
    + (ADD_FILL || CC_ClockSet)                             /* 0x00000128 */       \
    + (ADD_FILL || CC_HierarchyChangeAuth)                  /* 0x00000129 */       \
    + (ADD_FILL || CC_NV_DefineSpace)                       /* 0x0000012A */       \
    + (ADD_FILL || CC_PCR_Allocate)                         /* 0x0000012B */       \
    + (ADD_FILL || CC_PCR_SetAuthPolicy)                    /* 0x0000012C */       \
    + (ADD_FILL || CC_PP_Commands)                          /* 0x0000012D */       \
    + (ADD_FILL || CC_SetPrimaryPolicy)                     /* 0x0000012E */       \
    + (ADD_FILL || CC_FieldUpgradeStart)                    /* 0x0000012F */       \
    + (ADD_FILL || CC_ClockRateAdjust)                      /* 0x00000130 */       \
    + (ADD_FILL || CC_CreatePrimary)                        /* 0x00000131 */       \
    + (ADD_FILL || CC_NV_GlobalWriteLock)                   /* 0x00000132 */       \
    + (ADD_FILL || CC_GetCommandAuditDigest)                /* 0x00000133 */       \
    + (ADD_FILL || CC_NV_Increment)                         /* 0x00000134 */       \
    + (ADD_FILL || CC_NV_SetBits)                           /* 0x00000135 */       \
    + (ADD_FILL || CC_NV_Extend)                            /* 0x00000136 */       \
    + (ADD_FILL || CC_NV_Write)                             /* 0x00000137 */       \
    + (ADD_FILL || CC_NV_WriteLock)                         /* 0x00000138 */       \
    + (ADD_FILL || CC_DictionaryAttackLockReset)            /* 0x00000139 */       \
    + (ADD_FILL || CC_DictionaryAttackParameters)           /* 0x0000013A */       \
    + (ADD_FILL || CC_NV_ChangeAuth)                        /* 0x0000013B */       \
    + (ADD_FILL || CC_PCR_Event)                            /* 0x0000013C */       \
    + (ADD_FILL || CC_PCR_Reset)                            /* 0x0000013D */       \
    + (ADD_FILL || CC_SequenceComplete)                     /* 0x0000013E */       \
    + (ADD_FILL || CC_SetAlgorithmSet)                      /* 0x0000013F */       \
    + (ADD_FILL || CC_SetCommandCodeAuditStatus)            /* 0x00000140 */       \
    + (ADD_FILL || CC_FieldUpgradeData)                     /* 0x00000141 */       \
    + (ADD_FILL || CC_IncrementalSelfTest)                  /* 0x00000142 */       \
    + (ADD_FILL || CC_SelfTest)                             /* 0x00000143 */       \
    + (ADD_FILL || CC_Startup)                              /* 0x00000144 */       \
    + (ADD_FILL || CC_Shutdown)                             /* 0x00000145 */       \
    + (ADD_FILL || CC_StirRandom)                           /* 0x00000146 */       \
    + (ADD_FILL || CC_ActivateCredential)                   /* 0x00000147 */       \
    + (ADD_FILL || CC_Certify)                              /* 0x00000148 */       \
    + (ADD_FILL || CC_PolicyNV)                             /* 0x00000149 */       \
    + (ADD_FILL || CC_CertifyCreation)                      /* 0x0000014A */       \
    + (ADD_FILL || CC_Duplicate)                            /* 0x0000014B */       \
    + (ADD_FILL || CC_GetTime)                              /* 0x0000014C */       \
    + (ADD_FILL || CC_GetSessionAuditDigest)                /* 0x0000014D */       \
    + (ADD_FILL || CC_NV_Read)                              /* 0x0000014E */       \
    + (ADD_FILL || CC_NV_ReadLock)                          /* 0x0000014F */       \
    + (ADD_FILL || CC_ObjectChangeAuth)                     /* 0x00000150 */       \
    + (ADD_FILL || CC_PolicySecret)                         /* 0x00000151 */       \
    + (ADD_FILL || CC_Rewrap)                               /* 0x00000152 */       \
    + (ADD_FILL || CC_Create)                               /* 0x00000153 */       \
    + (ADD_FILL || CC_ECDH_ZGen)                            /* 0x00000154 */       \
    + (ADD_FILL || CC_HMAC || CC_MAC)                       /* 0x00000155 */       \
    + (ADD_FILL || CC_Import)                               /* 0x00000156 */       \
    + (ADD_FILL || CC_Load)                                 /* 0x00000157 */       \
    + (ADD_FILL || CC_Quote)                                /* 0x00000158 */       \
    + (ADD_FILL || CC_RSA_Decrypt)                          /* 0x00000159 */       \
    +  ADD_FILL                                             /* 0x0000015A */       \
    + (ADD_FILL || CC_HMAC_Start || CC_MAC_Start)           /* 0x0000015B */       \
    + (ADD_FILL || CC_SequenceUpdate)                       /* 0x0000015C */       \
    + (ADD_FILL || CC_Sign)                                 /* 0x0000015D */       \
    + (ADD_FILL || CC_Unseal)                               /* 0x0000015E */       \
    +  ADD_FILL                                             /* 0x0000015F */       \
    + (ADD_FILL || CC_PolicySigned)                         /* 0x00000160 */       \
    + (ADD_FILL || CC_ContextLoad)                          /* 0x00000161 */       \
    + (ADD_FILL || CC_ContextSave)                          /* 0x00000162 */       \
    + (ADD_FILL || CC_ECDH_KeyGen)                          /* 0x00000163 */       \
    + (ADD_FILL || CC_EncryptDecrypt)                       /* 0x00000164 */       \
    + (ADD_FILL || CC_FlushContext)                         /* 0x00000165 */       \
    +  ADD_FILL                                             /* 0x00000166 */       \
    + (ADD_FILL || CC_LoadExternal)                         /* 0x00000167 */       \
    + (ADD_FILL || CC_MakeCredential)                       /* 0x00000168 */       \
    + (ADD_FILL || CC_NV_ReadPublic)                        /* 0x00000169 */       \
    + (ADD_FILL || CC_PolicyAuthorize)                      /* 0x0000016A */       \
    + (ADD_FILL || CC_PolicyAuthValue)                      /* 0x0000016B */       \
    + (ADD_FILL || CC_PolicyCommandCode)                    /* 0x0000016C */       \
    + (ADD_FILL || CC_PolicyCounterTimer)                   /* 0x0000016D */       \
    + (ADD_FILL || CC_PolicyCpHash)                         /* 0x0000016E */       \
    + (ADD_FILL || CC_PolicyLocality)                       /* 0x0000016F */       \
    + (ADD_FILL || CC_PolicyNameHash)                       /* 0x00000170 */       \
    + (ADD_FILL || CC_PolicyOR)                             /* 0x00000171 */       \
    + (ADD_FILL || CC_PolicyTicket)                         /* 0x00000172 */       \
    + (ADD_FILL || CC_ReadPublic)                           /* 0x00000173 */       \
    + (ADD_FILL || CC_RSA_Encrypt)                          /* 0x00000174 */       \
    +  ADD_FILL                                             /* 0x00000175 */       \
    + (ADD_FILL || CC_StartAuthSession)                     /* 0x00000176 */       \
    + (ADD_FILL || CC_VerifySignature)                      /* 0x00000177 */       \
    + (ADD_FILL || CC_ECC_Parameters)                       /* 0x00000178 */       \
    + (ADD_FILL || CC_FirmwareRead)                         /* 0x00000179 */       \
    + (ADD_FILL || CC_GetCapability)                        /* 0x0000017A */       \
    + (ADD_FILL || CC_GetRandom)                            /* 0x0000017B */       \
    + (ADD_FILL || CC_GetTestResult)                        /* 0x0000017C */       \
    + (ADD_FILL || CC_Hash)                                 /* 0x0000017D */       \
    + (ADD_FILL || CC_PCR_Read)                             /* 0x0000017E */       \
    + (ADD_FILL || CC_PolicyPCR)                            /* 0x0000017F */       \
    + (ADD_FILL || CC_PolicyRestart)                        /* 0x00000180 */       \
    + (ADD_FILL || CC_ReadClock)                            /* 0x00000181 */       \
    + (ADD_FILL || CC_PCR_Extend)                           /* 0x00000182 */       \
    + (ADD_FILL || CC_PCR_SetAuthValue)                     /* 0x00000183 */       \
    + (ADD_FILL || CC_NV_Certify)                           /* 0x00000184 */       \
    + (ADD_FILL || CC_EventSequenceComplete)                /* 0x00000185 */       \
    + (ADD_FILL || CC_HashSequenceStart)                    /* 0x00000186 */       \
    + (ADD_FILL || CC_PolicyPhysicalPresence)               /* 0x00000187 */       \
    + (ADD_FILL || CC_PolicyDuplicationSelect)              /* 0x00000188 */       \
    + (ADD_FILL || CC_PolicyGetDigest)                      /* 0x00000189 */       \
    + (ADD_FILL || CC_TestParms)                            /* 0x0000018A */       \
    + (ADD_FILL || CC_Commit)                               /* 0x0000018B */       \
    + (ADD_FILL || CC_PolicyPassword)                       /* 0x0000018C */       \
    + (ADD_FILL || CC_ZGen_2Phase)                          /* 0x0000018D */       \
    + (ADD_FILL || CC_EC_Ephemeral)                         /* 0x0000018E */       \
    + (ADD_FILL || CC_PolicyNvWritten)                      /* 0x0000018F */       \
    + (ADD_FILL || CC_PolicyTemplate)                       /* 0x00000190 */       \
    + (ADD_FILL || CC_CreateLoaded)                         /* 0x00000191 */       \
    + (ADD_FILL || CC_PolicyAuthorizeNV)                    /* 0x00000192 */       \
    + (ADD_FILL || CC_EncryptDecrypt2)                      /* 0x00000193 */       \
    + (ADD_FILL || CC_AC_GetCapability)                     /* 0x00000194 */       \
    + (ADD_FILL || CC_AC_Send)                              /* 0x00000195 */       \
    + (ADD_FILL || CC_Policy_AC_SendSelect)                 /* 0x00000196 */       \
    + (ADD_FILL || CC_CertifyX509)                          /* 0x00000197 */       \
    + (ADD_FILL || CC_ACT_SetTimeout)                       /* 0x00000198 */       \
    + (ADD_FILL || CC_ECC_Encrypt)                          /* 0x00000199 */       \
    + (ADD_FILL || CC_ECC_Decrypt)                          /* 0x0000019A */       \
    )

#define VENDOR_COMMAND_ARRAY_SIZE   (0 + CC_Vendor_TCG_Test)

#define COMMAND_COUNT       (LIBRARY_COMMAND_ARRAY_SIZE + VENDOR_COMMAND_ARRAY_SIZE)

#define HASH_COUNT          \
            (ALG_SHA1     + ALG_SHA256   + ALG_SHA384   + ALG_SHA3_256 +           \
             ALG_SHA3_384 + ALG_SHA3_512 + ALG_SHA512   + ALG_SM3_256)

#define MAX_HASH_BLOCK_SIZE \
            (MAX(ALG_SHA1     * SHA1_BLOCK_SIZE,                                   \
             MAX(ALG_SHA256   * SHA256_BLOCK_SIZE,                                 \
             MAX(ALG_SHA384   * SHA384_BLOCK_SIZE,                                 \
             MAX(ALG_SHA3_256 * SHA3_256_BLOCK_SIZE,                               \
             MAX(ALG_SHA3_384 * SHA3_384_BLOCK_SIZE,                               \
             MAX(ALG_SHA3_512 * SHA3_512_BLOCK_SIZE,                               \
             MAX(ALG_SHA512   * SHA512_BLOCK_SIZE,                                 \
             MAX(ALG_SM3_256  * SM3_256_BLOCK_SIZE,                                \
             0)))))))))

#define MAX_DIGEST_SIZE     \
            (MAX(ALG_SHA1     * SHA1_DIGEST_SIZE,                                  \
             MAX(ALG_SHA256   * SHA256_DIGEST_SIZE,                                \
             MAX(ALG_SHA384   * SHA384_DIGEST_SIZE,                                \
             MAX(ALG_SHA3_256 * SHA3_256_DIGEST_SIZE,                              \
             MAX(ALG_SHA3_384 * SHA3_384_DIGEST_SIZE,                              \
             MAX(ALG_SHA3_512 * SHA3_512_DIGEST_SIZE,                              \
             MAX(ALG_SHA512   * SHA512_DIGEST_SIZE,                                \
             MAX(ALG_SM3_256  * SM3_256_DIGEST_SIZE,                               \
             0)))))))))

#if MAX_DIGEST_SIZE == 0 || MAX_HASH_BLOCK_SIZE == 0
#error "Hash data not valid"
#endif

// Define the 2B structure that would hold any hash block
TPM2B_TYPE(MAX_HASH_BLOCK, MAX_HASH_BLOCK_SIZE);

// Following typedef is for some old code
typedef TPM2B_MAX_HASH_BLOCK    TPM2B_HASH_BLOCK;

/* Additional symmetric constants */
#define MAX_SYM_KEY_BITS        \
            (MAX(AES_MAX_KEY_SIZE_BITS,      MAX(CAMELLIA_MAX_KEY_SIZE_BITS,       \
             MAX(SM4_MAX_KEY_SIZE_BITS,      MAX(TDES_MAX_KEY_SIZE_BITS,           \
             0)))))

#define MAX_SYM_KEY_BYTES       ((MAX_SYM_KEY_BITS + 7) / 8)

#define MAX_SYM_BLOCK_SIZE      \
            (MAX(AES_MAX_BLOCK_SIZE,      MAX(CAMELLIA_MAX_BLOCK_SIZE,             \
             MAX(SM4_MAX_BLOCK_SIZE,      MAX(TDES_MAX_BLOCK_SIZE,                 \
             0)))))

#if MAX_SYM_KEY_BITS == 0 || MAX_SYM_BLOCK_SIZE == 0
#   error Bad size for MAX_SYM_KEY_BITS or MAX_SYM_BLOCK
#endif


#endif // _TPM_ALGORITHM_DEFINES_H_