// This file was extracted from the TCG Published
// Trusted Platform Module Library
// Part 4: Supporting Routines
// Family "2.0"
// Level 00 Revision 01.16
// October 30, 2014
#include "Global.h"
#include "CryptoEngine.h"
#include "InternalRoutines.h"
#include "AlgorithmCap_fp.h"
//
//
// 10.4.2 Functions
//
// 10.4.2.1 RunSelfTest()
//
// Local function to run self-test
//
static TPM_RC
CryptRunSelfTests(
ALGORITHM_VECTOR *toTest // IN: the vector of the algorithms to test
)
{
TPM_ALG_ID alg;
// For each of the algorithms that are in the toTestVecor, need to run a
// test
for(alg = TPM_ALG_FIRST; alg <= TPM_ALG_LAST; alg++)
{
if(TEST_BIT(alg, *toTest))
{
TPM_RC result = CryptTestAlgorithm(alg, toTest);
if(result != TPM_RC_SUCCESS)
return result;
}
}
return TPM_RC_SUCCESS;
}
//
//
// 10.4.2.2 CryptSelfTest()
//
// This function is called to start/complete a full self-test. If fullTest is NO, then only the untested algorithms
// will be run. If fullTest is YES, then g_untestedDecryptionAlgorithms is reinitialized and then all tests are
// run. This implementation of the reference design does not support processing outside the framework of a
// TPM command. As a consequence, this command does not complete until all tests are done. Since this
// can take a long time, the TPM will check after each test to see if the command is canceled. If so, then the
// TPM will returned TPM_RC_CANCELLED. To continue with the self-tests, call TPM2_SelfTest(fullTest ==
// No) and the TPM will complete the testing.
//
// Error Returns Meaning
//
// TPM_RC_CANCELED if the command is canceled
//
LIB_EXPORT
TPM_RC
CryptSelfTest(
TPMI_YES_NO fullTest // IN: if full test is required
)
{
if(g_forceFailureMode)
FAIL(FATAL_ERROR_FORCED);
// If the caller requested a full test, then reset the to test vector so that
// all the tests will be run
if(fullTest == YES)
{
MemoryCopy(g_toTest,
g_implementedAlgorithms,
sizeof(g_toTest), sizeof(g_toTest));
}
return CryptRunSelfTests(&g_toTest);
}
//
//
// 10.4.2.3 CryptIncrementalSelfTest()
//
// This function is used to perform an incremental self-test. This implementation will perform the toTest
// values before returning. That is, it assumes that the TPM cannot perform background tasks between
// commands.
// This command may be canceled. If it is, then there is no return result. However, this command can be run
// again and the incremental progress will not be lost.
//
// Error Returns Meaning
//
// TPM_RC_CANCELED processing of this command was canceled
// TPM_RC_TESTING if toTest list is not empty
// TPM_RC_VALUE an algorithm in the toTest list is not implemented
//
TPM_RC
CryptIncrementalSelfTest(
TPML_ALG *toTest, // IN: list of algorithms to be tested
TPML_ALG *toDoList // OUT: list of algorithms needing test
)
{
ALGORITHM_VECTOR toTestVector = {0};
TPM_ALG_ID alg;
UINT32 i;
pAssert(toTest != NULL && toDoList != NULL);
if(toTest->count > 0)
{
// Transcribe the toTest list into the toTestVector
for(i = 0; i < toTest->count; i++)
{
TPM_ALG_ID alg = toTest->algorithms[i];
// make sure that the algorithm value is not out of range
if((alg > TPM_ALG_LAST) || !TEST_BIT(alg, g_implementedAlgorithms))
return TPM_RC_VALUE;
SET_BIT(alg, toTestVector);
}
// Run the test
if(CryptRunSelfTests(&toTestVector) == TPM_RC_CANCELED)
return TPM_RC_CANCELED;
}
// Fill in the toDoList with the algorithms that are still untested
toDoList->count = 0;
for(alg = TPM_ALG_FIRST;
toDoList->count < MAX_ALG_LIST_SIZE && alg <= TPM_ALG_LAST;
alg++)
{
if(TEST_BIT(alg, g_toTest))
toDoList->algorithms[toDoList->count++] = alg;
}
return TPM_RC_SUCCESS;
//
}
//
//
// 10.4.2.4 CryptInitializeToTest()
//
// This function will initialize the data structures for testing all the algorithms. This should not be called
// unless CryptAlgsSetImplemented() has been called
//
void
CryptInitializeToTest(
void
)
{
MemoryCopy(g_toTest,
g_implementedAlgorithms,
sizeof(g_toTest),
sizeof(g_toTest));
// Setting the algorithm to null causes the test function to just clear
// out any algorithms for which there is no test.
CryptTestAlgorithm(TPM_ALG_ERROR, &g_toTest);
return;
}
//
//
// 10.4.2.5 CryptTestAlgorithm()
//
// Only point of contact with the actual self tests. If a self-test fails, there is no return and the TPM goes into
// failure mode. The call to TestAlgorithm() uses an algorithms selector and a bit vector. When the test is
// run, the corresponding bit in toTest and in g_toTest is CLEAR. If toTest is NULL, then only the bit in
// g_toTest is CLEAR. There is a special case for the call to TestAlgorithm(). When alg is
// TPM_ALG_ERROR, TestAlgorithm() will CLEAR any bit in toTest for which it has no test. This allows the
// knowledge about which algorithms have test to be accessed through the interface that provides the test.
//
// Error Returns Meaning
//
// TPM_RC_SUCCESS test complete
// TPM_RC_CANCELED test was canceled
//
LIB_EXPORT
TPM_RC
CryptTestAlgorithm(
TPM_ALG_ID alg,
ALGORITHM_VECTOR *toTest
)
{
TPM_RC result = TPM_RC_SUCCESS;
#ifdef SELF_TEST
// This is the function prototype for TestAlgorithms(). It is here and not
// in a _fp.h file to avoid a compiler error when SELF_TEST is not defined and
// AlgorithmTexts.c is not part of the build.
TPM_RC TestAlgorithm(TPM_ALG_ID alg, ALGORITHM_VECTOR *toTest);
result = TestAlgorithm(alg, toTest);
#else
// If this is an attempt to determine the algorithms for which there is a
// self test, pretend that all of them do. We do that by not clearing any
// of the algorithm bits. When/if this function is called to run tests, it
// will over report. This can be changed so that any call to check on which
// algorithms have tests, 'toTest' can be cleared.
if(alg != TPM_ALG_ERROR)
{
CLEAR_BIT(alg, g_toTest);
if(toTest != NULL)
CLEAR_BIT(alg, *toTest);
}
#endif
return result;
}