Proxmox-Port/libtpms
1
0
Fork 0
mirror of https://github.com/stefanberger/libtpms synced 2026-01-23 23:45:58 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

rev148: Use #if ALG_* rather than #ifdef TPM_ALG_*

Browse Source 
Signed-off-by: Stefan Berger <stefanb@linux.vnet.ibm.com>
This commit is contained in:
Stefan Berger 2018-07-11 17:06:25 -04:00 committed by Stefan Berger
parent 2d972055aa
commit ff1f1305f5
43 changed files with 767 additions and 768 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
src/tpm2/AlgorithmCap.c
View File

@ -1,9 +1,9 @@
/********************************************************************************/
/* */
/* */
/* Algorithm Property Definitions */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: AlgorithmCap.c 1047 2017-07-20 18:27:34Z kgoldman $ */
/* $Id: AlgorithmCap.c 1259 2018-07-10 19:11:09Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -55,7 +55,7 @@
/* arising in any way out of use or reliance upon this specification or any */
/* information herein. */
/* */
/* (c) Copyright IBM Corp. and others, 2016, 2017 */
/* (c) Copyright IBM Corp. and others, 2016 - 2018 */
/* */
/********************************************************************************/
@ -75,103 +75,103 @@ static const ALGORITHM s_algorithms[] =
// The entries in this table need to be in ascending order but the table doesn't
// need to be full (gaps are allowed). One day, a tool might exist to fill in the
// table from the TPM_ALG description
#ifdef TPM_ALG_RSA
#if ALG_RSA
{TPM_ALG_RSA, TPMA_ALGORITHM_INITIALIZER(1, 0, 0, 1, 0, 0, 0, 0, 0)},
#endif
#ifdef TPM_ALG_TDES
#if ALG_TDES
{TPM_ALG_TDES, TPMA_ALGORITHM_INITIALIZER(0, 1, 0, 0, 0, 0, 0, 0, 0)},
#endif
#ifdef TPM_ALG_SHA1
#if ALG_SHA1
{TPM_ALG_SHA1, TPMA_ALGORITHM_INITIALIZER(0, 0, 1, 0, 0, 0, 0, 0, 0)},
#endif
{TPM_ALG_HMAC, TPMA_ALGORITHM_INITIALIZER(0, 0, 1, 0, 0, 1, 0, 0, 0)},
#ifdef TPM_ALG_AES
#if ALG_AES
{TPM_ALG_AES, TPMA_ALGORITHM_INITIALIZER(0, 1, 0, 0, 0, 0, 0, 0, 0)},
#endif
#ifdef TPM_ALG_MGF1
#if ALG_MGF1
{TPM_ALG_MGF1, TPMA_ALGORITHM_INITIALIZER(0, 0, 1, 0, 0, 0, 0, 1, 0)},
#endif
{TPM_ALG_KEYEDHASH, TPMA_ALGORITHM_INITIALIZER(0, 0, 1, 1, 0, 1, 1, 0, 0)},
#ifdef TPM_ALG_XOR
#if ALG_XOR
{TPM_ALG_XOR, TPMA_ALGORITHM_INITIALIZER(0, 1, 1, 0, 0, 0, 0, 0, 0)},
#endif
#ifdef TPM_ALG_SHA256
#if ALG_SHA256
{TPM_ALG_SHA256, TPMA_ALGORITHM_INITIALIZER(0, 0, 1, 0, 0, 0, 0, 0, 0)},
#endif
#ifdef TPM_ALG_SHA384
#if ALG_SHA384
{TPM_ALG_SHA384, TPMA_ALGORITHM_INITIALIZER(0, 0, 1, 0, 0, 0, 0, 0, 0)},
#endif
#ifdef TPM_ALG_SHA512
#if ALG_SHA512
{TPM_ALG_SHA512, TPMA_ALGORITHM_INITIALIZER(0, 0, 1, 0, 0, 0, 0, 0, 0)},
#endif
#ifdef TPM_ALG_SM3_256
#if ALG_SM3_256
{TPM_ALG_SM3_256, TPMA_ALGORITHM_INITIALIZER(0, 0, 1, 0, 0, 0, 0, 0, 0)},
#endif
#ifdef TPM_ALG_SM4
#if ALG_SM4
{TPM_ALG_SM4, TPMA_ALGORITHM_INITIALIZER(0, 1, 0, 0, 0, 0, 0, 0, 0)},
#endif
#ifdef TPM_ALG_RSASSA
#if ALG_RSASSA
{TPM_ALG_RSASSA, TPMA_ALGORITHM_INITIALIZER(1, 0, 0, 0, 0, 1, 0, 0, 0)},
#endif
#ifdef TPM_ALG_RSAES
#if ALG_RSAES
{TPM_ALG_RSAES, TPMA_ALGORITHM_INITIALIZER(1, 0, 0, 0, 0, 0, 1, 0, 0)},
#endif
#ifdef TPM_ALG_RSAPSS
#if ALG_RSAPSS
{TPM_ALG_RSAPSS, TPMA_ALGORITHM_INITIALIZER(1, 0, 0, 0, 0, 1, 0, 0, 0)},
#endif
#ifdef TPM_ALG_OAEP
#if ALG_OAEP
{TPM_ALG_OAEP, TPMA_ALGORITHM_INITIALIZER(1, 0, 0, 0, 0, 0, 1, 0, 0)},
#endif
#ifdef TPM_ALG_ECDSA
#if ALG_ECDSA
{TPM_ALG_ECDSA, TPMA_ALGORITHM_INITIALIZER(1, 0, 0, 0, 0, 1, 0, 1, 0)},
#endif
#ifdef TPM_ALG_ECDH
#if ALG_ECDH
{TPM_ALG_ECDH, TPMA_ALGORITHM_INITIALIZER(1, 0, 0, 0, 0, 0, 0, 1, 0)},
#endif
#ifdef TPM_ALG_ECDAA
#if ALG_ECDAA
{TPM_ALG_ECDAA, TPMA_ALGORITHM_INITIALIZER(1, 0, 0, 0, 0, 1, 0, 0, 0)},
#endif
#ifdef TPM_ALG_SM2
#if ALG_SM2
{TPM_ALG_SM2, TPMA_ALGORITHM_INITIALIZER(1, 0, 0, 0, 0, 1, 0, 1, 0)},
#endif
#ifdef TPM_ALG_ECSCHNORR
#if ALG_ECSCHNORR
{TPM_ALG_ECSCHNORR, TPMA_ALGORITHM_INITIALIZER(1, 0, 0, 0, 0, 1, 0, 0, 0)},
#endif
#ifdef TPM_ALG_ECMQV
#if ALG_ECMQV
{TPM_ALG_ECMQV, TPMA_ALGORITHM_INITIALIZER(1, 0, 0, 0, 0, 0, 0, 1, 0)},
#endif
#ifdef TPM_ALG_KDF1_SP800_56A
#if ALG_KDF1_SP800_56A
{TPM_ALG_KDF1_SP800_56A, TPMA_ALGORITHM_INITIALIZER(0, 0, 1, 0, 0, 0, 0, 1, 0)},
#endif
#ifdef TPM_ALG_KDF2
#if ALG_KDF2
{TPM_ALG_KDF2, TPMA_ALGORITHM_INITIALIZER(0, 0, 1, 0, 0, 0, 0, 1, 0)},
#endif
#ifdef TPM_ALG_KDF1_SP800_108
#if ALG_KDF1_SP800_108
{TPM_ALG_KDF1_SP800_108, TPMA_ALGORITHM_INITIALIZER(0, 0, 1, 0, 0, 0, 0, 1, 0)},
#endif
#ifdef TPM_ALG_ECC
#if ALG_ECC
{TPM_ALG_ECC, TPMA_ALGORITHM_INITIALIZER(1, 0, 0, 1, 0, 0, 0, 0, 0)},
#endif
{TPM_ALG_SYMCIPHER, TPMA_ALGORITHM_INITIALIZER(0, 0, 0, 1, 0, 0, 0, 0, 0)},
#ifdef TPM_ALG_CAMELLIA
#if ALG_CAMELLIA
{TPM_ALG_CAMELLIA, TPMA_ALGORITHM_INITIALIZER(0, 1, 0, 0, 0, 0, 0, 0, 0)},
#endif
#ifdef TPM_ALG_CMAC
#if ALG_CMAC
{TPM_ALG_CMAC, TPMA_ALGORITHM_INITIALIZER(0, 1, 0, 0, 0, 1, 0, 0, 0)},
#endif
#ifdef TPM_ALG_CTR
#if ALG_CTR
{TPM_ALG_CTR, TPMA_ALGORITHM_INITIALIZER(0, 1, 0, 0, 0, 0, 1, 0, 0)},
#endif
#ifdef TPM_ALG_OFB
#if ALG_OFB
{TPM_ALG_OFB, TPMA_ALGORITHM_INITIALIZER(0, 1, 0, 0, 0, 0, 1, 0, 0)},
#endif
#ifdef TPM_ALG_CBC
#if ALG_CBC
{TPM_ALG_CBC, TPMA_ALGORITHM_INITIALIZER(0, 1, 0, 0, 0, 0, 1, 0, 0)},
#endif
#ifdef TPM_ALG_CFB
#if ALG_CFB
{TPM_ALG_CFB, TPMA_ALGORITHM_INITIALIZER(0, 1, 0, 0, 0, 0, 1, 0, 0)},
#endif
#ifdef TPM_ALG_ECB
#if ALG_ECB
{TPM_ALG_ECB, TPMA_ALGORITHM_INITIALIZER(0, 1, 0, 0, 0, 0, 1, 0, 0)},
#endif
};

40
src/tpm2/AlgorithmTests.c
View File

