| // 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; |
| } |