@ -3,7 +3,7 @@
/* Code to perform the various self-test functions. */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: AlgorithmTests.c 1259 2018-07-10 19:11:09Z kgoldman $ */
/* $Id: AlgorithmTests.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -312,7 +312,7 @@ TestSymmetric(
return TPM_RC_SUCCESS;
}
/* 10.2.1.5 RSA Tests */
#ifdef TPM_ALG_RSA
#if ALG_RSA
/* 10.2.1.5.1 Introduction */
/* The tests are for public key only operations and for private key operations. Signature
verification and encryption are public key operations. They are tested by using a KVT. For
@ -573,7 +573,7 @@ TestRsa(
}
#endif // TPM_ALG_RSA
/* 10.2.1.6 ECC Tests */
#ifdef TPM_ALG_ECC
#if ALG_ECC
/* 10.2.1.6.1 LoadEccParameter() */
/* This function is mostly for readability and type checking */
static void
@ -795,36 +795,36 @@ TestAlgorithm(
switch(alg)
{
// Symmetric block ciphers
#ifdef TPM_ALG_AES
#if ALG_AES
case ALG_AES_VALUE:
#endif
#ifdef TPM_ALG_SM4
#if ALG_SM4
// if SM4 is implemented, its test is like other block ciphers but there
// aren't any test vectors for it yet
// case ALG_SM4_VALUE:
#endif
#ifdef TPM_ALG_CAMELLIA
#if ALG_CAMELLIA
// no test vectors for camellia
// case ALG_CAMELLIA_VALUE:
#endif
// Symmetric modes
#ifndef TPM_ALG_CFB
#if !ALG_CFB
# error CFB is required in all TPM implementations
#endif // !TPM_ALG_CFB
case ALG_CFB_VALUE:
if(doTest)
result = TestSymmetric(alg, toTest);
break;
#ifdef TPM_ALG_CTR
#if ALG_CTR
case ALG_CTR_VALUE:
#endif // TPM_ALG_CRT
#ifdef TPM_ALG_OFB
#if ALG_OFB
case ALG_OFB_VALUE:
#endif // TPM_ALG_OFB
#ifdef TPM_ALG_CBC
#if ALG_CBC
case ALG_CBC_VALUE:
#endif // TPM_ALG_CBC
#ifdef TPM_ALG_ECB
#if ALG_ECB
case ALG_ECB_VALUE:
#endif
if(doTest)
@ -836,7 +836,7 @@ TestAlgorithm(
if(toTest == &g_toTest)
CLEAR_BIT(alg, *toTest);
break;
#ifndef TPM_ALG_HMAC
#if !ALG_HMAC
# error HMAC is required in all TPM implementations
#endif
case ALG_HMAC_VALUE:
@ -851,28 +851,28 @@ TestAlgorithm(
// tested because this uses HMAC
SET_BOTH(DEFAULT_TEST_HASH);
break;
#ifdef TPM_ALG_SHA1
#if ALG_SHA1
case ALG_SHA1_VALUE:
#endif // TPM_ALG_SHA1
#ifdef TPM_ALG_SHA256
#if ALG_SHA256
case ALG_SHA256_VALUE:
#endif // TPM_ALG_SHA256
#ifdef TPM_ALG_SHA384
#if ALG_SHA384
case ALG_SHA384_VALUE:
#endif // TPM_ALG_SHA384
#ifdef TPM_ALG_SHA512
#if ALG_SHA512
case ALG_SHA512_VALUE:
#endif // TPM_ALG_SHA512
// if SM3 is implemented its test is like any other hash, but there
// aren't any test vectors yet.
#ifdef TPM_ALG_SM3_256
#if ALG_SM3_256
// case ALG_SM3_256_VALUE:
#endif // TPM_ALG_SM3_256
if(doTest)
result = TestHash(alg, toTest);
break;
// RSA-dependent
#ifdef TPM_ALG_RSA
#if ALG_RSA
case ALG_RSA_VALUE:
CLEAR_BOTH(alg);
if(doTest)
@ -889,13 +889,13 @@ TestAlgorithm(
result = TestRsa(alg, toTest);
break;
#endif // TPM_ALG_RSA
#ifdef TPM_ALG_KDF1_SP800_108
#if ALG_KDF1_SP800_108
case ALG_KDF1_SP800_108_VALUE:
if(doTest)
result = TestKDFa(toTest);
break;
#endif // TPM_ALG_KDF1_SP800_108
#ifdef TPM_ALG_ECC
#if ALG_ECC
// ECC dependent but no tests
// case ALG_ECDAA_VALUE:
// case ALG_ECMQV_VALUE:

12
src/tpm2/AsymmetricCommands.c
View File

@ -3,7 +3,7 @@
/* Asymmetric Commands */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: AsymmetricCommands.c 1259 2018-07-10 19:11:09Z kgoldman $ */
/* $Id: AsymmetricCommands.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -62,7 +62,7 @@
#include "Tpm.h"
#include "RSA_Encrypt_fp.h"
#if CC_RSA_Encrypt // Conditional expansion of this file
#ifdef TPM_ALG_RSA
#if ALG_RSA
TPM_RC
TPM2_RSA_Encrypt(
RSA_Encrypt_In *in, // IN: input parameter list
@ -100,7 +100,7 @@ TPM2_RSA_Encrypt(
#include "Tpm.h"
#include "RSA_Decrypt_fp.h"
#if CC_RSA_Decrypt // Conditional expansion of this file
#ifdef TPM_ALG_RSA
#if ALG_RSA
TPM_RC
TPM2_RSA_Decrypt(
RSA_Decrypt_In *in, // IN: input parameter list
@ -145,7 +145,7 @@ TPM2_RSA_Decrypt(
#include "Tpm.h"
#include "ECDH_KeyGen_fp.h"
#if CC_ECDH_KeyGen // Conditional expansion of this file
#ifdef TPM_ALG_ECC
#if ALG_ECC
TPM_RC
TPM2_ECDH_KeyGen(
ECDH_KeyGen_In *in, // IN: input parameter list
@ -192,7 +192,7 @@ TPM2_ECDH_KeyGen(
#include "Tpm.h"
#include "ECDH_ZGen_fp.h"
#if CC_ECDH_ZGen // Conditional expansion of this file
#ifdef TPM_ALG_ECC
#if ALG_ECC
TPM_RC
TPM2_ECDH_ZGen(
ECDH_ZGen_In *in, // IN: input parameter list
@ -230,7 +230,7 @@ TPM2_ECDH_ZGen(
#include "Tpm.h"
#include "ECC_Parameters_fp.h"
#if CC_ECC_Parameters // Conditional expansion of this file
#ifdef TPM_ALG_ECC
#if ALG_ECC
TPM_RC
TPM2_ECC_Parameters(
ECC_Parameters_In *in, // IN: input parameter list

4
src/tpm2/BnConvert.c
View File

@ -3,7 +3,7 @@
/* conversion functions that will convert TPM2B to/from internal format */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: BnConvert.c 1259 2018-07-10 19:11:09Z kgoldman $ */
/* $Id: BnConvert.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -251,7 +251,7 @@ BnTo2B(
}
return FALSE;
}
#ifdef TPM_ALG_ECC
#if ALG_ECC
/* 10.2.2.3.6 BnPointFrom2B() */
/* Function to create a BIG_POINT structure from a 2B point. A point is going to be two ECC values
in the same buffer. The values are going to be the size of the modulus. They are in modular

4
src/tpm2/BnMemory.c
View File

@ -3,7 +3,7 @@
/* */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: BnMemory.c 809 2016-11-16 18:31:54Z kgoldman $ */
/* $Id: BnMemory.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -169,7 +169,7 @@ BnCopy(
}
return TRUE;
}
#ifdef TPM_ALG_ECC
#if ALG_ECC
/* 10.2.5.3.6 BnPointCopy() */
/* Function to copy a bn point. */
LIB_EXPORT BOOL

4
src/tpm2/CapabilityCommands.c
View File

@ -3,7 +3,7 @@
/* Capability Commands */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: CapabilityCommands.c 1259 2018-07-10 19:11:09Z kgoldman $ */
/* $Id: CapabilityCommands.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -166,7 +166,7 @@ TPM2_GetCapability(
in->propertyCount,
&data->tpmProperties);
break;
#ifdef TPM_ALG_ECC
#if ALG_ECC
case TPM_CAP_ECC_CURVES:
out->moreData = CryptCapGetECCCurve((TPM_ECC_CURVE)in->property,
in->propertyCount,

88
src/tpm2/CryptUtil.c
View File

@ -3,7 +3,7 @@
/* Interfaces to the CryptoEngine() */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: CryptUtil.c 1259 2018-07-10 19:11:09Z kgoldman $ */
/* $Id: CryptUtil.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -300,7 +300,7 @@ CryptGenerateKeySymmetric(
MemoryCopy2B(&sensitive->sensitive.sym.b, &sensitiveCreate->data.b,
sizeof(sensitive->sensitive.sym.t.buffer));
}
#ifdef TPM_ALG_TDES
#if ALG_TDES
else if(publicArea->parameters.symDetail.sym.algorithm == TPM_ALG_TDES)
{
sensitive->sensitive.sym.t.size = keyBits / 8;
@ -378,10 +378,10 @@ CryptInit(
ok = ok && CryptSymInit();
ok = ok && CryptRandInit();
ok = ok && CryptHashInit();
#ifdef TPM_ALG_RSA
#if ALG_RSA
ok = ok && CryptRsaInit();
#endif // TPM_ALG_RSA
#ifdef TPM_ALG_ECC
#if ALG_ECC
ok = ok && CryptEccInit();
#endif // TPM_ALG_ECC
return ok;
@ -401,14 +401,14 @@ CryptStartup(
BOOL OK;
NOT_REFERENCED(type);
OK = CryptSymStartup() && CryptRandStartup() && CryptHashStartup()
#ifdef TPM_ALG_RSA
#if ALG_RSA
&& CryptRsaStartup()
#endif // TPM_ALG_RSA
#ifdef TPM_ALG_ECC
#if ALG_ECC
&& CryptEccStartup()
#endif // TPM_ALG_ECC
;
#ifdef TPM_ALG_ECC
#if ALG_ECC
// Don't directly check for SU_RESET because that is the default
if(OK && (type != SU_RESTART) && (type != SU_RESUME))
{
@ -441,10 +441,10 @@ CryptIsAsymAlgorithm(
{
switch(algID)
{
#ifdef TPM_ALG_RSA
case TPM_ALG_RSA:
#if ALG_RSA
case TPM_ALG_RSA:
#endif
#ifdef TPM_ALG_ECC
#if ALG_ECC
case TPM_ALG_ECC:
#endif
return TRUE;
@ -485,7 +485,7 @@ CryptSecretEncrypt(
return TPM_RC_ATTRIBUTES;
switch(encryptKey->publicArea.type)
{
#ifdef TPM_ALG_RSA
#if ALG_RSA
case TPM_ALG_RSA:
{
// Create secret data from RNG
@ -496,7 +496,7 @@ CryptSecretEncrypt(
}
break;
#endif //TPM_ALG_RSA
#ifdef TPM_ALG_ECC
#if ALG_ECC
case TPM_ALG_ECC:
{
TPMS_ECC_POINT eccPublic;
@ -590,7 +590,7 @@ CryptSecretDecrypt(
// Decryption for secret
switch(decryptKey->publicArea.type)
{
#ifdef TPM_ALG_RSA
#if ALG_RSA
case TPM_ALG_RSA:
{
TPMT_RSA_DECRYPT scheme;
@ -627,7 +627,7 @@ CryptSecretDecrypt(
}
break;
#endif //TPM_ALG_RSA
#ifdef TPM_ALG_ECC
#if ALG_ECC
case TPM_ALG_ECC:
{
TPMS_ECC_POINT eccPublic;
@ -670,7 +670,7 @@ CryptSecretDecrypt(
}
break;
#endif //TPM_ALG_ECC
#ifndef TPM_ALG_KEYEDHASH
#if !ALG_KEYEDHASH
# error "KEYEDHASH support is required"
#endif
case TPM_ALG_KEYEDHASH:
@ -946,7 +946,7 @@ CryptCreateObject(
// sensitive value for symmetric object
switch(publicArea->type)
{
#ifdef TPM_ALG_RSA
#if ALG_RSA
// Create RSA key
case TPM_ALG_RSA:
// RSA uses full object so that it has a place to put the private
@ -954,7 +954,7 @@ CryptCreateObject(
result = CryptRsaGenerateKey(object, rand);
break;
#endif // TPM_ALG_RSA
#ifdef TPM_ALG_ECC
#if ALG_ECC
// Create ECC key
case TPM_ALG_ECC:
result = CryptEccGenerateKey(&object->publicArea, &object->sensitive,
@ -1024,7 +1024,7 @@ CryptGetSignHashAlg(
// Get authHash algorithm based on signing scheme
switch(auth->sigAlg)
{
#ifdef TPM_ALG_RSA
#if ALG_RSA
// If RSA is supported, both RSASSA and RSAPSS are required
# if !defined TPM_ALG_RSASSA || !defined TPM_ALG_RSAPSS
# error "RSASSA and RSAPSS are required for RSA"
@ -1034,22 +1034,22 @@ CryptGetSignHashAlg(
case TPM_ALG_RSAPSS:
return auth->signature.rsapss.hash;
#endif //TPM_ALG_RSA
#ifdef TPM_ALG_ECC
#if ALG_ECC
// If ECC is defined, ECDSA is mandatory
# ifndef TPM_ALG_ECDSA
# error "ECDSA is requried for ECC"
# endif
case TPM_ALG_ECDSA:
// SM2 and ECSCHNORR are optional
# ifdef TPM_ALG_SM2
# if ALG_SM2
case TPM_ALG_SM2:
# endif
# ifdef TPM_ALG_ECSCHNORR
# if ALG_ECSCHNORR
case TPM_ALG_ECSCHNORR:
# endif
//all ECC signatures look the same
return auth->signature.ecdsa.hash;
# ifdef TPM_ALG_ECDAA
# if ALG_ECDAA
// Don't know how to verify an ECDAA signature
case TPM_ALG_ECDAA:
break;
@ -1072,7 +1072,7 @@ CryptIsSplitSign(
{
switch(scheme)
{
# ifdef TPM_ALG_ECDAA
# if ALG_ECDAA
case TPM_ALG_ECDAA:
return TRUE;
break;
@ -1093,7 +1093,7 @@ CryptIsAsymSignScheme(
BOOL isSignScheme = TRUE;
switch(publicType)
{
#ifdef TPM_ALG_RSA
#if ALG_RSA
case TPM_ALG_RSA:
switch(scheme)
{
@ -1109,20 +1109,20 @@ CryptIsAsymSignScheme(
}
break;
#endif //TPM_ALG_RSA
#ifdef TPM_ALG_ECC
#if ALG_ECC
// If ECC is implemented ECDSA is required
case TPM_ALG_ECC:
switch(scheme)
{
// Support for ECDSA is required for ECC
case TPM_ALG_ECDSA:
#ifdef TPM_ALG_ECDAA // ECDAA is optional
#if ALG_ECDAA // ECDAA is optional
case TPM_ALG_ECDAA:
#endif
#ifdef TPM_ALG_ECSCHNORR // Schnorr is also optional
#if ALG_ECSCHNORR // Schnorr is also optional
case TPM_ALG_ECSCHNORR:
#endif
#ifdef TPM_ALG_SM2 // SM2 is optional
#if ALG_SM2 // SM2 is optional
case TPM_ALG_SM2:
#endif
break;
@ -1149,7 +1149,7 @@ CryptIsAsymDecryptScheme(
BOOL isDecryptScheme = TRUE;
switch(publicType)
{
#ifdef TPM_ALG_RSA
#if ALG_RSA
case TPM_ALG_RSA:
switch(scheme)
{
@ -1162,19 +1162,19 @@ CryptIsAsymDecryptScheme(
}
break;
#endif //TPM_ALG_RSA
#ifdef TPM_ALG_ECC
#if ALG_ECC
// If ECC is implemented ECDH is required
case TPM_ALG_ECC:
switch(scheme)
{
#ifndef TPM_ALG_ECDH
#if !ALG_ECDH
# error "ECDH is required for ECC"
#endif
case TPM_ALG_ECDH:
#ifdef TPM_ALG_SM2
#if ALG_SM2
case TPM_ALG_SM2:
#endif
#ifdef TPM_ALG_ECMQV
#if ALG_ECMQV
case TPM_ALG_ECMQV:
#endif
break;
@ -1304,12 +1304,12 @@ CryptSign(
// perform sign operation based on different key type
switch(signKey->publicArea.type)
{
#ifdef TPM_ALG_RSA
#if ALG_RSA
case TPM_ALG_RSA:
result = CryptRsaSign(signature, signKey, digest, NULL);
break;
#endif //TPM_ALG_RSA
#ifdef TPM_ALG_ECC
#if ALG_ECC
case TPM_ALG_ECC:
// The reason that signScheme is passed to CryptEccSign but not to the
// other signing methods is that the signing for ECC may be split and
@ -1358,7 +1358,7 @@ CryptValidateSignature(
return TPM_RC_SIGNATURE;
switch(publicArea->type)
{
#ifdef TPM_ALG_RSA
#if ALG_RSA
case TPM_ALG_RSA:
{
//
@ -1367,7 +1367,7 @@ CryptValidateSignature(
break;
}
#endif //TPM_ALG_RSA
#ifdef TPM_ALG_ECC
#if ALG_ECC
case TPM_ALG_ECC:
result = CryptEccValidateSignature(signature, signObject, digest);
break;
@ -1411,14 +1411,14 @@ CryptIsUniqueSizeValid(
UINT16 keySizeInBytes;
switch(publicArea->type)
{
#ifdef TPM_ALG_RSA
#if ALG_RSA
case TPM_ALG_RSA:
keySizeInBytes = BITS_TO_BYTES(
publicArea->parameters.rsaDetail.keyBits);
consistent = publicArea->unique.rsa.t.size == keySizeInBytes;
break;
#endif //TPM_ALG_RSA
#ifdef TPM_ALG_ECC
#if ALG_ECC
case TPM_ALG_ECC:
{
keySizeInBytes = BITS_TO_BYTES(CryptEccGetKeySizeForCurve(
@ -1451,7 +1451,7 @@ CryptIsSensitiveSizeValid(
UINT16 keySizeInBytes;
switch(publicArea->type)
{
#ifdef TPM_ALG_RSA
#if ALG_RSA
case TPM_ALG_RSA:
// sensitive prime value has to be half the size of the public modulus
keySizeInBytes = BITS_TO_BYTES(publicArea->parameters.rsaDetail.keyBits);
@ -1459,7 +1459,7 @@ CryptIsSensitiveSizeValid(
== keySizeInBytes);
break;
#endif
#ifdef TPM_ALG_ECC
#if ALG_ECC
case TPM_ALG_ECC:
keySizeInBytes = BITS_TO_BYTES(CryptEccGetKeySizeForCurve(
publicArea->parameters.eccDetail.curveID));
@ -1530,7 +1530,7 @@ CryptValidateKeys(
}
switch(publicArea->type)
{
#ifdef TPM_ALG_RSA
#if ALG_RSA
case TPM_ALG_RSA:
keySizeInBytes = BITS_TO_BYTES(params->rsaDetail.keyBits);
// Regardless of whether there is a sensitive area, the public modulus
@ -1556,7 +1556,7 @@ CryptValidateKeys(
}
break;
#endif
#ifdef TPM_ALG_ECC
#if ALG_ECC
case TPM_ALG_ECC:
{
TPMI_ECC_CURVE curveId;
@ -1787,7 +1787,7 @@ CryptSmacIsValidAlg(
{
switch (alg)
{
#ifdef TPM_ALG_CMAC
#if ALG_CMAC
case TPM_ALG_CMAC:
return TRUE;
break;

6
src/tpm2/EphemeralCommands.c
View File

@ -3,7 +3,7 @@
/* Ephemeral EC Keys */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: EphemeralCommands.c 1259 2018-07-10 19:11:09Z kgoldman $ */
/* $Id: EphemeralCommands.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -62,7 +62,7 @@
#include "Tpm.h"
#include "Commit_fp.h"
#if CC_Commit // Conditional expansion of this file
#ifdef TPM_ALG_ECC
#if ALG_ECC
TPM_RC
TPM2_Commit(
Commit_In *in, // IN: input parameter list
@ -163,7 +163,7 @@ TPM2_Commit(
#include "Tpm.h"
#include "EC_Ephemeral_fp.h"
#if CC_EC_Ephemeral // Conditional expansion of this file
#ifdef TPM_ALG_ECC
#if ALG_ECC
TPM_RC
TPM2_EC_Ephemeral(
EC_Ephemeral_In *in, // IN: input parameter list

26
src/tpm2/Global.h
View File

@ -199,7 +199,7 @@ typedef struct OBJECT
OBJECT_ATTRIBUTES attributes; // object attributes
TPMT_PUBLIC publicArea; // public area of an object
TPMT_SENSITIVE sensitive; // sensitive area of an object
#ifdef TPM_ALG_RSA
#if ALG_RSA
privateExponent_t privateExponent; // Additional field for the private
#endif
TPM2B_NAME qualifiedName; // object qualified name
@ -379,19 +379,19 @@ typedef BYTE SESSION_BUF[sizeof(SESSION)];
specification to which the TPM is built. */
typedef struct PCR_SAVE
{
#ifdef TPM_ALG_SHA1
#if ALG_SHA1
BYTE sha1[NUM_STATIC_PCR][SHA1_DIGEST_SIZE];
#endif
#ifdef TPM_ALG_SHA256
#if ALG_SHA256
BYTE sha256[NUM_STATIC_PCR][SHA256_DIGEST_SIZE];
#endif
#ifdef TPM_ALG_SHA384
#if ALG_SHA384
BYTE sha384[NUM_STATIC_PCR][SHA384_DIGEST_SIZE];
#endif
#ifdef TPM_ALG_SHA512
#if ALG_SHA512
BYTE sha512[NUM_STATIC_PCR][SHA512_DIGEST_SIZE];
#endif
#ifdef TPM_ALG_SM3_256
#if ALG_SM3_256
BYTE sm3_256[NUM_STATIC_PCR][SM3_256_DIGEST_SIZE];
#endif
// This counter increments whenever the PCR are updated.
@ -465,7 +465,7 @@ typedef union
array. The commit counter is a 64-bit value and the low order bits are used to index the
commitArray. This mask value is applied to the commit counter to extract the bit number in the
array. */
#ifdef TPM_ALG_ECC
#if ALG_ECC
#define COMMIT_INDEX_MASK ((UINT16)((sizeof(gr.commitArray)*8)-1))
#endif
/* This array is used to contain the array of values that are added to a return code when it is a
@ -858,7 +858,7 @@ typedef struct state_reset_data
// NOTE: A platform-specific specification may designate that certain PCR changes
// do not increment this counter to increment.
UINT32 pcrCounter; // The default reset value is 0.
#ifdef TPM_ALG_ECC
#if ALG_ECC
//*****************************************************************************
// ECDAA
//*****************************************************************************
@ -1074,23 +1074,23 @@ extern OBJECT s_objects[MAX_LOADED_OBJECTS];
/* From PCR.c */
typedef struct
{
#ifdef TPM_ALG_SHA1
#if ALG_SHA1
// SHA1 PCR
BYTE sha1Pcr[SHA1_DIGEST_SIZE];
#endif
#ifdef TPM_ALG_SHA256
#if ALG_SHA256
// SHA256 PCR
BYTE sha256Pcr[SHA256_DIGEST_SIZE];
#endif
#ifdef TPM_ALG_SHA384
#if ALG_SHA384
// SHA384 PCR
BYTE sha384Pcr[SHA384_DIGEST_SIZE];
#endif
#ifdef TPM_ALG_SHA512
#if ALG_SHA512
// SHA512 PCR
BYTE sha512Pcr[SHA512_DIGEST_SIZE];
#endif
#ifdef TPM_ALG_SM3_256
#if ALG_SM3_256
// SHA256 PCR
BYTE sm3_256Pcr[SM3_256_DIGEST_SIZE];
#endif

4
src/tpm2/GpMacros.h
View File

@ -205,7 +205,7 @@
#ifndef CONTEXT_INTEGRITY_HASH_SIZE
#define CONTEXT_INTEGRITY_HASH_SIZE CONCAT(CONTEXT_HASH_ALGORITHM, _DIGEST_SIZE)
#endif
#ifdef TPM_ALG_RSA
#if ALG_RSA
#define RSA_SECURITY_STRENGTH (MAX_RSA_KEY_BITS >= 15360 ? 256 : \
(MAX_RSA_KEY_BITS >= 7680 ? 192 : \
(MAX_RSA_KEY_BITS >= 3072 ? 128 : \
@ -214,7 +214,7 @@
#else
#define RSA_SECURITY_STRENGTH 0
#endif
#ifdef TPM_ALG_ECC
#if ALG_ECC
#define ECC_SECURITY_STRENGTH (MAX_ECC_KEY_BITS >= 521 ? 256 : \
(MAX_ECC_KEY_BITS >= 384 ? 192 : \
(MAX_ECC_KEY_BITS >= 256 ? 128 : 0)))

308
src/tpm2/Implementation.h
View File

@ -287,159 +287,161 @@
#define ALG_XOR ALG_YES
/* From TCG Algorithm Registry: Table 2 - Definition of TPM_ALG_ID Constants */
typedef UINT16 TPM_ALG_ID;
#define ALG_ERROR_VALUE 0x0000
#define TPM_ALG_ERROR (TPM_ALG_ID)(ALG_ERROR_VALUE)
#define ALG_RSA_VALUE 0x0001
#if defined ALG_RSA && ALG_RSA == YES
#define TPM_ALG_RSA (TPM_ALG_ID)(ALG_RSA_VALUE)
#endif
#define ALG_TDES_VALUE 0x0003
#if defined ALG_TDES && ALG_TDES == YES
#define TPM_ALG_TDES (TPM_ALG_ID)(ALG_TDES_VALUE)
#endif
#define ALG_SHA_VALUE 0x0004
#if defined ALG_SHA && ALG_SHA == YES
#define TPM_ALG_SHA (TPM_ALG_ID)(ALG_SHA_VALUE)
#endif
#define ALG_SHA1_VALUE 0x0004
#if defined ALG_SHA1 && ALG_SHA1 == YES
#define TPM_ALG_SHA1 (TPM_ALG_ID)(ALG_SHA1_VALUE)
#endif
#define ALG_HMAC_VALUE 0x0005
#if defined ALG_HMAC && ALG_HMAC == YES
#define TPM_ALG_HMAC (TPM_ALG_ID)(ALG_HMAC_VALUE)
#endif
#define ALG_AES_VALUE 0x0006
#if defined ALG_AES && ALG_AES == YES
#define TPM_ALG_AES (TPM_ALG_ID)(ALG_AES_VALUE)
#endif
#define ALG_MGF1_VALUE 0x0007
#if defined ALG_MGF1 && ALG_MGF1 == YES
#define TPM_ALG_MGF1 (TPM_ALG_ID)(ALG_MGF1_VALUE)
#endif
#define ALG_KEYEDHASH_VALUE 0x0008
#if defined ALG_KEYEDHASH && ALG_KEYEDHASH == YES
#define TPM_ALG_KEYEDHASH (TPM_ALG_ID)(ALG_KEYEDHASH_VALUE)
#endif
#define ALG_XOR_VALUE 0x000A
#if defined ALG_XOR && ALG_XOR == YES
#define TPM_ALG_XOR (TPM_ALG_ID)(ALG_XOR_VALUE)
#endif
#define ALG_SHA256_VALUE 0x000B
#if defined ALG_SHA256 && ALG_SHA256 == YES
#define TPM_ALG_SHA256 (TPM_ALG_ID)(ALG_SHA256_VALUE)
#endif
#define ALG_SHA384_VALUE 0x000C
#if defined ALG_SHA384 && ALG_SHA384 == YES
#define TPM_ALG_SHA384 (TPM_ALG_ID)(ALG_SHA384_VALUE)
#endif
#define ALG_SHA512_VALUE 0x000D
#if defined ALG_SHA512 && ALG_SHA512 == YES
#define TPM_ALG_SHA512 (TPM_ALG_ID)(ALG_SHA512_VALUE)
#endif
#define ALG_NULL_VALUE 0x0010
#define TPM_ALG_NULL (TPM_ALG_ID)(ALG_NULL_VALUE)
#define ALG_SM3_256_VALUE 0x0012
#if defined ALG_SM3_256 && ALG_SM3_256 == YES
#define TPM_ALG_SM3_256 (TPM_ALG_ID)(ALG_SM3_256_VALUE)
#endif
#define ALG_SM4_VALUE 0x0013
#if defined ALG_SM4 && ALG_SM4 == YES
#define TPM_ALG_SM4 (TPM_ALG_ID)(ALG_SM4_VALUE)
#endif
#define ALG_RSASSA_VALUE 0x0014
#if defined ALG_RSASSA && ALG_RSASSA == YES
#define TPM_ALG_RSASSA (TPM_ALG_ID)(ALG_RSASSA_VALUE)
#endif
#define ALG_RSAES_VALUE 0x0015
#if defined ALG_RSAES && ALG_RSAES == YES
#define TPM_ALG_RSAES (TPM_ALG_ID)(ALG_RSAES_VALUE)
#endif
#define ALG_RSAPSS_VALUE 0x0016
#if defined ALG_RSAPSS && ALG_RSAPSS == YES
#define TPM_ALG_RSAPSS (TPM_ALG_ID)(ALG_RSAPSS_VALUE)
#endif
#define ALG_OAEP_VALUE 0x0017
#if defined ALG_OAEP && ALG_OAEP == YES
#define TPM_ALG_OAEP (TPM_ALG_ID)(ALG_OAEP_VALUE)
#endif
#define ALG_ECDSA_VALUE 0x0018
#if defined ALG_ECDSA && ALG_ECDSA == YES
#define TPM_ALG_ECDSA (TPM_ALG_ID)(ALG_ECDSA_VALUE)
#endif
#define ALG_ECDH_VALUE 0x0019
#if defined ALG_ECDH && ALG_ECDH == YES
#define TPM_ALG_ECDH (TPM_ALG_ID)(ALG_ECDH_VALUE)
#endif
#define ALG_ECDAA_VALUE 0x001A
#if defined ALG_ECDAA && ALG_ECDAA == YES
#define TPM_ALG_ECDAA (TPM_ALG_ID)(ALG_ECDAA_VALUE)
#endif
#define ALG_SM2_VALUE 0x001B
#if defined ALG_SM2 && ALG_SM2 == YES
#define TPM_ALG_SM2 (TPM_ALG_ID)(ALG_SM2_VALUE)
#endif
#define ALG_ECSCHNORR_VALUE 0x001C
#if defined ALG_ECSCHNORR && ALG_ECSCHNORR == YES
#define TPM_ALG_ECSCHNORR (TPM_ALG_ID)(ALG_ECSCHNORR_VALUE)
#endif
#define ALG_ECMQV_VALUE 0x001D
#if defined ALG_ECMQV && ALG_ECMQV == YES
#define TPM_ALG_ECMQV (TPM_ALG_ID)(ALG_ECMQV_VALUE)
#endif
#define ALG_KDF1_SP800_56A_VALUE 0x0020
#if defined ALG_KDF1_SP800_56A && ALG_KDF1_SP800_56A == YES
#define TPM_ALG_KDF1_SP800_56A (TPM_ALG_ID)(ALG_KDF1_SP800_56A_VALUE)
#endif
#define ALG_KDF2_VALUE 0x0021
#if defined ALG_KDF2 && ALG_KDF2 == YES
#define TPM_ALG_KDF2 (TPM_ALG_ID)(ALG_KDF2_VALUE)
#endif
#define ALG_KDF1_SP800_108_VALUE 0x0022
#if defined ALG_KDF1_SP800_108 && ALG_KDF1_SP800_108 == YES
#define TPM_ALG_KDF1_SP800_108 (TPM_ALG_ID)(ALG_KDF1_SP800_108_VALUE)
#endif
#define ALG_ECC_VALUE 0x0023
#if defined ALG_ECC && ALG_ECC == YES
#define TPM_ALG_ECC (TPM_ALG_ID)(ALG_ECC_VALUE)
#endif
#define ALG_SYMCIPHER_VALUE 0x0025
#if defined ALG_SYMCIPHER && ALG_SYMCIPHER == YES
#define TPM_ALG_SYMCIPHER (TPM_ALG_ID)(ALG_SYMCIPHER_VALUE)
#endif
#define ALG_CAMELLIA_VALUE 0x0026
#if defined ALG_CAMELLIA && ALG_CAMELLIA == YES
#define TPM_ALG_CAMELLIA (TPM_ALG_ID)(ALG_CAMELLIA_VALUE)
#endif
#define ALG_CMAC_VALUE 0x003F
#if defined ALG_CMAC && ALG_CMAC == YES
#define TPM_ALG_CMAC (TPM_ALG_ID)(ALG_CMAC_VALUE)
#endif
#define ALG_CTR_VALUE 0x0040
#if defined ALG_CTR && ALG_CTR == YES
#define TPM_ALG_CTR (TPM_ALG_ID)(ALG_CTR_VALUE)
#endif
#define ALG_OFB_VALUE 0x0041
#if defined ALG_OFB && ALG_OFB == YES
#define TPM_ALG_OFB (TPM_ALG_ID)(ALG_OFB_VALUE)
#endif
#define ALG_CBC_VALUE 0x0042
#if defined ALG_CBC && ALG_CBC == YES
#define TPM_ALG_CBC (TPM_ALG_ID)(ALG_CBC_VALUE)
#endif
#define ALG_CFB_VALUE 0x0043
#if defined ALG_CFB && ALG_CFB == YES
#define TPM_ALG_CFB (TPM_ALG_ID)(ALG_CFB_VALUE)
#endif
#define ALG_ECB_VALUE 0x0044
#if defined ALG_ECB && ALG_ECB == YES
#define TPM_ALG_ECB (TPM_ALG_ID)(ALG_ECB_VALUE)
#endif
#define TPM_ALG_FIRST (TPM_ALG_ID)(0x0001)
#define ALG_FIRST_VALUE 0x0001
#define TPM_ALG_LAST (TPM_ALG_ID)(0x0044)
#define ALG_LAST_VALUE 0x0044
typedef UINT16 TPM_ALG_ID;
#define ALG_ERROR_VALUE 0x0000
#define TPM_ALG_ERROR (TPM_ALG_ID)(ALG_ERROR_VALUE)
#define ALG_RSA_VALUE 0x0001
#if ALG_RSA
#define TPM_ALG_RSA (TPM_ALG_ID)(ALG_RSA_VALUE)
#endif // ALG_RSA
#define ALG_TDES_VALUE 0x0003
#if ALG_TDES
#define TPM_ALG_TDES (TPM_ALG_ID)(ALG_TDES_VALUE)
#endif // ALG_TDES
#define ALG_SHA_VALUE 0x0004
#if ALG_SHA
#define TPM_ALG_SHA (TPM_ALG_ID)(ALG_SHA_VALUE)
#endif // ALG_SHA
#define ALG_SHA1_VALUE 0x0004
#if ALG_SHA1
#define TPM_ALG_SHA1 (TPM_ALG_ID)(ALG_SHA1_VALUE)
#endif // ALG_SHA1
#define ALG_HMAC_VALUE 0x0005
#if ALG_HMAC
#define TPM_ALG_HMAC (TPM_ALG_ID)(ALG_HMAC_VALUE)
#endif // ALG_HMAC
#define ALG_AES_VALUE 0x0006
#if ALG_AES
#define TPM_ALG_AES (TPM_ALG_ID)(ALG_AES_VALUE)
#endif // ALG_AES
#define ALG_MGF1_VALUE 0x0007
#if ALG_MGF1
#define TPM_ALG_MGF1 (TPM_ALG_ID)(ALG_MGF1_VALUE)
#endif // ALG_MGF1
#define ALG_KEYEDHASH_VALUE 0x0008
#if ALG_KEYEDHASH
#define TPM_ALG_KEYEDHASH (TPM_ALG_ID)(ALG_KEYEDHASH_VALUE)
#endif // ALG_KEYEDHASH
#define ALG_XOR_VALUE 0x000A
#if ALG_XOR
#define TPM_ALG_XOR (TPM_ALG_ID)(ALG_XOR_VALUE)
#endif // ALG_XOR
#define ALG_SHA256_VALUE 0x000B
#if ALG_SHA256
#define TPM_ALG_SHA256 (TPM_ALG_ID)(ALG_SHA256_VALUE)
#endif // ALG_SHA256
#define ALG_SHA384_VALUE 0x000C
#if ALG_SHA384
#define TPM_ALG_SHA384 (TPM_ALG_ID)(ALG_SHA384_VALUE)
#endif // ALG_SHA384
#define ALG_SHA512_VALUE 0x000D
#if ALG_SHA512
#define TPM_ALG_SHA512 (TPM_ALG_ID)(ALG_SHA512_VALUE)
#endif // ALG_SHA512
#define ALG_NULL_VALUE 0x0010
#define TPM_ALG_NULL (TPM_ALG_ID)(ALG_NULL_VALUE)
#define ALG_SM3_256_VALUE 0x0012
#if ALG_SM3_256
#define TPM_ALG_SM3_256 (TPM_ALG_ID)(ALG_SM3_256_VALUE)
#endif // ALG_SM3_256
#define ALG_SM4_VALUE 0x0013
#if ALG_SM4
#define TPM_ALG_SM4 (TPM_ALG_ID)(ALG_SM4_VALUE)
#endif // ALG_SM4
#define ALG_RSASSA_VALUE 0x0014
#if ALG_RSASSA
#define TPM_ALG_RSASSA (TPM_ALG_ID)(ALG_RSASSA_VALUE)
#endif // ALG_RSASSA
#define ALG_RSAES_VALUE 0x0015
#if ALG_RSAES
#define TPM_ALG_RSAES (TPM_ALG_ID)(ALG_RSAES_VALUE)
#endif // ALG_RSAES
#define ALG_RSAPSS_VALUE 0x0016
#if ALG_RSAPSS
#define TPM_ALG_RSAPSS (TPM_ALG_ID)(ALG_RSAPSS_VALUE)
#endif // ALG_RSAPSS
#define ALG_OAEP_VALUE 0x0017
#if ALG_OAEP
#define TPM_ALG_OAEP (TPM_ALG_ID)(ALG_OAEP_VALUE)
#endif // ALG_OAEP
#define ALG_ECDSA_VALUE 0x0018
#if ALG_ECDSA
#define TPM_ALG_ECDSA (TPM_ALG_ID)(ALG_ECDSA_VALUE)
#endif // ALG_ECDSA
#define ALG_ECDH_VALUE 0x0019
#if ALG_ECDH
#define TPM_ALG_ECDH (TPM_ALG_ID)(ALG_ECDH_VALUE)
#endif // ALG_ECDH
#define ALG_ECDAA_VALUE 0x001A
#if ALG_ECDAA
#define TPM_ALG_ECDAA (TPM_ALG_ID)(ALG_ECDAA_VALUE)
#endif // ALG_ECDAA
#define ALG_SM2_VALUE 0x001B
#if ALG_SM2
#define TPM_ALG_SM2 (TPM_ALG_ID)(ALG_SM2_VALUE)
#endif // ALG_SM2
#define ALG_ECSCHNORR_VALUE 0x001C
#if ALG_ECSCHNORR
#define TPM_ALG_ECSCHNORR (TPM_ALG_ID)(ALG_ECSCHNORR_VALUE)
#endif // ALG_ECSCHNORR
#define ALG_ECMQV_VALUE 0x001D
#if ALG_ECMQV
#define TPM_ALG_ECMQV (TPM_ALG_ID)(ALG_ECMQV_VALUE)
#endif // ALG_ECMQV
#define ALG_KDF1_SP800_56A_VALUE 0x0020
#if ALG_KDF1_SP800_56A
#define TPM_ALG_KDF1_SP800_56A (TPM_ALG_ID)(ALG_KDF1_SP800_56A_VALUE)
#endif // ALG_KDF1_SP800_56A
#define ALG_KDF2_VALUE 0x0021
#if ALG_KDF2
#define TPM_ALG_KDF2 (TPM_ALG_ID)(ALG_KDF2_VALUE)
#endif // ALG_KDF2
#define ALG_KDF1_SP800_108_VALUE 0x0022
#if ALG_KDF1_SP800_108
#define TPM_ALG_KDF1_SP800_108 (TPM_ALG_ID)(ALG_KDF1_SP800_108_VALUE)
#endif // ALG_KDF1_SP800_108
#define ALG_ECC_VALUE 0x0023
#if ALG_ECC
#define TPM_ALG_ECC (TPM_ALG_ID)(ALG_ECC_VALUE)
#endif // ALG_ECC
#define ALG_SYMCIPHER_VALUE 0x0025
#if ALG_SYMCIPHER
#define TPM_ALG_SYMCIPHER (TPM_ALG_ID)(ALG_SYMCIPHER_VALUE)
#endif // ALG_SYMCIPHER
#define ALG_CAMELLIA_VALUE 0x0026
#if ALG_CAMELLIA
#define TPM_ALG_CAMELLIA (TPM_ALG_ID)(ALG_CAMELLIA_VALUE)
#endif // ALG_CAMELLIA
#define ALG_CMAC_VALUE 0x003F
#if ALG_CMAC
#define TPM_ALG_CMAC (TPM_ALG_ID)(ALG_CMAC_VALUE)
#endif // ALG_CMAC
#define ALG_CTR_VALUE 0x0040
#if ALG_CTR
#define TPM_ALG_CTR (TPM_ALG_ID)(ALG_CTR_VALUE)
#endif // ALG_CTR
#define ALG_OFB_VALUE 0x0041
#if ALG_OFB
#define TPM_ALG_OFB (TPM_ALG_ID)(ALG_OFB_VALUE)
#endif // ALG_OFB
#define ALG_CBC_VALUE 0x0042
#if ALG_CBC
#define TPM_ALG_CBC (TPM_ALG_ID)(ALG_CBC_VALUE)
#endif // ALG_CBC
#define ALG_CFB_VALUE 0x0043
#if ALG_CFB
#define TPM_ALG_CFB (TPM_ALG_ID)(ALG_CFB_VALUE)
#endif // ALG_CFB
#define ALG_ECB_VALUE 0x0044
#if ALG_ECB
#define TPM_ALG_ECB (TPM_ALG_ID)(ALG_ECB_VALUE)
#endif // ALG_ECB
// Values derived from Table 1:2
#define ALG_FIRST_VALUE 0x0001
#define TPM_ALG_FIRST (TPM_ALG_ID)(ALG_FIRST_VALUE)
#define ALG_LAST_VALUE 0x0044
#define TPM_ALG_LAST (TPM_ALG_ID)(ALG_LAST_VALUE)
/* From TCG Algorithm Registry: Table 3 - Definition of TPM_ECC_CURVE Constants */
typedef UINT16 TPM_ECC_CURVE;

10
src/tpm2/InternalRoutines.h
View File

@ -3,7 +3,7 @@
/* Include Headers for Internal Routines */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: InternalRoutines.h 1047 2017-07-20 18:27:34Z kgoldman $ */
/* $Id: InternalRoutines.h 1259 2018-07-10 19:11:09Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -55,7 +55,7 @@
/* arising in any way out of use or reliance upon this specification or any */
/* information herein. */
/* */
/* (c) Copyright IBM Corp. and others, 2016, 2017 */
/* (c) Copyright IBM Corp. and others, 2016 - 2018 */
/* */
/********************************************************************************/
@ -121,18 +121,18 @@
#include "MathOnByteBuffers_fp.h"
#include "CryptSym_fp.h"
#include "AlgorithmTests_fp.h"
#ifdef TPM_ALG_RSA
#if ALG_RSA
#include "CryptRsa_fp.h"
#include "CryptPrimeSieve_fp.h"
#endif
#ifdef TPM_ALG_ECC
#if ALG_ECC
#include "CryptEccMain_fp.h"
#include "CryptEccSignature_fp.h"
#include "CryptEccKeyExchange_fp.h"
#endif
#if CC_MAC || CC_MAC_Start
# include "CryptSmac_fp.h"
# ifdef TPM_ALG_CMAC
# if ALG_CMAC
# include "CryptCmac_fp.h"
# endif
#endif

6
src/tpm2/Manufacture.c
View File

@ -3,7 +3,7 @@
/* Performs the manufacturing of the TPM */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: Manufacture.c 1259 2018-07-10 19:11:09Z kgoldman $ */
/* $Id: Manufacture.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -168,10 +168,10 @@ TpmEndSimulation(
HashLibSimulationEnd();
SymLibSimulationEnd();
MathLibSimulationEnd();
#ifdef TPM_ALG_RSA
#if ALG_RSA
RsaSimulationEnd();
#endif
#ifdef TPM_ALG_ECC
#if ALG_ECC
EccSimulationEnd();
#endif
#endif // SIMULATION

102
src/tpm2/Marshal.c
View File

@ -3,7 +3,7 @@
/* Parameter Marshaling */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: Marshal.c 1047 2017-07-20 18:27:34Z kgoldman $ */
/* $Id: Marshal.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -229,7 +229,7 @@ TPM_ALG_ID_Marshal(TPM_ALG_ID *source, BYTE **buffer, INT32 *size)
/* Table 10 - Definition of (UINT16) {ECC} TPM_ECC_CURVE Constants <IN/OUT, S> */
#ifdef TPM_ALG_ECC
#if ALG_ECC
UINT16
TPM_ECC_CURVE_Marshal(TPM_ECC_CURVE *source, BYTE **buffer, INT32 *size)
{
@ -467,27 +467,27 @@ TPMU_HA_Marshal(TPMU_HA *source, BYTE **buffer, INT32 *size, UINT32 selector)
UINT16 written = 0;
switch (selector) {
#ifdef TPM_ALG_SHA1
#if ALG_SHA1
case TPM_ALG_SHA1:
written += Array_Marshal(&source->sha1[0], SHA1_DIGEST_SIZE, buffer, size);
break;
#endif
#ifdef TPM_ALG_SHA256
#if ALG_SHA256
case TPM_ALG_SHA256:
written += Array_Marshal(&source->sha256[0], SHA256_DIGEST_SIZE, buffer, size);
break;
#endif
#ifdef TPM_ALG_SHA384
#if ALG_SHA384
case TPM_ALG_SHA384:
written += Array_Marshal(&source->sha384[0], SHA384_DIGEST_SIZE, buffer, size);
break;
#endif
#ifdef TPM_ALG_SHA512
#if ALG_SHA512
case TPM_ALG_SHA512:
written += Array_Marshal(&source->sha512[0], SHA512_DIGEST_SIZE, buffer, size);
break;
#endif
#ifdef TPM_ALG_SM3_256
#if ALG_SM3_256
case TPM_ALG_SM3_256:
written += Array_Marshal(&source->sm3_256[0], SM3_256_DIGEST_SIZE, buffer, size);
break;
@ -1155,22 +1155,22 @@ TPMU_SYM_KEY_BITS_Marshal(TPMU_SYM_KEY_BITS *source, BYTE **buffer, INT32 *size,
UINT16 written = 0;
switch(selector) {
#ifdef TPM_ALG_AES
#if ALG_AES
case TPM_ALG_AES:
written += TPMI_AES_KEY_BITS_Marshal(&source->aes, buffer, size);
break;
#endif
#ifdef TPM_ALG_SM4
#if ALG_SM4
case TPM_ALG_SM4:
written += TPMI_SM4_KEY_BITS_Marshal(&source->sm4, buffer, size);
break;
#endif
#ifdef TPM_ALG_CAMELLIA
#if ALG_CAMELLIA
case TPM_ALG_CAMELLIA:
written += TPMI_CAMELLIA_KEY_BITS_Marshal(&source->camellia, buffer, size);
break;
#endif
#ifdef TPM_ALG_XOR
#if ALG_XOR
case TPM_ALG_XOR:
written += TPMI_ALG_HASH_Marshal(&source->xorr, buffer, size);
break;
@ -1191,22 +1191,22 @@ TPMU_SYM_MODE_Marshal(TPMU_SYM_MODE *source, BYTE **buffer, INT32 *size, UINT32
UINT16 written = 0;
switch (selector) {
#ifdef TPM_ALG_AES
#if ALG_AES
case TPM_ALG_AES:
written += TPMI_ALG_SYM_MODE_Marshal(&source->aes, buffer, size);
break;
#endif
#ifdef TPM_ALG_SM4
#if ALG_SM4
case TPM_ALG_SM4:
written += TPMI_ALG_SYM_MODE_Marshal(&source->sm4, buffer, size);
break;
#endif
#ifdef TPM_ALG_CAMELLIA
#if ALG_CAMELLIA
case TPM_ALG_CAMELLIA:
written += TPMI_ALG_SYM_MODE_Marshal(&source->camellia, buffer, size);
break;
#endif
#ifdef TPM_ALG_XOR
#if ALG_XOR
case TPM_ALG_XOR:
#endif
case TPM_ALG_NULL:
@ -1406,12 +1406,12 @@ TPMU_SCHEME_KEYEDHASH_Marshal(TPMU_SCHEME_KEYEDHASH *source, BYTE **buffer, INT3
UINT16 written = 0;
switch (selector) {
#ifdef TPM_ALG_HMAC
#if ALG_HMAC
case TPM_ALG_HMAC:
written += TPMS_SCHEME_HMAC_Marshal(&source->hmac, buffer, size);
break;
#endif
#ifdef TPM_ALG_XOR
#if ALG_XOR
case TPM_ALG_XOR:
written += TPMS_SCHEME_XOR_Marshal(&source->xorr, buffer, size);
break;
@ -1434,7 +1434,6 @@ TPMS_KEY_SCHEME_ECDH_Marshal(TPMS_KEY_SCHEME_ECDH *source, BYTE **buffer, INT32
return written;
}
#ifdef TPM_ALG_ECMQV
UINT16
TPMS_KEY_SCHEME_ECMQV_Marshal(TPMS_KEY_SCHEME_ECMQV *source, BYTE **buffer, INT32 *size)
{
@ -1442,7 +1441,6 @@ TPMS_KEY_SCHEME_ECMQV_Marshal(TPMS_KEY_SCHEME_ECMQV *source, BYTE **buffer, INT3
written += TPMS_SCHEME_HASH_Marshal(source, buffer, size);
return written;
}
#endif
/* Table 2:155 - Definition of Types for KDF Schemes (TypedefTable()) */
UINT16
@ -1483,22 +1481,22 @@ TPMU_KDF_SCHEME_Marshal(TPMU_KDF_SCHEME *source, BYTE **buffer, INT32 *size, UIN
switch (selector) {
#ifdef TPM_ALG_MGF1
#if ALG_MGF1
case TPM_ALG_MGF1:
written += TPMS_SCHEME_MGF1_Marshal(&source->mgf1, buffer, size);
break;
#endif
#ifdef TPM_ALG_KDF1_SP800_56A
#if ALG_KDF1_SP800_56A
case TPM_ALG_KDF1_SP800_56A:
written += TPMS_SCHEME_KDF1_SP800_56A_Marshal(&source->kdf1_sp800_56a, buffer, size);
break;
#endif
#ifdef TPM_ALG_KDF2
#if ALG_KDF2
case TPM_ALG_KDF2:
written += TPMS_SCHEME_KDF2_Marshal(&source->kdf2, buffer, size);
break;
#endif
#ifdef TPM_ALG_KDF1_SP800_108
#if ALG_KDF1_SP800_108
case TPM_ALG_KDF1_SP800_108:
written += TPMS_SCHEME_KDF1_SP800_108_Marshal(&source->kdf1_sp800_108, buffer, size);
break;
@ -1531,52 +1529,52 @@ TPMU_ASYM_SCHEME_Marshal(TPMU_ASYM_SCHEME *source, BYTE **buffer, INT32 *size,
UINT16 written = 0;
switch (selector) {
#ifdef TPM_ALG_ECDH
#if ALG_ECDH
case TPM_ALG_ECDH:
written += TPMS_KEY_SCHEME_ECDH_Marshal(&source->ecdh, buffer, size);
break;
#endif
#ifdef TPM_ALG_ECMQV
#if ALG_ECMQV
case TPM_ALG_ECMQV:
written += TPMS_KEY_SCHEME_ECMQV_Marshal(&source->ecmqv, buffer, size);
break;
#endif
#ifdef TPM_ALG_RSASSA
#if ALG_RSASSA
case TPM_ALG_RSASSA:
written += TPMS_SIG_SCHEME_RSASSA_Marshal(&source->rsassa, buffer, size);
break;
#endif
#ifdef TPM_ALG_RSAPSS
#if ALG_RSAPSS
case TPM_ALG_RSAPSS:
written += TPMS_SIG_SCHEME_RSAPSS_Marshal(&source->rsapss, buffer, size);
break;
#endif
#ifdef TPM_ALG_ECDSA
#if ALG_ECDSA
case TPM_ALG_ECDSA:
written += TPMS_SIG_SCHEME_ECDSA_Marshal(&source->ecdsa, buffer, size);
break;
#endif
#ifdef TPM_ALG_ECDAA
#if ALG_ECDAA
case TPM_ALG_ECDAA:
written += TPMS_SIG_SCHEME_ECDAA_Marshal(&source->ecdaa, buffer, size);
break;
#endif
#ifdef TPM_ALG_SM2
#if ALG_SM2
case TPM_ALG_SM2:
written += TPMS_SIG_SCHEME_SM2_Marshal(&source->sm2, buffer, size);
break;
#endif
#ifdef TPM_ALG_ECSCHNORR
#if ALG_ECSCHNORR
case TPM_ALG_ECSCHNORR:
written += TPMS_SIG_SCHEME_ECSCHNORR_Marshal(&source->ecschnorr, buffer, size);
break;
#endif
#ifdef TPM_ALG_RSAES
#if ALG_RSAES
case TPM_ALG_RSAES:
written += TPMS_ENC_SCHEME_RSAES_Marshal(&source->rsaes, buffer, size);
break;
#endif
#ifdef TPM_ALG_OAEP
#if ALG_OAEP
case TPM_ALG_OAEP:
written += TPMS_ENC_SCHEME_OAEP_Marshal(&source->oaep, buffer, size);
break;
@ -1820,37 +1818,37 @@ TPMU_SIGNATURE_Marshal(TPMU_SIGNATURE *source, BYTE **buffer, INT32 *size, UINT3
UINT16 written = 0;
switch (selector) {
#ifdef TPM_ALG_RSASSA
#if ALG_RSASSA
case TPM_ALG_RSASSA:
written += TPMS_SIGNATURE_RSASSA_Marshal(&source->rsassa, buffer, size);
break;
#endif
#ifdef TPM_ALG_RSAPSS
#if ALG_RSAPSS
case TPM_ALG_RSAPSS:
written += TPMS_SIGNATURE_RSAPSS_Marshal(&source->rsapss, buffer, size);
break;
#endif
#ifdef TPM_ALG_ECDSA
#if ALG_ECDSA
case TPM_ALG_ECDSA:
written += TPMS_SIGNATURE_ECDSA_Marshal(&source->ecdsa, buffer, size);
break;
#endif
#ifdef TPM_ALG_ECDAA
#if ALG_ECDAA
case TPM_ALG_ECDAA:
written += TPMS_SIGNATURE_ECDAA_Marshal(&source->ecdaa, buffer, size);
break;
#endif
#ifdef TPM_ALG_SM2
#if ALG_SM2
case TPM_ALG_SM2:
written += TPMS_SIGNATURE_SM2_Marshal(&source->sm2, buffer, size);
break;
#endif
#ifdef TPM_ALG_ECSCHNORR
#if ALG_ECSCHNORR
case TPM_ALG_ECSCHNORR:
written += TPMS_SIGNATURE_ECSCHNORR_Marshal(&source->ecschnorr, buffer, size);
break;
#endif
#ifdef TPM_ALG_HMAC
#if ALG_HMAC
case TPM_ALG_HMAC:
written += TPMT_HA_Marshal(&source->hmac, buffer, size);
break;
@ -1903,22 +1901,22 @@ TPMU_PUBLIC_ID_Marshal(TPMU_PUBLIC_ID *source, BYTE **buffer, INT32 *size, UINT3
UINT16 written = 0;
switch (selector) {
#ifdef TPM_ALG_KEYEDHASH
#if ALG_KEYEDHASH
case TPM_ALG_KEYEDHASH:
written += TPM2B_DIGEST_Marshal(&source->keyedHash, buffer, size);
break;
#endif
#ifdef TPM_ALG_SYMCIPHER
#if ALG_SYMCIPHER
case TPM_ALG_SYMCIPHER:
written += TPM2B_DIGEST_Marshal(&source->sym, buffer, size);
break;
#endif
#ifdef TPM_ALG_RSA
#if ALG_RSA
case TPM_ALG_RSA:
written += TPM2B_PUBLIC_KEY_RSA_Marshal(&source->rsa, buffer, size);
break;
#endif
#ifdef TPM_ALG_ECC
#if ALG_ECC
case TPM_ALG_ECC:
written += TPMS_ECC_POINT_Marshal(&source->ecc, buffer, size);
break;
@ -1975,22 +1973,22 @@ TPMU_PUBLIC_PARMS_Marshal(TPMU_PUBLIC_PARMS *source, BYTE **buffer, INT32 *size,
UINT16 written = 0;
switch (selector) {
#ifdef TPM_ALG_KEYEDHASH
#if ALG_KEYEDHASH
case TPM_ALG_KEYEDHASH:
written += TPMS_KEYEDHASH_PARMS_Marshal(&source->keyedHashDetail, buffer, size);
break;
#endif
#ifdef TPM_ALG_SYMCIPHER
#if ALG_SYMCIPHER
case TPM_ALG_SYMCIPHER:
written += TPMS_SYMCIPHER_PARMS_Marshal(&source->symDetail, buffer, size);
break;
#endif
#ifdef TPM_ALG_RSA
#if ALG_RSA
case TPM_ALG_RSA:
written += TPMS_RSA_PARMS_Marshal(&source->rsaDetail, buffer, size);
break;
#endif
#ifdef TPM_ALG_ECC
#if ALG_ECC
case TPM_ALG_ECC:
written += TPMS_ECC_PARMS_Marshal(&source->eccDetail, buffer, size);
break;
@ -2057,22 +2055,22 @@ TPMU_SENSITIVE_COMPOSITE_Marshal(TPMU_SENSITIVE_COMPOSITE *source, BYTE **buffer
UINT16 written = 0;
switch (selector) {
#ifdef TPM_ALG_RSA
#if ALG_RSA
case TPM_ALG_RSA:
written += TPM2B_PRIVATE_KEY_RSA_Marshal(&source->rsa, buffer, size);
break;
#endif
#ifdef TPM_ALG_ECC
#if ALG_ECC
case TPM_ALG_ECC:
written += TPM2B_ECC_PARAMETER_Marshal(&source->ecc, buffer, size);
break;
#endif
#ifdef TPM_ALG_KEYEDHASH
#if ALG_KEYEDHASH
case TPM_ALG_KEYEDHASH:
written += TPM2B_SENSITIVE_DATA_Marshal(&source->bits, buffer, size);
break;
#endif
#ifdef TPM_ALG_SYMCIPHER
#if ALG_SYMCIPHER
case TPM_ALG_SYMCIPHER:
written += TPM2B_SYM_KEY_Marshal(&source->sym, buffer, size);
break;

78
src/tpm2/NVMarshal.c
View File

@ -694,7 +694,7 @@ PCR_SAVE_Marshal(PCR_SAVE *data, BYTE **buffer, INT32 *size)
array_size = NUM_STATIC_PCR;
written += UINT16_Marshal(&array_size, buffer, size);
#ifdef TPM_ALG_SHA1
#if ALG_SHA1
algid = TPM_ALG_SHA1;
written += TPM_ALG_ID_Marshal(&algid, buffer, size);
@ -703,7 +703,7 @@ PCR_SAVE_Marshal(PCR_SAVE *data, BYTE **buffer, INT32 *size)
written += Array_Marshal((BYTE *)&data->sha1, array_size,
buffer, size);
#endif
#ifdef TPM_ALG_SHA256
#if ALG_SHA256
algid = TPM_ALG_SHA256;
written += TPM_ALG_ID_Marshal(&algid, buffer, size);
@ -712,7 +712,7 @@ PCR_SAVE_Marshal(PCR_SAVE *data, BYTE **buffer, INT32 *size)
written += Array_Marshal((BYTE *)&data->sha256, array_size,
buffer, size);
#endif
#ifdef TPM_ALG_SHA384
#if ALG_SHA384
algid = TPM_ALG_SHA384;
written += TPM_ALG_ID_Marshal(&algid, buffer, size);
@ -721,7 +721,7 @@ PCR_SAVE_Marshal(PCR_SAVE *data, BYTE **buffer, INT32 *size)
written += Array_Marshal((BYTE *)&data->sha384, array_size,
buffer, size);
#endif
#ifdef TPM_ALG_SHA512
#if ALG_SHA512
algid = TPM_ALG_SHA512;
written += TPM_ALG_ID_Marshal(&algid, buffer, size);
@ -730,7 +730,7 @@ PCR_SAVE_Marshal(PCR_SAVE *data, BYTE **buffer, INT32 *size)
written += Array_Marshal((BYTE *)&data->sha512, array_size,
buffer, size);
#endif
#ifdef TPM_ALG_SM3_256
#if ALG_SM3_256
algid = TPM_ALG_SM3_256;
written += TPM_ALG_ID_Marshal(&algid, buffer, size);
@ -810,31 +810,31 @@ PCR_SAVE_Unmarshal(PCR_SAVE *data, BYTE **buffer, INT32 *size,
}
if (rc == TPM_RC_SUCCESS) {
switch (algid) {
#ifdef TPM_ALG_SHA1
#if ALG_SHA1
case TPM_ALG_SHA1:
needed_size = sizeof(data->sha1);
t = (BYTE *)&data->sha1;
break;
#endif
#ifdef TPM_ALG_SHA256
#if ALG_SHA256
case TPM_ALG_SHA256:
needed_size = sizeof(data->sha256);
t = (BYTE *)&data->sha256;
break;
#endif
#ifdef TPM_ALG_SHA384
#if ALG_SHA384
case TPM_ALG_SHA384:
needed_size = sizeof(data->sha384);
t = (BYTE *)&data->sha384;
break;
#endif
#ifdef TPM_ALG_SHA512
#if ALG_SHA512
case TPM_ALG_SHA512:
needed_size = sizeof(data->sha512);
t = (BYTE *)&data->sha512;
break;
#endif
#ifdef TPM_ALG_SM3_256
#if ALG_SM3_256
case TPM_ALG_SM3_256:
needed_size = sizeof(data->sm3_256);
t = (BYTE *)&data->sm3_256;
@ -903,7 +903,7 @@ PCR_Marshal(PCR *data, BYTE **buffer, INT32 *size)
written = NV_HEADER_Marshal(buffer, size,
PCR_VERSION, PCR_MAGIC, 1);
#ifdef TPM_ALG_SHA1
#if ALG_SHA1
algid = TPM_ALG_SHA1;
written += TPM_ALG_ID_Marshal(&algid, buffer, size);
@ -912,7 +912,7 @@ PCR_Marshal(PCR *data, BYTE **buffer, INT32 *size)
written += Array_Marshal((BYTE *)&data->sha1Pcr, array_size,
buffer, size);
#endif
#ifdef TPM_ALG_SHA256
#if ALG_SHA256
algid = TPM_ALG_SHA256;
written += TPM_ALG_ID_Marshal(&algid, buffer, size);
@ -921,7 +921,7 @@ PCR_Marshal(PCR *data, BYTE **buffer, INT32 *size)
written += Array_Marshal((BYTE *)&data->sha256Pcr, array_size,
buffer, size);
#endif
#ifdef TPM_ALG_SHA384
#if ALG_SHA384
algid = TPM_ALG_SHA384;
written += TPM_ALG_ID_Marshal(&algid, buffer, size);
@ -930,7 +930,7 @@ PCR_Marshal(PCR *data, BYTE **buffer, INT32 *size)
written += Array_Marshal((BYTE *)&data->sha384Pcr, array_size,
buffer, size);
#endif
#ifdef TPM_ALG_SHA512
#if ALG_SHA512
algid = TPM_ALG_SHA512;
written += TPM_ALG_ID_Marshal(&algid, buffer, size);
@ -939,7 +939,7 @@ PCR_Marshal(PCR *data, BYTE **buffer, INT32 *size)
written += Array_Marshal((BYTE *)&data->sha512Pcr, array_size,
buffer, size);
#endif
#ifdef TPM_ALG_SM3_256
#if ALG_SM3_256
algid = TPM_ALG_SM3_256;
written += TPM_ALG_ID_Marshal(&algid, buffer, size);
@ -986,31 +986,31 @@ PCR_Unmarshal(PCR *data, BYTE **buffer, INT32 *size,
}
if (rc == TPM_RC_SUCCESS) {
switch (algid) {
#ifdef TPM_ALG_SHA1
#if ALG_SHA1
case TPM_ALG_SHA1:
needed_size = sizeof(data->sha1Pcr);
t = (BYTE *)&data->sha1Pcr;
break;
#endif
#ifdef TPM_ALG_SHA256
#if ALG_SHA256
case TPM_ALG_SHA256:
needed_size = sizeof(data->sha256Pcr);
t = (BYTE *)&data->sha256Pcr;
break;
#endif
#ifdef TPM_ALG_SHA384
#if ALG_SHA384
case TPM_ALG_SHA384:
needed_size = sizeof(data->sha384Pcr);
t = (BYTE *)&data->sha384Pcr;
break;
#endif
#ifdef TPM_ALG_SHA512
#if ALG_SHA512
case TPM_ALG_SHA512:
needed_size = sizeof(data->sha512Pcr);
t = (BYTE *)&data->sha512Pcr;
break;
#endif
#ifdef TPM_ALG_SM3_256
#if ALG_SM3_256
case TPM_ALG_SM3_256:
needed_size = sizeof(data->sm3_256Pcr);
t = (BYTE *)&data->sm3_256Pcr;
@ -1269,7 +1269,7 @@ STATE_RESET_DATA_Unmarshal(STATE_RESET_DATA *data, BYTE **buffer, INT32 *size)
rc = UINT32_Unmarshal(&data->pcrCounter, buffer, size);
}
#ifdef TPM_ALG_ECC
#if ALG_ECC
needs_block = TRUE;
#else
needs_block = FALSE;
@ -1278,7 +1278,7 @@ STATE_RESET_DATA_Unmarshal(STATE_RESET_DATA *data, BYTE **buffer, INT32 *size)
BLOCK_SKIP_READ(skip_alg_ecc, needs_block, buffer, size,
"STATE_RESET_DATA", "commitCounter");
}
#ifdef TPM_ALG_ECC
#if ALG_ECC
if (rc == TPM_RC_SUCCESS) {
rc = UINT64_Unmarshal(&data->commitCounter, buffer, size);
}
@ -1342,14 +1342,14 @@ STATE_RESET_DATA_Marshal(STATE_RESET_DATA *data, BYTE **buffer, INT32 *size)
buffer, size);
written += UINT32_Marshal(&data->restartCount, buffer, size);
written += UINT32_Marshal(&data->pcrCounter, buffer, size);
#ifdef TPM_ALG_ECC
#if ALG_ECC
has_block = TRUE;
#else
has_block = FALSE;
#endif
written += BLOCK_SKIP_WRITE_PUSH(has_block, buffer, size);
#ifdef TPM_ALG_ECC
#if ALG_ECC
written += UINT64_Marshal(&data->commitCounter, buffer, size);
written += TPM2B_AUTH_Marshal(&data->commitNonce, buffer, size);
@ -1584,7 +1584,7 @@ SHA_LONG64_Unmarshal(SHA_LONG64 *data, BYTE **buffer, INT32 *size)
return UINT64_Unmarshal((UINT64 *)data, buffer, size);
}
#ifdef TPM_ALG_SHA1
#if ALG_SHA1
#define HASH_STATE_SHA1_MAGIC 0x19d46f50
#define HASH_STATE_SHA1_VERSION 2
@ -1692,7 +1692,7 @@ skip_future_versions:
}
#endif
#ifdef TPM_ALG_SHA256
#if ALG_SHA256
#define HASH_STATE_SHA256_MAGIC 0x6ea059d0
#define HASH_STATE_SHA256_VERSION 2
@ -1804,7 +1804,7 @@ skip_future_versions:
}
#endif
#if defined(TPM_ALG_SHA384) || defined(TPM_ALG_SHA512)
#if ALG_SHA384 || ALG_SHA512
#define HASH_STATE_SHA384_MAGIC 0x14814b08
#define HASH_STATE_SHA384_VERSION 2
@ -1946,23 +1946,23 @@ ANY_HASH_STATE_Marshal(ANY_HASH_STATE *data, BYTE **buffer, INT32 *size,
ANY_HASH_STATE_MAGIC, 1);
switch (hashAlg) {
#ifdef TPM_ALG_SHA1
#if ALG_SHA1
case ALG_SHA1_VALUE:
written += tpmHashStateSHA1_Marshal(&data->Sha1, buffer, size);
break;
#endif
#ifdef TPM_ALG_SHA256
#if ALG_SHA256
case ALG_SHA256_VALUE:
written += tpmHashStateSHA256_Marshal(&data->Sha256, buffer, size);
break;
#endif
#ifdef TPM_ALG_SHA384
#if ALG_SHA384
case ALG_SHA384_VALUE:
written += tpmHashStateSHA512_Marshal(&data->Sha384, buffer, size,
ALG_SHA384_VALUE);
break;
#endif
#ifdef TPM_ALG_SHA512
#if ALG_SHA512
case ALG_SHA512_VALUE:
written += tpmHashStateSHA512_Marshal(&data->Sha512, buffer, size,
ALG_SHA512_VALUE);
@ -1996,23 +1996,23 @@ ANY_HASH_STATE_Unmarshal(ANY_HASH_STATE *data, BYTE **buffer, INT32 *size,
}
switch (hashAlg) {
#ifdef TPM_ALG_SHA1
#if ALG_SHA1
case ALG_SHA1_VALUE:
rc = tpmHashStateSHA1_Unmarshal(&data->Sha1, buffer, size);
break;
#endif
#ifdef TPM_ALG_SHA256
#if ALG_SHA256
case ALG_SHA256_VALUE:
rc = tpmHashStateSHA256_Unmarshal(&data->Sha256, buffer, size);
break;
#endif
#ifdef TPM_ALG_SHA384
#if ALG_SHA384
case ALG_SHA384_VALUE:
rc = tpmHashStateSHA512_Unmarshal(&data->Sha384, buffer, size,
ALG_SHA384_VALUE);
break;
#endif
#ifdef TPM_ALG_SHA512
#if ALG_SHA512
case ALG_SHA512_VALUE:
rc = tpmHashStateSHA512_Unmarshal(&data->Sha512, buffer, size,
ALG_SHA512_VALUE);
@ -2267,13 +2267,13 @@ OBJECT_Marshal(OBJECT *data, BYTE **buffer, INT32 *size)
written += TPMT_PUBLIC_Marshal(&data->publicArea, buffer, size);
written += TPMT_SENSITIVE_Marshal(&data->sensitive, buffer, size);
#ifdef TPM_ALG_RSA
#if ALG_RSA
has_block = TRUE;
#else
has_block = FALSE;
#endif
written += BLOCK_SKIP_WRITE_PUSH(has_block, buffer, size);
#ifdef TPM_ALG_RSA
#if ALG_RSA
written += privateExponent_t_Marshal(&data->privateExponent,
buffer, size);
#endif
@ -2315,7 +2315,7 @@ OBJECT_Unmarshal(OBJECT *data, BYTE **buffer, INT32 *size)
rc = TPMT_SENSITIVE_Unmarshal(&data->sensitive, buffer, size);
}
#ifdef TPM_ALG_RSA
#if ALG_RSA
needs_block = TRUE;
#else
needs_block = FALSE;
@ -2324,7 +2324,7 @@ OBJECT_Unmarshal(OBJECT *data, BYTE **buffer, INT32 *size)
BLOCK_SKIP_READ(skip_alg_rsa, needs_block, buffer, size,
"OBJECT", "privateExponent");
}
#ifdef TPM_ALG_RSA
#if ALG_RSA
if (rc == TPM_RC_SUCCESS) {
rc = privateExponent_t_Unmarshal(&data->privateExponent,
buffer, size);

4
src/tpm2/Object.c
View File

@ -3,7 +3,7 @@
/* Manage the object store of the TPM. */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: Object.c 1259 2018-07-10 19:11:09Z kgoldman $ */
/* $Id: Object.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -468,7 +468,7 @@ ObjectLoad(
else
{
object->sensitive = *sensitive;
#ifdef TPM_ALG_RSA
#if ALG_RSA
// If this is an RSA key that is not a parent, complete the load by
// computing the private exponent.
if(publicArea->type == ALG_RSA_VALUE)

4
src/tpm2/Object_spt.c
View File

@ -3,7 +3,7 @@
/* Object Command Support */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: Object_spt.c 1259 2018-07-10 19:11:09Z kgoldman $ */
/* $Id: Object_spt.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -491,7 +491,7 @@ SchemeChecks(
return TPM_RCS_SYMMETRIC;
}
// Special checks for an ECC key
#ifdef TPM_ALG_ECC
#if ALG_ECC
if(publicArea->type == TPM_ALG_ECC)
{
TPM_ECC_CURVE curveID;

22
src/tpm2/PCR.c
View File

@ -3,7 +3,7 @@
/* */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: PCR.c 1047 2017-07-20 18:27:34Z kgoldman $ */
/* $Id: PCR.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -279,27 +279,27 @@ GetSavedPcrPointer(
{
switch(alg)
{
#ifdef TPM_ALG_SHA1
#if ALG_SHA1
case TPM_ALG_SHA1:
return gc.pcrSave.sha1[pcrIndex];
break;
#endif
#ifdef TPM_ALG_SHA256
#if ALG_SHA256
case TPM_ALG_SHA256:
return gc.pcrSave.sha256[pcrIndex];
break;
#endif
#ifdef TPM_ALG_SHA384
#if ALG_SHA384
case TPM_ALG_SHA384:
return gc.pcrSave.sha384[pcrIndex];
break;
#endif
#ifdef TPM_ALG_SHA512
#if ALG_SHA512
case TPM_ALG_SHA512:
return gc.pcrSave.sha512[pcrIndex];
break;
#endif
#ifdef TPM_ALG_SM3_256
#if ALG_SM3_256
case TPM_ALG_SM3_256:
return gc.pcrSave.sm3_256[pcrIndex];
break;
@ -355,27 +355,27 @@ GetPcrPointer(
return NULL;
switch(alg)
{
#ifdef TPM_ALG_SHA1
#if ALG_SHA1
case TPM_ALG_SHA1:
pcr = s_pcrs[pcrNumber].sha1Pcr;
break;
#endif
#ifdef TPM_ALG_SHA256
#if ALG_SHA256
case TPM_ALG_SHA256:
pcr = s_pcrs[pcrNumber].sha256Pcr;
break;
#endif
#ifdef TPM_ALG_SHA384
#if ALG_SHA384
case TPM_ALG_SHA384:
pcr = s_pcrs[pcrNumber].sha384Pcr;
break;
#endif
#ifdef TPM_ALG_SHA512
#if ALG_SHA512
case TPM_ALG_SHA512:
pcr = s_pcrs[pcrNumber].sha512Pcr;
break;
#endif
#ifdef TPM_ALG_SM3_256
#if ALG_SM3_256
case TPM_ALG_SM3_256:
pcr = s_pcrs[pcrNumber].sm3_256Pcr;
break;

6
src/tpm2/PropertyCap.c
View File

@ -3,7 +3,7 @@
/* For accessing the TPM_CAP_TPM_PROPERTY values */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: PropertyCap.c 1259 2018-07-10 19:11:09Z kgoldman $ */
/* $Id: PropertyCap.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -331,7 +331,7 @@ TPMPropertyIsDefined(
case TPM_PT_SPLIT_MAX:
// number of split signing operations supported by the TPM
*value = 0;
#ifdef TPM_ALG_ECC
#if ALG_ECC
*value = sizeof(gr.commitArray) * 8;
#endif
break;
@ -498,7 +498,7 @@ TPMPropertyIsDefined(
*value = gp.algorithmSet;
break;
case TPM_PT_LOADED_CURVES:
#ifdef TPM_ALG_ECC
#if ALG_ECC
// number of loaded ECC curves
*value = ECC_CURVE_COUNT;
#else // TPM_ALG_ECC

2
src/tpm2/SelfTest.h
View File

@ -122,7 +122,7 @@ typedef struct {
const BYTE *dataIn; // data to encrypt
const BYTE *dataOut[NUM_SYM_MODES];// data to decrypt
} SYMMETRIC_TEST_VECTOR;
#ifdef TPM_ALG_RSA
#if ALG_RSA
extern const RSA_KEY c_rsaTestKey; // This is a constant structure
#endif
#define SYM_TEST_VALUE_REF(value, alg, keyBits, mode) \

250
src/tpm2/TpmTypes.h
View File

@ -3,7 +3,7 @@
/* TPM Part 2 Headers */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: TpmTypes.h 1047 2017-07-20 18:27:34Z kgoldman $ */
/* $Id: TpmTypes.h 1259 2018-07-10 19:11:09Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -55,7 +55,7 @@
/* arising in any way out of use or reliance upon this specification or any */
/* information herein. */
/* */
/* (c) Copyright IBM Corp. and others, 2016, 2017 */
/* (c) Copyright IBM Corp. and others, 2016 - 2018 */
/* */
/********************************************************************************/
@ -67,7 +67,7 @@
#include "GpMacros.h"
#include "Capabilities.h"
/* Table 2:5 - Definition of Types for Documentation Clarity (TypedefTable()) */
/* Table 2:5 - Definition of Types for Documentation Clarity */
typedef UINT32 TPM_ALGORITHM_ID;
typedef UINT32 TPM_MODIFIER_INDICATOR;
typedef UINT32 TPM_AUTHORIZATION_SIZE;
@ -896,21 +896,21 @@ typedef struct {
} TPMS_ALGORITHM_DESCRIPTION;
/* Table 2:71 - Definition of TPMU_HA Union */
typedef union {
#ifdef TPM_ALG_SHA1
#if ALG_SHA1
BYTE sha1[SHA1_DIGEST_SIZE];
#endif // TPM_ALG_SHA1
#ifdef TPM_ALG_SHA256
#endif // ALG_SHA1
#if ALG_SHA256
BYTE sha256[SHA256_DIGEST_SIZE];
#endif // TPM_ALG_SHA256
#ifdef TPM_ALG_SHA384
#endif // ALG_SHA256
#if ALG_SHA384
BYTE sha384[SHA384_DIGEST_SIZE];
#endif // TPM_ALG_SHA384
#ifdef TPM_ALG_SHA512
#endif // ALG_SHA384
#if ALG_SHA512
BYTE sha512[SHA512_DIGEST_SIZE];
#endif // TPM_ALG_SHA512
#ifdef TPM_ALG_SM3_256
#endif // ALG_SHA512
#if ALG_SM3_256
BYTE sm3_256[SM3_256_DIGEST_SIZE];
#endif // TPM_ALG_SM3_256
#endif // ALG_SM3_256
} TPMU_HA;
/* Table 2:72 - Definition of TPMT_HA Structure */
typedef struct {
@ -1118,9 +1118,9 @@ typedef union {
TPML_PCR_SELECTION assignedPCR;
TPML_TAGGED_TPM_PROPERTY tpmProperties;
TPML_TAGGED_PCR_PROPERTY pcrProperties;
#ifdef TPM_ALG_ECC
#if ALG_ECC
TPML_ECC_CURVE eccCurves;
#endif // TPM_ALG_ECC
#endif // ALG_ECC
TPML_TAGGED_POLICY authPolicies;
} TPMU_CAPABILITIES;
/* Table 2:111 - Definition of TPMS_CAPABILITY_DATA Structure */
@ -1231,37 +1231,37 @@ typedef TPM_KEY_BITS TPMI_SM4_KEY_BITS;
typedef TPM_KEY_BITS TPMI_CAMELLIA_KEY_BITS;
/* Table 2:128 - Definition of TPMU_SYM_KEY_BITS Union */
typedef union {
#ifdef TPM_ALG_TDES
#if ALG_TDES
TPMI_TDES_KEY_BITS tdes;
#endif // TPM_ALG_TDES
#ifdef TPM_ALG_AES
#endif // ALG_TDES
#if ALG_AES
TPMI_AES_KEY_BITS aes;
#endif // TPM_ALG_AES
#ifdef TPM_ALG_SM4
#endif // ALG_AES
#if ALG_SM4
TPMI_SM4_KEY_BITS sm4;
#endif // TPM_ALG_SM4
#ifdef TPM_ALG_CAMELLIA
#endif // ALG_SM4
#if ALG_CAMELLIA
TPMI_CAMELLIA_KEY_BITS camellia;
#endif // TPM_ALG_CAMELLIA
#endif // ALG_CAMELLIA
TPM_KEY_BITS sym;
#ifdef TPM_ALG_XOR
#if ALG_XOR
TPMI_ALG_HASH xorr;
#endif // TPM_ALG_XOR
#endif // ALG_XOR
} TPMU_SYM_KEY_BITS;
/* Table 2:129 - Definition of TPMU_SYM_MODE Union */
typedef union {
#ifdef TPM_ALG_TDES
#if ALG_TDES
TPMI_ALG_SYM_MODE tdes;
#endif // TPM_ALG_TDES
#ifdef TPM_ALG_AES
#endif // ALG_TDES
#if ALG_AES
TPMI_ALG_SYM_MODE aes;
#endif // TPM_ALG_AES
#ifdef TPM_ALG_SM4
#endif // ALG_AES
#if ALG_SM4
TPMI_ALG_SYM_MODE sm4;
#endif // TPM_ALG_SM4
#ifdef TPM_ALG_CAMELLIA
#endif // ALG_SM4
#if ALG_CAMELLIA
TPMI_ALG_SYM_MODE camellia;
#endif // TPM_ALG_CAMELLIA
#endif // ALG_CAMELLIA
TPMI_ALG_SYM_MODE sym;
} TPMU_SYM_MODE;
/* Table 2:131 - Definition of TPMT_SYM_DEF Structure */
@ -1352,12 +1352,12 @@ typedef struct {
} TPMS_SCHEME_XOR;
/* Table 2:147 - Definition of TPMU_SCHEME_KEYEDHASH Union */
typedef union {
#ifdef TPM_ALG_HMAC
#if ALG_HMAC
TPMS_SCHEME_HMAC hmac;
#endif // TPM_ALG_HMAC
#ifdef TPM_ALG_XOR
#endif // ALG_HMAC
#if ALG_XOR
TPMS_SCHEME_XOR xorr;
#endif // TPM_ALG_XOR
#endif // ALG_XOR
} TPMU_SCHEME_KEYEDHASH;
/* Table 2:148 - Definition of TPMT_KEYEDHASH_SCHEME Structure */
typedef struct {
@ -1374,27 +1374,27 @@ typedef TPMS_SCHEME_HASH TPMS_SIG_SCHEME_ECSCHNORR;
typedef TPMS_SCHEME_ECDAA TPMS_SIG_SCHEME_ECDAA;
/* Table 2:151 - Definition of TPMU_SIG_SCHEME Union */
typedef union {
#ifdef TPM_ALG_ECC
#if ALG_ECC
TPMS_SIG_SCHEME_ECDAA ecdaa;
#endif // TPM_ALG_ECC
#ifdef TPM_ALG_RSASSA
#endif // ALG_ECC
#if ALG_RSASSA
TPMS_SIG_SCHEME_RSASSA rsassa;
#endif // TPM_ALG_RSASSA
#ifdef TPM_ALG_RSAPSS
#endif // ALG_RSASSA
#if ALG_RSAPSS
TPMS_SIG_SCHEME_RSAPSS rsapss;
#endif // TPM_ALG_RSAPSS
#ifdef TPM_ALG_ECDSA
#endif // ALG_RSAPSS
#if ALG_ECDSA
TPMS_SIG_SCHEME_ECDSA ecdsa;
#endif // TPM_ALG_ECDSA
#ifdef TPM_ALG_SM2
#endif // ALG_ECDSA
#if ALG_SM2
TPMS_SIG_SCHEME_SM2 sm2;
#endif // TPM_ALG_SM2
#ifdef TPM_ALG_ECSCHNORR
#endif // ALG_SM2
#if ALG_ECSCHNORR
TPMS_SIG_SCHEME_ECSCHNORR ecschnorr;
#endif // TPM_ALG_ECSCHNORR
#ifdef TPM_ALG_HMAC
#endif // ALG_ECSCHNORR
#if ALG_HMAC
TPMS_SCHEME_HMAC hmac;
#endif // TPM_ALG_HMAC
#endif // ALG_HMAC
TPMS_SCHEME_HASH any;
} TPMU_SIG_SCHEME;
/* Table 2:152 - Definition of TPMT_SIG_SCHEME Structure */
@ -1415,18 +1415,18 @@ typedef TPMS_SCHEME_HASH TPMS_SCHEME_KDF2;
typedef TPMS_SCHEME_HASH TPMS_SCHEME_KDF1_SP800_108;
/* Table 2:156 - Definition of TPMU_KDF_SCHEME Union */
typedef union {
#ifdef TPM_ALG_MGF1
#if ALG_MGF1
TPMS_SCHEME_MGF1 mgf1;
#endif // TPM_ALG_MGF1
#ifdef TPM_ALG_KDF1_SP800_56A
#endif // ALG_MGF1
#if ALG_KDF1_SP800_56A
TPMS_SCHEME_KDF1_SP800_56A kdf1_sp800_56a;
#endif // TPM_ALG_KDF1_SP800_56A
#ifdef TPM_ALG_KDF2
#endif // ALG_KDF1_SP800_56A
#if ALG_KDF2
TPMS_SCHEME_KDF2 kdf2;
#endif // TPM_ALG_KDF2
#ifdef TPM_ALG_KDF1_SP800_108
#endif // ALG_KDF2
#if ALG_KDF1_SP800_108
TPMS_SCHEME_KDF1_SP800_108 kdf1_sp800_108;
#endif // TPM_ALG_KDF1_SP800_108
#endif // ALG_KDF1_SP800_108
} TPMU_KDF_SCHEME;
/* Table 2:157 - Definition of TPMT_KDF_SCHEME Structure */
typedef struct {
@ -1437,36 +1437,36 @@ typedef struct {
typedef TPM_ALG_ID TPMI_ALG_ASYM_SCHEME;
/* Table 2:159 - Definition of TPMU_ASYM_SCHEME Union */
typedef union {
#ifdef TPM_ALG_ECDH
#if ALG_ECDH
TPMS_KEY_SCHEME_ECDH ecdh;
#endif // TPM_ALG_ECDH
#ifdef TPM_ALG_ECMQV
#endif // ALG_ECDH
#if ALG_ECMQV
TPMS_KEY_SCHEME_ECMQV ecmqv;
#endif // TPM_ALG_ECMQV
#ifdef TPM_ALG_ECC
#endif // ALG_ECMQV
#if ALG_ECC
TPMS_SIG_SCHEME_ECDAA ecdaa;
#endif // TPM_ALG_ECC
#ifdef TPM_ALG_RSASSA
#endif // ALG_ECC
#if ALG_RSASSA
TPMS_SIG_SCHEME_RSASSA rsassa;
#endif // TPM_ALG_RSASSA
#ifdef TPM_ALG_RSAPSS
#endif // ALG_RSASSA
#if ALG_RSAPSS
TPMS_SIG_SCHEME_RSAPSS rsapss;
#endif // TPM_ALG_RSAPSS
#ifdef TPM_ALG_ECDSA
#endif // ALG_RSAPSS
#if ALG_ECDSA
TPMS_SIG_SCHEME_ECDSA ecdsa;
#endif // TPM_ALG_ECDSA
#ifdef TPM_ALG_SM2
#endif // ALG_ECDSA
#if ALG_SM2
TPMS_SIG_SCHEME_SM2 sm2;
#endif // TPM_ALG_SM2
#ifdef TPM_ALG_ECSCHNORR
#endif // ALG_SM2
#if ALG_ECSCHNORR
TPMS_SIG_SCHEME_ECSCHNORR ecschnorr;
#endif // TPM_ALG_ECSCHNORR
#ifdef TPM_ALG_RSAES
#endif // ALG_ECSCHNORR
#if ALG_RSAES
TPMS_ENC_SCHEME_RSAES rsaes;
#endif // TPM_ALG_RSAES
#ifdef TPM_ALG_OAEP
#endif // ALG_RSAES
#if ALG_OAEP
TPMS_ENC_SCHEME_OAEP oaep;
#endif // TPM_ALG_OAEP
#endif // ALG_OAEP
TPMS_SCHEME_HASH anySig;
} TPMU_ASYM_SCHEME;
/* Table 2:160 - Definition of TPMT_ASYM_SCHEME Structure */
@ -1568,27 +1568,27 @@ typedef TPMS_SIGNATURE_ECC TPMS_SIGNATURE_SM2;
typedef TPMS_SIGNATURE_ECC TPMS_SIGNATURE_ECSCHNORR;
/* Table 2:179 - Definition of TPMU_SIGNATURE Union */
typedef union {
#ifdef TPM_ALG_ECC
#if ALG_ECC
TPMS_SIGNATURE_ECDAA ecdaa;
#endif // TPM_ALG_ECC
#ifdef TPM_ALG_RSA
#endif // ALG_ECC
#if ALG_RSA
TPMS_SIGNATURE_RSASSA rsassa;
#endif // TPM_ALG_RSA
#ifdef TPM_ALG_RSA
#endif // ALG_RSA
#if ALG_RSA
TPMS_SIGNATURE_RSAPSS rsapss;
#endif // TPM_ALG_RSA
#ifdef TPM_ALG_ECC
#endif // ALG_RSA
#if ALG_ECC
TPMS_SIGNATURE_ECDSA ecdsa;
#endif // TPM_ALG_ECC
#ifdef TPM_ALG_ECC
#endif // ALG_ECC
#if ALG_ECC
TPMS_SIGNATURE_SM2 sm2;
#endif // TPM_ALG_ECC
#ifdef TPM_ALG_ECC
#endif // ALG_ECC
#if ALG_ECC
TPMS_SIGNATURE_ECSCHNORR ecschnorr;
#endif // TPM_ALG_ECC
#ifdef TPM_ALG_HMAC
#endif // ALG_ECC
#if ALG_HMAC
TPMT_HA hmac;
#endif // TPM_ALG_HMAC
#endif // ALG_HMAC
TPMS_SCHEME_HASH any;
} TPMU_SIGNATURE;
/* Table 2:180 - Definition of TPMT_SIGNATURE Structure */
@ -1598,18 +1598,18 @@ typedef struct {
} TPMT_SIGNATURE;
/* Table 2:181 - Definition of TPMU_ENCRYPTED_SECRET Union */
typedef union {
#ifdef TPM_ALG_ECC
#if ALG_ECC
BYTE ecc[sizeof(TPMS_ECC_POINT)];
#endif // TPM_ALG_ECC
#ifdef TPM_ALG_RSA
#endif // ALG_ECC
#if ALG_RSA
BYTE rsa[MAX_RSA_KEY_BYTES];
#endif // TPM_ALG_RSA
#ifdef TPM_ALG_SYMCIPHER
#endif // ALG_RSA
#if ALG_SYMCIPHER
BYTE symmetric[sizeof(TPM2B_DIGEST)];
#endif // TPM_ALG_SYMCIPHER
#ifdef TPM_ALG_KEYEDHASH
#endif // ALG_SYMCIPHER
#if ALG_KEYEDHASH
BYTE keyedHash[sizeof(TPM2B_DIGEST)];
#endif // TPM_ALG_KEYEDHASH
#endif // ALG_KEYEDHASH
} TPMU_ENCRYPTED_SECRET;
/* Table 2:182 - Definition of TPM2B_ENCRYPTED_SECRET Structure */
typedef union {
@ -1623,18 +1623,18 @@ typedef union {
typedef TPM_ALG_ID TPMI_ALG_PUBLIC;
/* Table 2:184 - Definition of TPMU_PUBLIC_ID Union */
typedef union {
#ifdef TPM_ALG_KEYEDHASH
#if ALG_KEYEDHASH
TPM2B_DIGEST keyedHash;
#endif // TPM_ALG_KEYEDHASH
#ifdef TPM_ALG_SYMCIPHER
#endif // ALG_KEYEDHASH
#if ALG_SYMCIPHER
TPM2B_DIGEST sym;
#endif // TPM_ALG_SYMCIPHER
#ifdef TPM_ALG_RSA
#endif // ALG_SYMCIPHER
#if ALG_RSA
TPM2B_PUBLIC_KEY_RSA rsa;
#endif // TPM_ALG_RSA
#ifdef TPM_ALG_ECC
#endif // ALG_RSA
#if ALG_ECC
TPMS_ECC_POINT ecc;
#endif // TPM_ALG_ECC
#endif // ALG_ECC
TPMS_DERIVE derive;
} TPMU_PUBLIC_ID;
/* Table 2:185 - Definition of TPMS_KEYEDHASH_PARMS Structure */
@ -1662,18 +1662,18 @@ typedef struct {
} TPMS_ECC_PARMS;
/* Table 2:189 - Definition of TPMU_PUBLIC_PARMS Union */
typedef union {
#ifdef TPM_ALG_KEYEDHASH
#if ALG_KEYEDHASH
TPMS_KEYEDHASH_PARMS keyedHashDetail;
#endif // TPM_ALG_KEYEDHASH
#ifdef TPM_ALG_SYMCIPHER
#endif // ALG_KEYEDHASH
#if ALG_SYMCIPHER
TPMS_SYMCIPHER_PARMS symDetail;
#endif // TPM_ALG_SYMCIPHER
#ifdef TPM_ALG_RSA
#endif // ALG_SYMCIPHER
#if ALG_RSA
TPMS_RSA_PARMS rsaDetail;
#endif // TPM_ALG_RSA
#ifdef TPM_ALG_ECC
#endif // ALG_RSA
#if ALG_ECC
TPMS_ECC_PARMS eccDetail;
#endif // TPM_ALG_ECC
#endif // ALG_ECC
TPMS_ASYM_PARMS asymDetail;
} TPMU_PUBLIC_PARMS;
/* Table 2:190 - Definition of TPMT_PUBLIC_PARMS Structure */
@ -1713,18 +1713,18 @@ typedef union {
} TPM2B_PRIVATE_VENDOR_SPECIFIC;
/* Table 2:195 - Definition of TPMU_SENSITIVE_COMPOSITE Union */
typedef union {
#ifdef TPM_ALG_RSA
#if ALG_RSA
TPM2B_PRIVATE_KEY_RSA rsa;
#endif // TPM_ALG_RSA
#ifdef TPM_ALG_ECC
#endif // ALG_RSA
#if ALG_ECC
TPM2B_ECC_PARAMETER ecc;
#endif // TPM_ALG_ECC
#ifdef TPM_ALG_KEYEDHASH
#endif // ALG_ECC
#if ALG_KEYEDHASH
TPM2B_SENSITIVE_DATA bits;
#endif // TPM_ALG_KEYEDHASH
#ifdef TPM_ALG_SYMCIPHER
#endif // ALG_KEYEDHASH
#if ALG_SYMCIPHER
TPM2B_SYM_KEY sym;
#endif // TPM_ALG_SYMCIPHER
#endif // ALG_SYMCIPHER
TPM2B_PRIVATE_VENDOR_SPECIFIC any;
} TPMU_SENSITIVE_COMPOSITE;
/* Table 2:196 - Definition of TPMT_SENSITIVE Structure */

266
src/tpm2/Unmarshal.c
View File

@ -3,7 +3,7 @@
/* Parameter Unmarshaling */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: Unmarshal.c 1259 2018-07-10 19:11:09Z kgoldman $ */
/* $Id: Unmarshal.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* (c) Copyright IBM Corporation 2015 - 2018 */
/* */
@ -196,7 +196,7 @@ TPM_ALG_ID_Unmarshal(TPM_ALG_ID *target, BYTE **buffer, INT32 *size)
/* Table 10 - Definition of (UINT16) {ECC} TPM_ECC_CURVE Constants <IN/OUT, S> */
#ifdef TPM_ALG_ECC
#if ALG_ECC
TPM_RC
TPM_ECC_CURVE_Unmarshal(TPM_ECC_CURVE *target, BYTE **buffer, INT32 *size)
{
@ -1067,19 +1067,19 @@ TPMI_ALG_HASH_Unmarshal(TPMI_ALG_HASH *target, BYTE **buffer, INT32 *size, BOOL
}
if (rc == TPM_RC_SUCCESS) {
switch (*target) {
#ifdef TPM_ALG_SHA1
#if ALG_SHA1
case TPM_ALG_SHA1:
#endif
#ifdef TPM_ALG_SHA256
#if ALG_SHA256
case TPM_ALG_SHA256:
#endif
#ifdef TPM_ALG_SHA384
#if ALG_SHA384
case TPM_ALG_SHA384:
#endif
#ifdef TPM_ALG_SHA512
#if ALG_SHA512
case TPM_ALG_SHA512:
#endif
#ifdef TPM_ALG_SM3_256
#if ALG_SM3_256
case TPM_ALG_SM3_256:
#endif
break;
@ -1106,16 +1106,16 @@ TPMI_ALG_SYM_Unmarshal(TPMI_ALG_SYM *target, BYTE **buffer, INT32 *size, BOOL al
}
if (rc == TPM_RC_SUCCESS) {
switch (*target) {
#ifdef TPM_ALG_AES
#if ALG_AES
case TPM_ALG_AES:
#endif
#ifdef TPM_ALG_SM4
#if ALG_SM4
case TPM_ALG_SM4:
#endif
#ifdef TPM_ALG_CAMELLIA
#if ALG_CAMELLIA
case TPM_ALG_CAMELLIA:
#endif
#ifdef TPM_ALG_XOR
#if ALG_XOR
case TPM_ALG_XOR:
#endif
break;
@ -1142,13 +1142,13 @@ TPMI_ALG_SYM_OBJECT_Unmarshal(TPMI_ALG_SYM_OBJECT *target, BYTE **buffer, INT32
}
if (rc == TPM_RC_SUCCESS) {
switch (*target) {
#ifdef TPM_ALG_AES
#if ALG_AES
case TPM_ALG_AES:
#endif
#ifdef TPM_ALG_SM4
#if ALG_SM4
case TPM_ALG_SM4:
#endif
#ifdef TPM_ALG_CAMELLIA
#if ALG_CAMELLIA
case TPM_ALG_CAMELLIA:
#endif
break;
@ -1175,22 +1175,22 @@ TPMI_ALG_SYM_MODE_Unmarshal(TPMI_ALG_SYM_MODE *target, BYTE **buffer, INT32 *siz
}
if (rc == TPM_RC_SUCCESS) {
switch (*target) {
#ifdef TPM_ALG_CTR
#if ALG_CTR
case TPM_ALG_CTR:
#endif
#ifdef TPM_ALG_OFB
#if ALG_OFB
case TPM_ALG_OFB:
#endif
#ifdef TPM_ALG_CBC
#if ALG_CBC
case TPM_ALG_CBC:
#endif
#ifdef TPM_ALG_CFB
#if ALG_CFB
case TPM_ALG_CFB:
#endif
#ifdef TPM_ALG_ECB
#if ALG_ECB
case TPM_ALG_ECB:
#endif
#ifdef TPM_ALG_CMAC
#if ALG_CMAC
case TPM_ALG_CMAC:
#endif
break;
@ -1217,16 +1217,16 @@ TPMI_ALG_KDF_Unmarshal(TPMI_ALG_KDF *target, BYTE **buffer, INT32 *size, BOOL al
}
if (rc == TPM_RC_SUCCESS) {
switch (*target) {
#ifdef TPM_ALG_MGF1
#if ALG_MGF1
case TPM_ALG_MGF1:
#endif
#ifdef TPM_ALG_KDF1_SP800_56A
#if ALG_KDF1_SP800_56A
case TPM_ALG_KDF1_SP800_56A:
#endif
#ifdef TPM_ALG_KDF2
#if ALG_KDF2
case TPM_ALG_KDF2:
#endif
#ifdef TPM_ALG_KDF1_SP800_108
#if ALG_KDF1_SP800_108
case TPM_ALG_KDF1_SP800_108:
#endif
break;
@ -1253,25 +1253,25 @@ TPMI_ALG_SIG_SCHEME_Unmarshal(TPMI_ALG_SIG_SCHEME *target, BYTE **buffer, INT32
}
if (rc == TPM_RC_SUCCESS) {
switch (*target) {
#ifdef TPM_ALG_HMAC
#if ALG_HMAC
case TPM_ALG_HMAC:
#endif
#ifdef TPM_ALG_RSASSA
#if ALG_RSASSA
case TPM_ALG_RSASSA:
#endif
#ifdef TPM_ALG_RSAPSS
#if ALG_RSAPSS
case TPM_ALG_RSAPSS:
#endif
#ifdef TPM_ALG_ECDSA
#if ALG_ECDSA
case TPM_ALG_ECDSA:
#endif
#ifdef TPM_ALG_ECDAA
#if ALG_ECDAA
case TPM_ALG_ECDAA:
#endif
#ifdef TPM_ALG_SM2
#if ALG_SM2
case TPM_ALG_SM2:
#endif
#ifdef TPM_ALG_ECSCHNORR
#if ALG_ECSCHNORR
case TPM_ALG_ECSCHNORR:
#endif
break;
@ -1298,13 +1298,13 @@ TPMI_ECC_KEY_EXCHANGE_Unmarshal(TPMI_ECC_KEY_EXCHANGE *target, BYTE **buffer, IN
}
if (rc == TPM_RC_SUCCESS) {
switch (*target) {
#ifdef TPM_ALG_ECDH
#if ALG_ECDH
case TPM_ALG_ECDH:
#endif
#ifdef TPM_ALG_ECMQV
#if ALG_ECMQV
case TPM_ALG_ECMQV:
#endif
#ifdef TPM_ALG_SM2
#if ALG_SM2
case TPM_ALG_SM2:
#endif
break;
@ -1354,22 +1354,22 @@ TPMI_ALG_MAC_SCHEME_Unmarshal(TPMI_ALG_MAC_SCHEME *target, BYTE **buffer, INT32
}
if (rc == TPM_RC_SUCCESS) {
switch (*target) {
#ifdef TPM_ALG_SHA1
#if ALG_SHA1
case TPM_ALG_SHA1:
#endif
#ifdef TPM_ALG_SHA256
#if ALG_SHA256
case TPM_ALG_SHA256:
#endif
#ifdef TPM_ALG_SHA384
#if ALG_SHA384
case TPM_ALG_SHA384:
#endif
#ifdef TPM_ALG_SHA512
#if ALG_SHA512
case TPM_ALG_SHA512:
#endif
#ifdef TPM_ALG_SM3_256
#if ALG_SM3_256
case TPM_ALG_SM3_256:
#endif
#ifdef TPM_ALG_CMAC
#if ALG_CMAC
case TPM_ALG_CMAC:
#endif
break;
@ -1396,19 +1396,19 @@ TPMI_ALG_CIPHER_MODE_Unmarshal(TPMI_ALG_CIPHER_MODE*target, BYTE **buffer, INT32
}
if (rc == TPM_RC_SUCCESS) {
switch (*target) {
#ifdef TPM_ALG_CTR
#if ALG_CTR
case TPM_ALG_CTR:
#endif
#ifdef TPM_ALG_OFB
#if ALG_OFB
case TPM_ALG_OFB:
#endif
#ifdef TPM_ALG_CBC
#if ALG_CBC
case TPM_ALG_CBC:
#endif
#ifdef TPM_ALG_CFB
#if ALG_CFB
case TPM_ALG_CFB:
#endif
#ifdef TPM_ALG_ECB
#if ALG_ECB
case TPM_ALG_ECB:
#endif
break;
@ -1443,27 +1443,27 @@ TPMU_HA_Unmarshal(TPMU_HA *target, BYTE **buffer, INT32 *size, UINT32 selector)
TPM_RC rc = TPM_RC_SUCCESS;
switch (selector) {
#ifdef TPM_ALG_SHA1
#if ALG_SHA1
case TPM_ALG_SHA1:
rc = Array_Unmarshal(target->sha1, SHA1_DIGEST_SIZE, buffer, size);
break;
#endif
#ifdef TPM_ALG_SHA256
#if ALG_SHA256
case TPM_ALG_SHA256:
rc = Array_Unmarshal(target->sha256, SHA256_DIGEST_SIZE, buffer, size);
break;
#endif
#ifdef TPM_ALG_SHA384
#if ALG_SHA384
case TPM_ALG_SHA384:
rc = Array_Unmarshal(target->sha384, SHA384_DIGEST_SIZE, buffer, size);
break;
#endif
#ifdef TPM_ALG_SHA512
#if ALG_SHA512
case TPM_ALG_SHA512:
rc = Array_Unmarshal(target->sha512, SHA512_DIGEST_SIZE, buffer, size);
break;
#endif
#ifdef TPM_ALG_SM3_256
#if ALG_SM3_256
case TPM_ALG_SM3_256:
rc = Array_Unmarshal(target->sm3_256, SM3_256_DIGEST_SIZE, buffer, size);
break;
@ -2444,7 +2444,7 @@ TPMS_AUTH_RESPONSE_Unmarshal(TPMS_AUTH_RESPONSE *target, BYTE **buffer, INT32 *s
/* Table 124 - Definition of {!ALG.S} (TPM_KEY_BITS) TPMI_!ALG.S_KEY_BITS Type */
#ifdef TPM_ALG_AES
#if ALG_AES
TPM_RC
TPMI_AES_KEY_BITS_Unmarshal(TPMI_AES_KEY_BITS *target, BYTE **buffer, INT32 *size)
{
@ -2466,7 +2466,7 @@ TPMI_AES_KEY_BITS_Unmarshal(TPMI_AES_KEY_BITS *target, BYTE **buffer, INT32 *siz
}
#endif
#ifdef TPM_ALG_CAMELLIA
#if ALG_CAMELLIA
TPM_RC
TPMI_CAMELLIA_KEY_BITS_Unmarshal(TPMI_CAMELLIA_KEY_BITS *target, BYTE **buffer, INT32 *size)
{
@ -2487,7 +2487,7 @@ TPMI_CAMELLIA_KEY_BITS_Unmarshal(TPMI_CAMELLIA_KEY_BITS *target, BYTE **buffer,
}
#endif
#ifdef TPM_ALG_SM4
#if ALG_SM4
TPM_RC
TPMI_SM4_KEY_BITS_Unmarshal(TPMI_SM4_KEY_BITS *target, BYTE **buffer, INT32 *size)
{
@ -2516,22 +2516,22 @@ TPMU_SYM_KEY_BITS_Unmarshal(TPMU_SYM_KEY_BITS *target, BYTE **buffer, INT32 *siz
TPM_RC rc = TPM_RC_SUCCESS;
switch (selector) {
#ifdef TPM_ALG_AES
#if ALG_AES
case TPM_ALG_AES:
rc = TPMI_AES_KEY_BITS_Unmarshal(&target->aes, buffer, size);
break;
#endif
#ifdef TPM_ALG_SM4
#if ALG_SM4
case TPM_ALG_SM4:
rc = TPMI_SM4_KEY_BITS_Unmarshal(&target->sm4, buffer, size);
break;
#endif
#ifdef TPM_ALG_CAMELLIA
#if ALG_CAMELLIA
case TPM_ALG_CAMELLIA:
rc = TPMI_CAMELLIA_KEY_BITS_Unmarshal(&target->camellia, buffer, size);
break;
#endif
#ifdef TPM_ALG_XOR
#if ALG_XOR
case TPM_ALG_XOR:
rc = TPMI_ALG_HASH_Unmarshal(&target->xorr, buffer, size, NO);
break;
@ -2552,17 +2552,17 @@ TPMU_SYM_MODE_Unmarshal(TPMU_SYM_MODE *target, BYTE **buffer, INT32 *size, UINT3
TPM_RC rc = TPM_RC_SUCCESS;
switch (selector) {
#ifdef TPM_ALG_AES
#if ALG_AES
case TPM_ALG_AES:
rc = TPMI_ALG_SYM_MODE_Unmarshal(&target->aes, buffer, size, YES);
break;
#endif
#ifdef TPM_ALG_SM4
#if ALG_SM4
case TPM_ALG_SM4:
rc = TPMI_ALG_SYM_MODE_Unmarshal(&target->sm4, buffer, size, YES);
break;
#endif
#ifdef TPM_ALG_CAMELLIA
#if ALG_CAMELLIA
case TPM_ALG_CAMELLIA:
rc = TPMI_ALG_SYM_MODE_Unmarshal(&target->camellia, buffer, size, YES);
break;
@ -2782,10 +2782,10 @@ TPMI_ALG_KEYEDHASH_SCHEME_Unmarshal(TPMI_ALG_KEYEDHASH_SCHEME *target, BYTE **bu
}
if (rc == TPM_RC_SUCCESS) {
switch (*target) {
#ifdef TPM_ALG_HMAC
#if ALG_HMAC
case TPM_ALG_HMAC:
#endif
#ifdef TPM_ALG_XOR
#if ALG_XOR
case TPM_ALG_XOR:
#endif
break;
@ -2837,12 +2837,12 @@ TPMU_SCHEME_KEYEDHASH_Unmarshal(TPMU_SCHEME_KEYEDHASH *target, BYTE **buffer, IN
TPM_RC rc = TPM_RC_SUCCESS;
switch (selector) {
#ifdef TPM_ALG_HMAC
#if ALG_HMAC
case TPM_ALG_HMAC:
rc = TPMS_SCHEME_HMAC_Unmarshal(&target->hmac, buffer, size);
break;
#endif
#ifdef TPM_ALG_XOR
#if ALG_XOR
case TPM_ALG_XOR:
rc = TPMS_SCHEME_XOR_Unmarshal(&target->xorr, buffer, size);
break;
@ -2957,37 +2957,37 @@ TPMU_SIG_SCHEME_Unmarshal(TPMU_SIG_SCHEME *target, BYTE **buffer, INT32 *size, U
TPM_RC rc = TPM_RC_SUCCESS;
switch (selector) {
#ifdef TPM_ALG_RSASSA
#if ALG_RSASSA
case TPM_ALG_RSASSA:
rc = TPMS_SIG_SCHEME_RSASSA_Unmarshal(&target->rsassa, buffer, size);
break;
#endif
#ifdef TPM_ALG_RSAPSS
#if ALG_RSAPSS
case TPM_ALG_RSAPSS:
rc = TPMS_SIG_SCHEME_RSAPSS_Unmarshal(&target->rsapss, buffer, size);
break;
#endif
#ifdef TPM_ALG_ECDSA
#if ALG_ECDSA
case TPM_ALG_ECDSA:
rc = TPMS_SIG_SCHEME_ECDSA_Unmarshal(&target->ecdsa, buffer, size);
break;
#endif
#ifdef TPM_ALG_ECDAA
#if ALG_ECDAA
case TPM_ALG_ECDAA:
rc = TPMS_SIG_SCHEME_ECDAA_Unmarshal(&target->ecdaa, buffer, size);
break;
#endif
#ifdef TPM_ALG_SM2
#if ALG_SM2
case TPM_ALG_SM2:
rc = TPMS_SIG_SCHEME_SM2_Unmarshal(&target->sm2, buffer, size);
break;
#endif
#ifdef TPM_ALG_ECSCHNORR
#if ALG_ECSCHNORR
case TPM_ALG_ECSCHNORR:
rc = TPMS_SIG_SCHEME_ECSCHNORR_Unmarshal(&target->ecschnorr, buffer, size);
break;
#endif
#ifdef TPM_ALG_HMAC
#if ALG_HMAC
case TPM_ALG_HMAC:
rc = TPMS_SCHEME_HMAC_Unmarshal(&target->hmac, buffer, size);
break;
@ -3128,22 +3128,22 @@ TPMU_KDF_SCHEME_Unmarshal(TPMU_KDF_SCHEME *target, BYTE **buffer, INT32 *size, U
TPM_RC rc = TPM_RC_SUCCESS;
switch (selector) {
#ifdef TPM_ALG_MGF1
#if ALG_MGF1
case TPM_ALG_MGF1:
rc = TPMS_SCHEME_MGF1_Unmarshal(&target->mgf1, buffer, size);
break;
#endif
#ifdef TPM_ALG_KDF1_SP800_56A
#if ALG_KDF1_SP800_56A
case TPM_ALG_KDF1_SP800_56A:
rc = TPMS_SCHEME_KDF1_SP800_56A_Unmarshal(&target->kdf1_sp800_56a, buffer, size);
break;
#endif
#ifdef TPM_ALG_KDF2
#if ALG_KDF2
case TPM_ALG_KDF2:
rc = TPMS_SCHEME_KDF2_Unmarshal(&target->kdf2, buffer, size);
break;
#endif
#ifdef TPM_ALG_KDF1_SP800_108
#if ALG_KDF1_SP800_108
case TPM_ALG_KDF1_SP800_108:
rc = TPMS_SCHEME_KDF1_SP800_108_Unmarshal(&target->kdf1_sp800_108, buffer, size);
break;
@ -3185,34 +3185,34 @@ TPMI_ALG_ASYM_SCHEME_Unmarshal(TPMI_ALG_ASYM_SCHEME *target, BYTE **buffer, INT3
}
if (rc == TPM_RC_SUCCESS) {
switch (*target) {
#ifdef TPM_ALG_ECDH
#if ALG_ECDH
case TPM_ALG_ECDH:
#endif
#ifdef TPM_ALG_ECMQV
#if ALG_ECMQV
case TPM_ALG_ECMQV:
#endif
#ifdef TPM_ALG_RSASSA
#if ALG_RSASSA
case TPM_ALG_RSASSA:
#endif
#ifdef TPM_ALG_RSAPSS
#if ALG_RSAPSS
case TPM_ALG_RSAPSS:
#endif
#ifdef TPM_ALG_ECDSA
#if ALG_ECDSA
case TPM_ALG_ECDSA:
#endif
#ifdef TPM_ALG_ECDAA
#if ALG_ECDAA
case TPM_ALG_ECDAA:
#endif
#ifdef TPM_ALG_SM2
#if ALG_SM2
case TPM_ALG_SM2:
#endif
#ifdef TPM_ALG_ECSCHNORR
#if ALG_ECSCHNORR
case TPM_ALG_ECSCHNORR:
#endif
#ifdef TPM_ALG_RSAES
#if ALG_RSAES
case TPM_ALG_RSAES:
#endif
#ifdef TPM_ALG_OAEP
#if ALG_OAEP
case TPM_ALG_OAEP:
#endif
break;
@ -3236,52 +3236,52 @@ TPMU_ASYM_SCHEME_Unmarshal(TPMU_ASYM_SCHEME *target, BYTE **buffer, INT32 *size,
TPM_RC rc = TPM_RC_SUCCESS;
switch (selector) {
#ifdef TPM_ALG_ECDH
#if ALG_ECDH
case TPM_ALG_ECDH:
rc = TPMS_KEY_SCHEME_ECDH_Unmarshal(&target->ecdh, buffer, size);
break;
#endif
#ifdef TPM_ALG_ECMQV
#if ALG_ECMQV
case TPM_ALG_ECMQV:
rc = TPMS_KEY_SCHEME_ECMQV_Unmarshal(&target->ecmqv, buffer, size);
break;
#endif
#ifdef TPM_ALG_RSASSA
#if ALG_RSASSA
case TPM_ALG_RSASSA:
rc = TPMS_SIG_SCHEME_RSASSA_Unmarshal(&target->rsassa, buffer, size);
break;
#endif
#ifdef TPM_ALG_RSAPSS
#if ALG_RSAPSS
case TPM_ALG_RSAPSS:
rc = TPMS_SIG_SCHEME_RSAPSS_Unmarshal(&target->rsapss, buffer, size);
break;
#endif
#ifdef TPM_ALG_ECDSA
#if ALG_ECDSA
case TPM_ALG_ECDSA:
rc = TPMS_SIG_SCHEME_ECDSA_Unmarshal(&target->ecdsa, buffer, size);
break;
#endif
#ifdef TPM_ALG_ECDAA
#if ALG_ECDAA
case TPM_ALG_ECDAA:
rc = TPMS_SIG_SCHEME_ECDAA_Unmarshal(&target->ecdaa, buffer, size);
break;
#endif
#ifdef TPM_ALG_SM2
#if ALG_SM2
case TPM_ALG_SM2:
rc = TPMS_SIG_SCHEME_SM2_Unmarshal(&target->sm2, buffer, size);
break;
#endif
#ifdef TPM_ALG_ECSCHNORR
#if ALG_ECSCHNORR
case TPM_ALG_ECSCHNORR:
rc = TPMS_SIG_SCHEME_ECSCHNORR_Unmarshal(&target->ecschnorr, buffer, size);
break;
#endif
#ifdef TPM_ALG_RSAES
#if ALG_RSAES
case TPM_ALG_RSAES:
rc = TPMS_ENC_SCHEME_RSAES_Unmarshal(&target->rsaes, buffer, size);
break;
#endif
#ifdef TPM_ALG_OAEP
#if ALG_OAEP
case TPM_ALG_OAEP:
rc = TPMS_ENC_SCHEME_OAEP_Unmarshal(&target->oaep, buffer, size);
break;
@ -3324,16 +3324,16 @@ TPMI_ALG_RSA_SCHEME_Unmarshal(TPMI_ALG_RSA_SCHEME *target, BYTE **buffer, INT32
}
if (rc == TPM_RC_SUCCESS) {
switch (*target) {
#ifdef TPM_ALG_RSASSA
#if ALG_RSASSA
case TPM_ALG_RSASSA:
#endif
#ifdef TPM_ALG_RSAPSS
#if ALG_RSAPSS
case TPM_ALG_RSAPSS:
#endif
#ifdef TPM_ALG_RSAES
#if ALG_RSAES
case TPM_ALG_RSAES:
#endif
#ifdef TPM_ALG_OAEP
#if ALG_OAEP
case TPM_ALG_OAEP:
#endif
break;
@ -3376,10 +3376,10 @@ TPMI_ALG_RSA_DECRYPT_Unmarshal(TPMI_ALG_RSA_DECRYPT *target, BYTE **buffer, INT3
}
if (rc == TPM_RC_SUCCESS) {
switch (*target) {
#ifdef TPM_ALG_RSAES
#if ALG_RSAES
case TPM_ALG_RSAES:
#endif
#ifdef TPM_ALG_OAEP
#if ALG_OAEP
case TPM_ALG_OAEP:
#endif
break;
@ -3529,22 +3529,22 @@ TPMI_ALG_ECC_SCHEME_Unmarshal(TPMI_ALG_ECC_SCHEME *target, BYTE **buffer, INT32
}
if (rc == TPM_RC_SUCCESS) {
switch (*target) {
#ifdef TPM_ALG_ECDSA
#if ALG_ECDSA
case TPM_ALG_ECDSA:
#endif
#ifdef TPM_ALG_SM2
#if ALG_SM2
case TPM_ALG_SM2:
#endif
#ifdef TPM_ALG_ECDAA
#if ALG_ECDAA
case TPM_ALG_ECDAA:
#endif
#ifdef TPM_ALG_ECSCHNORR
#if ALG_ECSCHNORR
case TPM_ALG_ECSCHNORR:
#endif
#ifdef TPM_ALG_ECDH
#if ALG_ECDH
case TPM_ALG_ECDH:
#endif
#ifdef TPM_ALG_ECMQV
#if ALG_ECMQV
case TPM_ALG_ECMQV:
#endif
break;
@ -3571,13 +3571,13 @@ TPMI_ECC_CURVE_Unmarshal(TPMI_ECC_CURVE *target, BYTE **buffer, INT32 *size)
}
if (rc == TPM_RC_SUCCESS) {
switch (*target) {
#ifdef TPM_ECC_BN_P256
#if ECC_BN_P256
case TPM_ECC_BN_P256:
#endif
#ifdef TPM_ECC_NIST_P256
#if ECC_NIST_P256
case TPM_ECC_NIST_P256:
#endif
#ifdef TPM_ECC_NIST_P384
#if ECC_NIST_P384
case TPM_ECC_NIST_P384:
#endif
break;
@ -3762,37 +3762,37 @@ TPMU_SIGNATURE_Unmarshal(TPMU_SIGNATURE *target, BYTE **buffer, INT32 *size, UIN
TPM_RC rc = TPM_RC_SUCCESS;
switch (selector) {
#ifdef TPM_ALG_RSASSA
#if ALG_RSASSA
case TPM_ALG_RSASSA:
rc = TPMS_SIGNATURE_RSASSA_Unmarshal(&target->rsassa, buffer, size);
break;
#endif
#ifdef TPM_ALG_RSAPSS
#if ALG_RSAPSS
case TPM_ALG_RSAPSS:
rc = TPMS_SIGNATURE_RSAPSS_Unmarshal(&target->rsapss, buffer, size);
break;
#endif
#ifdef TPM_ALG_ECDSA
#if ALG_ECDSA
case TPM_ALG_ECDSA:
rc = TPMS_SIGNATURE_ECDSA_Unmarshal(&target->ecdsa, buffer, size);
break;
#endif
#ifdef TPM_ALG_ECDAA
#if ALG_ECDAA
case TPM_ALG_ECDAA:
rc = TPMS_SIGNATURE_ECDAA_Unmarshal(&target->ecdaa, buffer, size);
break;
#endif
#ifdef TPM_ALG_SM2
#if ALG_SM2
case TPM_ALG_SM2:
rc = TPMS_SIGNATURE_SM2_Unmarshal(&target->sm2, buffer, size);
break;
#endif
#ifdef TPM_ALG_ECSCHNORR
#if ALG_ECSCHNORR
case TPM_ALG_ECSCHNORR:
rc = TPMS_SIGNATURE_ECSCHNORR_Unmarshal(&target->ecschnorr, buffer, size);
break;
#endif
#ifdef TPM_ALG_HMAC
#if ALG_HMAC
case TPM_ALG_HMAC:
rc = TPMT_HA_Unmarshal(&target->hmac, buffer, size, NO);
break;
@ -3846,16 +3846,16 @@ TPMI_ALG_PUBLIC_Unmarshal(TPMI_ALG_PUBLIC *target, BYTE **buffer, INT32 *size)
}
if (rc == TPM_RC_SUCCESS) {
switch (*target) {
#ifdef TPM_ALG_KEYEDHASH
#if ALG_KEYEDHASH
case TPM_ALG_KEYEDHASH:
#endif
#ifdef TPM_ALG_RSA
#if ALG_RSA
case TPM_ALG_RSA:
#endif
#ifdef TPM_ALG_ECC
#if ALG_ECC
case TPM_ALG_ECC:
#endif
#ifdef TPM_ALG_SYMCIPHER
#if ALG_SYMCIPHER
case TPM_ALG_SYMCIPHER:
#endif
break;
@ -3874,22 +3874,22 @@ TPMU_PUBLIC_ID_Unmarshal(TPMU_PUBLIC_ID *target, BYTE **buffer, INT32 *size, UIN
TPM_RC rc = TPM_RC_SUCCESS;
switch (selector) {
#ifdef TPM_ALG_KEYEDHASH
#if ALG_KEYEDHASH
case TPM_ALG_KEYEDHASH:
rc = TPM2B_DIGEST_Unmarshal(&target->keyedHash, buffer, size);
break;
#endif
#ifdef TPM_ALG_SYMCIPHER
#if ALG_SYMCIPHER
case TPM_ALG_SYMCIPHER:
rc = TPM2B_DIGEST_Unmarshal(&target->sym, buffer, size);
break;
#endif
#ifdef TPM_ALG_RSA
#if ALG_RSA
case TPM_ALG_RSA:
rc = TPM2B_PUBLIC_KEY_RSA_Unmarshal(&target->rsa, buffer, size);
break;
#endif
#ifdef TPM_ALG_ECC
#if ALG_ECC
case TPM_ALG_ECC:
rc = TPMS_ECC_POINT_Unmarshal(&target->ecc, buffer, size);
break;
@ -3983,22 +3983,22 @@ TPMU_PUBLIC_PARMS_Unmarshal(TPMU_PUBLIC_PARMS *target, BYTE **buffer, INT32 *siz
TPM_RC rc = TPM_RC_SUCCESS;
switch (selector) {
#ifdef TPM_ALG_KEYEDHASH
#if ALG_KEYEDHASH
case TPM_ALG_KEYEDHASH:
rc = TPMS_KEYEDHASH_PARMS_Unmarshal(&target->keyedHashDetail, buffer, size);
break;
#endif
#ifdef TPM_ALG_SYMCIPHER
#if ALG_SYMCIPHER
case TPM_ALG_SYMCIPHER:
rc = TPMS_SYMCIPHER_PARMS_Unmarshal(&target->symDetail, buffer, size);
break;
#endif
#ifdef TPM_ALG_RSA
#if ALG_RSA
case TPM_ALG_RSA:
rc = TPMS_RSA_PARMS_Unmarshal(&target->rsaDetail, buffer, size);
break;
#endif
#ifdef TPM_ALG_ECC
#if ALG_ECC
case TPM_ALG_ECC:
rc = TPMS_ECC_PARMS_Unmarshal(&target->eccDetail, buffer, size);
break;
@ -4119,22 +4119,22 @@ TPMU_SENSITIVE_COMPOSITE_Unmarshal(TPMU_SENSITIVE_COMPOSITE *target, BYTE **buff
TPM_RC rc = TPM_RC_SUCCESS;
switch (selector) {
#ifdef TPM_ALG_RSA
#if ALG_RSA
case TPM_ALG_RSA:
rc = TPM2B_PRIVATE_KEY_RSA_Unmarshal(&target->rsa, buffer, size);
break;
#endif
#ifdef TPM_ALG_ECC
#if ALG_ECC
case TPM_ALG_ECC:
rc = TPM2B_ECC_PARAMETER_Unmarshal(&target->ecc, buffer, size);
break;
#endif
#ifdef TPM_ALG_KEYEDHASH
#if ALG_KEYEDHASH
case TPM_ALG_KEYEDHASH:
rc = TPM2B_SENSITIVE_DATA_Unmarshal(&target->bits, buffer, size);
break;
#endif
#ifdef TPM_ALG_SYMCIPHER
#if ALG_SYMCIPHER
case TPM_ALG_SYMCIPHER:
rc = TPM2B_SYM_KEY_Unmarshal(&target->sym, buffer, size);
break;

12
src/tpm2/crypto/CryptHash.h
View File

@ -3,7 +3,7 @@
/* Hash structure definitions */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: CryptHash.h 1259 2018-07-10 19:11:09Z kgoldman $ */
/* $Id: CryptHash.h 1265 2018-07-15 18:29:22Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -102,7 +102,7 @@ typedef struct tpmCmacState {
TPM2B_SYM_KEY symKey;
} tpmCmacState_t;
typedef union SMAC_STATES {
#ifdef TPM_ALG_CMAC
#if ALG_CMAC
tpmCmacState_t cmac;
#endif
UINT64 pad;
@ -113,16 +113,16 @@ typedef struct SMAC_STATE {
} SMAC_STATE;
typedef union
{
#ifdef TPM_ALG_SHA1
#if ALG_SHA1
tpmHashStateSHA1_t Sha1;
#endif
#ifdef TPM_ALG_SHA256
#if ALG_SHA256
tpmHashStateSHA256_t Sha256;
#endif
#ifdef TPM_ALG_SHA384
#if ALG_SHA384
tpmHashStateSHA384_t Sha384;
#endif
#ifdef TPM_ALG_SHA512
#if ALG_SHA512
tpmHashStateSHA512_t Sha512;
#endif
// Additions for symmetric block cipher MAC

12
src/tpm2/crypto/CryptHashData.h
View File

@ -3,7 +3,7 @@
/* */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: CryptHashData.h 809 2016-11-16 18:31:54Z kgoldman $ */
/* $Id: CryptHashData.h 1265 2018-07-15 18:29:22Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -66,23 +66,23 @@
/* 10.1.4 CryptHashData.h */
#ifdef GLOBAL_C
const HASH_INFO g_hashData[HASH_COUNT + 1] = {
#ifdef TPM_ALG_SHA1
#if ALG_SHA1
{TPM_ALG_SHA1, SHA1_DIGEST_SIZE, SHA1_BLOCK_SIZE,
SHA1_DER_SIZE, {SHA1_DER}},
#endif
#ifdef TPM_ALG_SHA256
#if ALG_SHA256
{TPM_ALG_SHA256, SHA256_DIGEST_SIZE, SHA256_BLOCK_SIZE,
SHA256_DER_SIZE, {SHA256_DER}},
#endif
#ifdef TPM_ALG_SHA512
#if ALG_SHA512
{TPM_ALG_SHA512, SHA512_DIGEST_SIZE, SHA512_BLOCK_SIZE,
SHA512_DER_SIZE, {SHA512_DER}},
#endif
#ifdef TPM_ALG_SHA384
#if ALG_SHA384
{TPM_ALG_SHA384, SHA384_DIGEST_SIZE, SHA384_BLOCK_SIZE,
SHA384_DER_SIZE, {SHA384_DER}},
#endif
#ifdef TPM_ALG_SM3_256
#if ALG_SM3_256
{TPM_ALG_SM3_256, SM3_256_DIGEST_SIZE, SM3_256_BLOCK_SIZE,
SM3_256_DER_SIZE, {SM3_256_DER}},
#endif

21
src/tpm2/crypto/CryptSym.h
View File

@ -3,7 +3,7 @@
/* Implementation of the symmetric block cipher modes */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: CryptSym.h 1047 2017-07-20 18:27:34Z kgoldman $ */
/* $Id: CryptSym.h 1259 2018-07-10 19:11:09Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -55,26 +55,25 @@
/* arising in any way out of use or reliance upon this specification or any */
/* information herein. */
/* */
/* (c) Copyright IBM Corp. and others, 2017 */
/* (c) Copyright IBM Corp. and others, 2017 - 2018 */
/* */
/********************************************************************************/
/* kgold - Missing in 146 code merge. Taken from 142. */
#ifndef CRYPTSYM_H
#define CRYPTSYM_H
union tpmCryptKeySchedule_t {
#ifdef TPM_ALG_AES
#if ALG_AES
tpmKeyScheduleAES AES;
#endif
#ifdef TPM_ALG_SM4
#if ALG_SM4
tpmKeyScheduleSM4 SM4;
#endif
#ifdef TPM_ALG_CAMELLIA
#if ALG_CAMELLIA
tpmKeyScheduleCAMELLIA CAMELLIA;
#endif
#ifdef TPM_ALG_TDES
#if ALG_TDES
tpmKeyScheduleTDES TDES[3];
#endif
#if SYMMETRIC_ALIGNMENT == 8
@ -108,28 +107,28 @@ union tpmCryptKeySchedule_t {
TpmCryptSetDecryptKey##ALG(key, keySizeInBits, &keySchedule.ALG); \
decrypt = (TpmCryptSetSymKeyCall_t)TpmCryptDecrypt##ALG; \
break;
#ifdef TPM_ALG_AES
#if ALG_AES
#define ENCRYPT_CASE_AES ENCRYPT_CASE(AES)
#define DECRYPT_CASE_AES DECRYPT_CASE(AES)
#else
#define ENCRYPT_CASE_AES
#define DECRYPT_CASE_AES
#endif
#ifdef TPM_ALG_SM4
#if ALG_SM4
#define ENCRYPT_CASE_SM4 ENCRYPT_CASE(SM4)
#define DECRYPT_CASE_SM4 DECRYPT_CASE(SM4)
#else
#define ENCRYPT_CASE_SM4
#define DECRYPT_CASE_SM4
#endif
#ifdef TPM_ALG_CAMELLIA
#if ALG_CAMELLIA
#define ENCRYPT_CASE_CAMELLIA ENCRYPT_CASE(CAMELLIA)
#define DECRYPT_CASE_CAMELLIA DECRYPT_CASE(CAMELLIA)
#else
#define ENCRYPT_CASE_CAMELLIA
#define DECRYPT_CASE_CAMELLIA
#endif
#ifdef TPM_ALG_TDES
#if ALG_TDES
#define ENCRYPT_CASE_TDES ENCRYPT_CASE(TDES)
#define DECRYPT_CASE_TDES DECRYPT_CASE(TDES)
#else

6
src/tpm2/crypto/CryptTest.h
View File

@ -3,7 +3,7 @@
/* constant definitions used for self-test. */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: CryptTest.h 1047 2017-07-20 18:27:34Z kgoldman $ */
/* $Id: CryptTest.h 1265 2018-07-15 18:29:22Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -82,10 +82,10 @@ typedef struct
UINT32 rng;
UINT32 hash;
UINT32 sym;
#ifdef TPM_ALG_RSA
#if ALG_RSA
UINT32 rsa;
#endif
#ifdef TPM_ALG_ECC
#if ALG_ECC
UINT32 ecc;
#endif
} CRYPTO_SELF_TEST_STATE;

4
src/tpm2/crypto/openssl/CryptCmac.c
View File

@ -3,7 +3,7 @@
/* Message Authentication Codes Based on a Symmetric Block Cipher */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: CryptCmac.c 1259 2018-07-10 19:11:09Z kgoldman $ */
/* $Id: CryptCmac.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -68,7 +68,7 @@
#define _CRYPT_HASH_C_
#include "Tpm.h"
#include "CryptSym.h"
#ifdef TPM_ALG_CMAC
#if ALG_CMAC
/* 10.2.6.3 Functions */
/* 10.2.6.3.1 CryptCmacStart() */
/* This is the function to start the CMAC sequence operation. It initializes the dispatch

4
src/tpm2/crypto/openssl/CryptDataEcc.c
View File

@ -3,7 +3,7 @@
/* */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: CryptDataEcc.c 1012 2017-05-23 21:45:57Z kgoldman $ */
/* $Id: CryptDataEcc.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -61,7 +61,7 @@
/* 10.2.8 CryptDataEcc.c */
#include "Tpm.h"
#ifdef TPM_ALG_ECC
#if ALG_ECC
/* Defines for the sizes of ECC parameters */
TPM2B_BYTE_VALUE(1);
TPM2B_BYTE_VALUE(16);

4
src/tpm2/crypto/openssl/CryptDes.c
View File

@ -3,7 +3,7 @@
/* Functions Required for TDES */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: CryptDes.c 1259 2018-07-10 19:11:09Z kgoldman $ */
/* $Id: CryptDes.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -64,7 +64,7 @@
/* This file contains the extra functions required for TDES. */
/* 10.2.9.2 Includes, Defines, and Typedefs */
#include "Tpm.h"
#ifdef TPM_ALG_TDES
#if ALG_TDES
#define DES_NUM_WEAK 64
const UINT64 DesWeakKeys[DES_NUM_WEAK] = {
0x0101010101010101ULL, 0xFEFEFEFEFEFEFEFEULL, 0xE0E0E0E0F1F1F1F1ULL, 0x1F1F1F1F0E0E0E0EULL,

34
src/tpm2/crypto/openssl/CryptEccKeyExchange.c
View File

@ -3,7 +3,7 @@
/* Functions that are used for the two-phase, ECC, key-exchange protocols */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: CryptEccKeyExchange.c 1047 2017-07-20 18:27:34Z kgoldman $ */
/* $Id: CryptEccKeyExchange.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -55,25 +55,25 @@
/* arising in any way out of use or reliance upon this specification or any */
/* information herein. */
/* */
/* (c) Copyright IBM Corp. and others, 2016 */
/* (c) Copyright IBM Corp. and others, 2016 - 2018 */
/* */
/********************************************************************************/
/* 10.2.11 CryptEccKeyExchange.c */
#include "Tpm.h"
/* libtpms added: */
LIB_EXPORT TPM_RC
SM2KeyExchange(
TPMS_ECC_POINT *outZ, // OUT: the computed point
TPM_ECC_CURVE curveId, // IN: the curve for the computations
TPM2B_ECC_PARAMETER *dsAIn, // IN: static private TPM key
TPM2B_ECC_PARAMETER *deAIn, // IN: ephemeral private TPM key
TPMS_ECC_POINT *QsBIn, // IN: static public party B key
TPMS_ECC_POINT *QeBIn // IN: ephemeral public party B key
);
TPMS_ECC_POINT *outZ, // OUT: the computed point
TPM_ECC_CURVE curveId, // IN: the curve for the computations
TPM2B_ECC_PARAMETER *dsAIn, // IN: static private TPM key
TPM2B_ECC_PARAMETER *deAIn, // IN: ephemeral private TPM key
TPMS_ECC_POINT *QsBIn, // IN: static public party B key
TPMS_ECC_POINT *QeBIn // IN: ephemeral public party B key
);
#if CC_ZGen_2Phase == YES //%
#ifdef TPM_ALG_ECMQV
#if CC_ZGen_2Phase == YES
#if ALG_ECMQV
/* 10.2.11.1.1 avf1() */
/* This function does the associated value computation required by MQV key exchange. Process: */
/* a) Convert xQ to an integer xqi using the convention specified in Appendix C.3. */
@ -175,7 +175,7 @@ C_2_2_MQV(
CURVE_FREE(E);
return retVal;
}
#endif // TPM_ALG_ECMQV
#endif // ALG_ECMQV
/* 10.2.11.1.3 C_2_2_ECDH() */
/* This function performs the two phase key exchange defined in SP800-56A, 6.1.1.2 Full Unified
Model, C(2, 2, ECC CDH). */
@ -252,12 +252,12 @@ CryptEcc2PhaseKeyExchange(
case TPM_ALG_ECDH:
return C_2_2_ECDH(outZ1, outZ2, curveId, dsA, deA, QsB, QeB);
break;
#ifdef TPM_ALG_ECMQV
#if ALG_ECMQV
case TPM_ALG_ECMQV:
return C_2_2_MQV(outZ1, curveId, dsA, deA, QsB, QeB);
break;
#endif
#ifdef TPM_ALG_SM2
#if ALG_SM2
case TPM_ALG_SM2:
return SM2KeyExchange(outZ1, curveId, dsA, deA, QsB, QeB);
break;
@ -266,7 +266,7 @@ CryptEcc2PhaseKeyExchange(
return TPM_RC_SCHEME;
}
}
#ifdef TPM_ALG_SM2
#if ALG_SM2
/* 10.2.11.1.5 ComputeWForSM2() */
/* Compute the value for w used by SM2 */
static UINT32
@ -371,4 +371,4 @@ SM2KeyExchange(
return retVal;
}
#endif
#endif //% CC_ZGen_2Phase
#endif // CC_ZGen_2Phase

2
src/tpm2/crypto/openssl/CryptEccMain.c
View File

@ -62,7 +62,7 @@
/* 10.2.12 CryptEccMain.c */
/* 10.2.12.1 Includes and Defines */
#include "Tpm.h"
#ifdef TPM_ALG_ECC
#if ALG_ECC
/* This version requires that the new format for ECC data be used */
#if !USE_BN_ECC_DATA
#error "Need to define USE_BN_ECC_DATA in Implementaion.h"

4
src/tpm2/crypto/openssl/CryptEccSignature.c
View File

@ -3,7 +3,7 @@
/* ECC Signatures */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: CryptEccSignature.c 1259 2018-07-10 19:11:09Z kgoldman $ */
/* $Id: CryptEccSignature.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -63,7 +63,7 @@
/* 10.2.13.1 Includes and Defines */
#include "Tpm.h"
#include "CryptEccSignature_fp.h"
#ifdef TPM_ALG_ECC
#if ALG_ECC
/* 10.2.13.2 Utility Functions */
/* 10.2.13.2.1 EcdsaDigest() */
/* Function to adjust the digest so that it is no larger than the order of the curve. This is used

28
src/tpm2/crypto/openssl/CryptHash.c
View File

@ -3,7 +3,7 @@
/* Implementation of cryptographic functions for hashing. */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: CryptHash.c 1259 2018-07-10 19:11:09Z kgoldman $ */
/* $Id: CryptHash.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -67,16 +67,16 @@
#include "Tpm.h"
#define HASH_TABLE_SIZE (HASH_COUNT + 1)
extern const HASH_INFO g_hashData[HASH_COUNT + 1];
#ifdef TPM_ALG_SHA1
#if ALG_SHA1
HASH_DEF_TEMPLATE(SHA1);
#endif
#ifdef TPM_ALG_SHA256
#if ALG_SHA256
HASH_DEF_TEMPLATE(SHA256);
#endif
#ifdef TPM_ALG_SHA384
#if ALG_SHA384
HASH_DEF_TEMPLATE(SHA384);
#endif
#ifdef TPM_ALG_SHA512
#if ALG_SHA512
HASH_DEF_TEMPLATE(SHA512);
#endif
HASH_DEF nullDef = {{0}};
@ -115,22 +115,22 @@ CryptGetHashDef(
PHASH_DEF retVal;
switch(hashAlg)
{
#ifdef TPM_ALG_SHA1
#if ALG_SHA1
case TPM_ALG_SHA1:
return &SHA1_Def;
break;
#endif
#ifdef TPM_ALG_SHA256
#if ALG_SHA256
case TPM_ALG_SHA256:
retVal = &SHA256_Def;
break;
#endif
#ifdef TPM_ALG_SHA384
#if ALG_SHA384
case TPM_ALG_SHA384:
retVal = &SHA384_Def;
break;
#endif
#ifdef TPM_ALG_SHA512
#if ALG_SHA512
case TPM_ALG_SHA512:
retVal = &SHA512_Def;
break;
@ -155,19 +155,19 @@ CryptHashIsValidAlg(
{
switch(hashAlg)
{
#ifdef TPM_ALG_SHA1
#if ALG_SHA1
case TPM_ALG_SHA1:
#endif
#ifdef TPM_ALG_SHA256
#if ALG_SHA256
case TPM_ALG_SHA256:
#endif
#ifdef TPM_ALG_SHA384
#if ALG_SHA384
case TPM_ALG_SHA384:
#endif
#ifdef TPM_ALG_SHA512
#if ALG_SHA512
case TPM_ALG_SHA512:
#endif
#ifdef TPM_ALG_SM3_256
#if ALG_SM3_256
case TPM_ALG_SM3_256:
#endif
return TRUE;

12
src/tpm2/crypto/openssl/CryptHashData.c
View File

@ -3,7 +3,7 @@
/* */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: CryptHashData.c 901 2017-01-08 04:14:48Z kgoldman $ */
/* $Id: CryptHashData.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -62,23 +62,23 @@
/* 10.2.15 CryptHashData.c */
#include "Tpm.h"
const HASH_INFO g_hashData[HASH_COUNT + 1] = {
#ifdef TPM_ALG_SHA1
#if ALG_SHA1
{TPM_ALG_SHA1, SHA1_DIGEST_SIZE, SHA1_BLOCK_SIZE,
SHA1_DER_SIZE, {SHA1_DER}},
#endif
#ifdef TPM_ALG_SHA256
#if ALG_SHA256
{TPM_ALG_SHA256, SHA256_DIGEST_SIZE, SHA256_BLOCK_SIZE,
SHA256_DER_SIZE, {SHA256_DER}},
#endif
#ifdef TPM_ALG_SHA384
#if ALG_SHA384
{TPM_ALG_SHA384, SHA384_DIGEST_SIZE, SHA384_BLOCK_SIZE,
SHA384_DER_SIZE, {SHA384_DER}},
#endif
#ifdef TPM_ALG_SHA512
#if ALG_SHA512
{TPM_ALG_SHA512, SHA512_DIGEST_SIZE, SHA512_BLOCK_SIZE,
SHA512_DER_SIZE, {SHA512_DER}},
#endif
#ifdef TPM_ALG_SM3_256
#if ALG_SM3_256
{TPM_ALG_SM3_256, SM3_256_DIGEST_SIZE, SM3_256_BLOCK_SIZE,
SM3_256_DER_SIZE, {SM3_256_DER}},
#endif

8
src/tpm2/crypto/openssl/CryptPrime.c
View File

@ -3,7 +3,7 @@
/* Code for prime validation. */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: CryptPrime.c 953 2017-03-06 20:31:40Z kgoldman $ */
/* $Id: CryptPrime.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -55,7 +55,7 @@
/* arising in any way out of use or reliance upon this specification or any */
/* information herein. */
/* */
/* (c) Copyright IBM Corp. and others, 2016, 2017 */
/* (c) Copyright IBM Corp. and others, 2016 - 2018 */
/* */
/********************************************************************************/
@ -256,7 +256,7 @@ MillerRabin(
end:
return ret;
}
#ifdef TPM_ALG_RSA //%
#if ALG_RSA
/* 10.2.16.1.6 RsaCheckPrime() */
/* This will check to see if a number is prime and appropriate for an RSA prime. */
/* This has different functionality based on whether we are using key sieving or not. If not, the
@ -340,4 +340,4 @@ BnGeneratePrimeForRSA(
found = RsaCheckPrime(prime, exponent, rand) == TPM_RC_SUCCESS;
}
}
#endif //% TPM_ALG_RSA
#endif // TPM_ALG_RSA

6
src/tpm2/crypto/openssl/CryptPrimeSieve.c
View File

@ -1,9 +1,9 @@
/********************************************************************************/
/* */
/* */
/* CryptPrimeSieve */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: CryptPrimeSieve.c 809 2016-11-16 18:31:54Z kgoldman $ */
/* $Id: CryptPrimeSieve.c 1259 2018-07-10 19:11:09Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -55,7 +55,7 @@
/* arising in any way out of use or reliance upon this specification or any */
/* information herein. */
/* */
/* (c) Copyright IBM Corp. and others, 2016 */
/* (c) Copyright IBM Corp. and others, 2016 - 2018 */
/* */
/********************************************************************************/

4
src/tpm2/crypto/openssl/CryptRsa.c
View File

@ -3,7 +3,7 @@
/* Implementation of cryptographic primitives for RSA */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: CryptRsa.c 1259 2018-07-10 19:11:09Z kgoldman $ */
/* $Id: CryptRsa.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -67,7 +67,7 @@
/* Need this define to get the private defines for this function */
#define CRYPT_RSA_C
#include "Tpm.h"
#ifdef TPM_ALG_RSA
#if ALG_RSA
/* 10.2.19.3 Obligatory Initialization Functions */
/* 10.2.19.3.1 CryptRsaInit() */
/* Function called at _TPM_Init(). */

4
src/tpm2/crypto/openssl/CryptSmac.c
View File

@ -3,7 +3,7 @@
/* Message Authentication Codes Based on a Symmetric Block Cipher */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: CryptSmac.c 1259 2018-07-10 19:11:09Z kgoldman $ */
/* $Id: CryptSmac.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -86,7 +86,7 @@ CryptSmacStart(
{
switch(macAlg)
{
#ifdef TPM_ALG_CMAC
#if ALG_CMAC
case TPM_ALG_CMAC:
retVal = CryptCmacStart(&state->state.smac, keyParameters,
macAlg, key);

32
src/tpm2/crypto/openssl/CryptSym.c
View File

@ -3,7 +3,7 @@
/* Symmetric block cipher modes */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: CryptSym.c 1047 2017-07-20 18:27:34Z kgoldman $ */
/* $Id: CryptSym.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -55,7 +55,7 @@
/* arising in any way out of use or reliance upon this specification or any */
/* information herein. */
/* */
/* (c) Copyright IBM Corp. and others, 2016, 2017 */
/* (c) Copyright IBM Corp. and others, 2016 - 2018 */
/* */
/********************************************************************************/
@ -99,7 +99,7 @@ CryptGetSymmetricBlockSize(
{
switch(symmetricAlg)
{
#ifdef TPM_ALG_AES
#if ALG_AES
case TPM_ALG_AES:
switch(keySizeInBits)
{
@ -114,7 +114,7 @@ CryptGetSymmetricBlockSize(
}
break;
#endif
#ifdef TPM_ALG_SM4
#if ALG_SM4
case TPM_ALG_SM4:
switch(keySizeInBits)
{
@ -124,7 +124,7 @@ CryptGetSymmetricBlockSize(
break;
}
#endif
#ifdef TPM_ALG_CAMELLIA
#if ALG_CAMELLIA
case TPM_ALG_CAMELLIA:
switch(keySizeInBits)
{
@ -138,7 +138,7 @@ CryptGetSymmetricBlockSize(
break;
}
#endif
#ifdef TPM_ALG_TDES
#if ALG_TDES
case TPM_ALG_TDES:
switch(keySizeInBits)
{
@ -207,7 +207,7 @@ CryptSymmetricEncrypt(
SELECT(ENCRYPT);
switch(mode)
{
#ifdef TPM_ALG_CTR
#if ALG_CTR
case TPM_ALG_CTR:
for(; dSize > 0; dSize -= blockSize)
{
@ -224,7 +224,7 @@ CryptSymmetricEncrypt(
}
break;
#endif
#ifdef TPM_ALG_OFB
#if ALG_OFB
case TPM_ALG_OFB:
// This is written so that dIn and dOut may be the same
for(; dSize > 0; dSize -= blockSize)
@ -238,7 +238,7 @@ CryptSymmetricEncrypt(
}
break;
#endif
#ifdef TPM_ALG_CBC
#if ALG_CBC
case TPM_ALG_CBC:
// For CBC the data size must be an even multiple of the
// cipher block size
@ -278,7 +278,7 @@ CryptSymmetricEncrypt(
for(; dSize < 0; dSize++)
*pIv++ = 0;
break;
#ifdef TPM_ALG_ECB
#if ALG_ECB
case TPM_ALG_ECB:
// For ECB the data size must be an even multiple of the
// cipher block size
@ -357,7 +357,7 @@ CryptSymmetricDecrypt(
// the decryption or encryption schedule.
switch(mode)
{
#if defined TPM_ALG_CBC || defined TPM_ALG_ECB
#if ALG_CBC || ALG_ECB
case ALG_CBC_VALUE: // decrypt = decrypt
case ALG_ECB_VALUE:
// For ECB and CBC, the data size must be an even multiple of the
@ -375,7 +375,7 @@ CryptSymmetricDecrypt(
// Now do the mode-dependent decryption
switch(mode)
{
#ifdef TPM_ALG_CBC
#if ALG_CBC
case TPM_ALG_CBC:
// Copy the input data to a temp buffer, decrypt the buffer into the
// output, XOR in the IV, and copy the temp buffer to the IV and repeat.
@ -414,7 +414,7 @@ CryptSymmetricDecrypt(
for(; dSize < 0; dSize++)
*pIv++ = 0;
break;
#ifdef TPM_ALG_CTR
#if ALG_CTR
case TPM_ALG_CTR:
for(; dSize > 0; dSize -= blockSize)
{
@ -431,7 +431,7 @@ CryptSymmetricDecrypt(
}
break;
#endif
#ifdef TPM_ALG_ECB
#if ALG_ECB
case TPM_ALG_ECB:
for(; dSize > 0; dSize -= blockSize)
{
@ -441,7 +441,7 @@ CryptSymmetricDecrypt(
}
break;
#endif
#ifdef TPM_ALG_OFB
#if ALG_OFB
case TPM_ALG_OFB:
// This is written so that dIn and dOut may be the same
for(; dSize > 0; dSize -= blockSize)
@ -473,7 +473,7 @@ CryptSymKeyValidate(
{
if(key->t.size != BITS_TO_BYTES(symDef->keyBits.sym))
return TPM_RCS_KEY_SIZE;
#ifdef TPM_ALG_TDES
#if ALG_TDES
if(symDef->algorithm == TPM_ALG_TDES && !CryptDesValidateKey(key))
return TPM_RCS_KEY;
#endif // TPM_ALG_TDES

4
src/tpm2/crypto/openssl/TpmToOsslHash.h
View File

@ -3,7 +3,7 @@
/* Used to splice the OpenSSL() hash code into the TPM code */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: TpmToOsslHash.h 1259 2018-07-10 19:11:09Z kgoldman $ */
/* $Id: TpmToOsslHash.h 1265 2018-07-15 18:29:22Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -80,7 +80,7 @@
#define tpmHashStateSHA256_t SHA256_CTX
#define tpmHashStateSHA384_t SHA512_CTX
#define tpmHashStateSHA512_t SHA512_CTX
#ifdef TPM_ALG_SM3
#if ALG_SM3
# error "The version of OpenSSL used by this code does not support SM3"
#endif
/* The defines below are only needed when compiling CryptHash.c or CryptSmac.c. This isolation

8
src/tpm2/crypto/openssl/TpmToOsslMath.c
View File

@ -1,9 +1,9 @@
/********************************************************************************/
/* */
/* */
/* TPM to OpenSSL BigNum Shim Layer */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: TpmToOsslMath.c 1047 2017-07-20 18:27:34Z kgoldman $ */
/* $Id: TpmToOsslMath.c 1262 2018-07-11 21:03:43Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -340,7 +340,7 @@ BnDiv(
OSSL_LEAVE();
return OK;
}
#ifdef TPM_ALG_RSA
#if ALG_RSA
/* B.2.3.2.3.5. BnGcd() */
/* Get the greatest common divisor of two numbers */
LIB_EXPORT BOOL
@ -427,7 +427,7 @@ BnModInverse(
return OK;
}
#endif // TPM_ALG_RSA
#ifdef TPM_ALG_ECC
#if ALG_ECC
/* B.2.3.2.3.8. PointFromOssl() */
/* Function to copy the point result from an OSSL function to a bigNum */
static BOOL

2
src/tpm2/crypto/openssl/TpmToOsslMath_fp.h
View File

@ -3,7 +3,7 @@
/* */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: TpmToOsslMath_fp.h 809 2016-11-16 18:31:54Z kgoldman $ */
/* $Id: TpmToOsslMath_fp.h 1108 2017-12-12 19:07:15Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */

8
src/tpm2/crypto/openssl/TpmToOsslSym.h
View File

@ -3,7 +3,7 @@
/* Splice the OpenSSL() library into the TPM code. */
/* Written by Ken Goldman */
/* IBM Thomas J. Watson Research Center */
/* $Id: TpmToOsslSym.h 1047 2017-07-20 18:27:34Z kgoldman $ */
/* $Id: TpmToOsslSym.h 1265 2018-07-15 18:29:22Z kgoldman $ */
/* */
/* Licenses and Notices */
/* */
@ -75,10 +75,10 @@
#include <openssl/bn.h>
#include <openssl/ossl_typ.h>
/* B.2.2.3.2. Links to the OpenSSL AES code */
#ifdef TPM_ALG_SM4
#if ALG_SM4
#error "SM4 is not available"
#endif
#ifdef TPM_ALG_CAMELLIA
#if ALG_CAMELLIA
#error "Camellia is not available"
#endif
/* Define the order of parameters to the library functions that do block encryption and
@ -117,7 +117,7 @@ typedef void(*TpmCryptSetSymKeyCall_t)(
#define TpmCryptDecryptTDES TDES_decrypt
#define tpmKeyScheduleTDES DES_key_schedule
typedef union tpmCryptKeySchedule_t tpmCryptKeySchedule_t;
#ifdef TPM_ALG_TDES
#if ALG_TDES
#include "TpmToOsslDesSupport_fp.h"
#endif
/* This definition would change if there were something to report */