| // 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 |
| |
| #define TPM_FAIL_C |
| #include "InternalRoutines.h" |
| #include <assert.h> |
| // |
| // On MS C compiler, can save the alignment state and set the alignment to 1 for the duration of the |
| // TPM_Types.h include. This will avoid a lot of alignment warnings from the compiler for the unaligned |
| // structures. The alignment of the structures is not important as this function does not use any of the |
| // structures in TPM_Types.h and only include it for the #defines of the capabilities, properties, and |
| // command code values. |
| // |
| #pragma pack(push, 1) |
| #include "TPM_Types.h" |
| #pragma pack (pop) |
| #include "swap.h" |
| // |
| // |
| // Typedefs |
| // |
| // These defines are used primarily for sizing of the local response buffer. |
| // |
| #pragma pack(push,1) |
| typedef struct { |
| TPM_ST tag; |
| UINT32 size; |
| TPM_RC code; |
| } HEADER; |
| typedef struct { |
| UINT16 size; |
| struct { |
| UINT32 function; |
| UINT32 line; |
| UINT32 code; |
| } values; |
| TPM_RC returnCode; |
| } GET_TEST_RESULT_PARAMETERS; |
| typedef struct { |
| TPMI_YES_NO moreData; |
| TPM_CAP capability; // Always TPM_CAP_TPM_PROPERTIES |
| TPML_TAGGED_TPM_PROPERTY tpmProperty; // a single tagged property |
| } GET_CAPABILITY_PARAMETERS; |
| typedef struct { |
| HEADER header; |
| GET_TEST_RESULT_PARAMETERS getTestResult; |
| } TEST_RESPONSE; |
| typedef struct { |
| HEADER header; |
| GET_CAPABILITY_PARAMETERS getCap; |
| } CAPABILITY_RESPONSE; |
| typedef union { |
| TEST_RESPONSE test; |
| CAPABILITY_RESPONSE cap; |
| } RESPONSES; |
| #pragma pack(pop) |
| // |
| // Buffer to hold the responses. This may be a little larger than required due to padding that a compiler |
| // might add. |
| // |
| // NOTE: This is not in Global.c because of the specialized data definitions above. Since the data contained in this |
| // structure is not relevant outside of the execution of a single command (when the TPM is in failure mode. There |
| // is no compelling reason to move all the typedefs to Global.h and this structure to Global.c. |
| // |
| #ifndef __IGNORE_STATE__ // Don't define this value |
| static BYTE response[sizeof(RESPONSES)]; |
| #endif |
| // |
| // |
| // Local Functions |
| // |
| // MarshalUint16() |
| // |
| // Function to marshal a 16 bit value to the output buffer. |
| // |
| static INT32 |
| MarshalUint16( |
| UINT16 integer, |
| BYTE **buffer, |
| INT32 *size |
| ) |
| { |
| return UINT16_Marshal(&integer, buffer, size); |
| } |
| // |
| // |
| // MarshalUint32() |
| // |
| // Function to marshal a 32 bit value to the output buffer. |
| static INT32 |
| MarshalUint32( |
| UINT32 integer, |
| BYTE **buffer, |
| INT32 *size |
| ) |
| { |
| return UINT32_Marshal(&integer, buffer, size); |
| } |
| // |
| // |
| // UnmarshalHeader() |
| // |
| // Funtion to unmarshal the 10-byte command header. |
| // |
| static BOOL |
| UnmarshalHeader( |
| HEADER *header, |
| BYTE **buffer, |
| INT32 *size |
| ) |
| { |
| UINT32 usize; |
| TPM_RC ucode; |
| if( UINT16_Unmarshal(&header->tag, buffer, size) != TPM_RC_SUCCESS |
| || UINT32_Unmarshal(&usize, buffer, size) != TPM_RC_SUCCESS |
| || UINT32_Unmarshal(&ucode, buffer, size) != TPM_RC_SUCCESS |
| ) |
| return FALSE; |
| header->size = usize; |
| header->code = ucode; |
| return TRUE; |
| } |
| // |
| // |
| // Public Functions |
| // |
| // SetForceFailureMode() |
| // |
| // This function is called by the simulator to enable failure mode testing. |
| // |
| LIB_EXPORT void |
| SetForceFailureMode( |
| void |
| ) |
| { |
| g_forceFailureMode = TRUE; |
| return; |
| } |
| |
| // |
| // |
| // TpmFail() |
| // |
| // This function is called by TPM.lib when a failure occurs. It will set up the failure values to be returned on |
| // TPM2_GetTestResult(). |
| // |
| void |
| TpmFail( |
| const char *function, |
| int line, int code |
| ) |
| { |
| // Save the values that indicate where the error occurred. |
| // On a 64-bit machine, this may truncate the address of the string |
| // of the function name where the error occurred. |
| memcpy(&s_failFunction, function, sizeof(s_failFunction)); |
| s_failLine = line; |
| s_failCode = code; |
| // if asserts are enabled, then do an assert unless the failure mode code |
| // is being tested |
| assert(g_forceFailureMode); |
| // Clear this flag |
| g_forceFailureMode = FALSE; |
| // Jump to the failure mode code. |
| // Note: only get here if asserts are off or if we are testing failure mode |
| #ifndef EMBEDDED_MODE |
| longjmp(&g_jumpBuffer[0], 1); |
| #endif |
| } |
| // |
| // |
| // TpmFailureMode |
| // |
| // This function is called by the interface code when the platform is in failure mode. |
| // |
| void |
| TpmFailureMode ( |
| unsigned int inRequestSize, // IN: command buffer size |
| unsigned char *inRequest, // IN: command buffer |
| unsigned int *outResponseSize, // OUT: response buffer size |
| unsigned char **outResponse // OUT: response buffer |
| ) |
| { |
| BYTE *buffer; |
| INT32 bufferSize; |
| UINT32 marshalSize; |
| UINT32 capability; |
| HEADER header; // unmarshaled command header |
| UINT32 pt; // unmarshaled property type |
| UINT32 count; // unmarshaled property count |
| // If there is no command buffer, then just return TPM_RC_FAILURE |
| if(inRequestSize == 0 || inRequest == NULL) |
| goto FailureModeReturn; |
| // If the header is not correct for TPM2_GetCapability() or |
| // TPM2_GetTestResult() then just return the in failure mode response; |
| buffer = inRequest; |
| if(!UnmarshalHeader(&header, &inRequest, (INT32 *)&inRequestSize)) |
| goto FailureModeReturn; |
| if( header.tag != TPM_ST_NO_SESSIONS |
| || header.size < 10) |
| goto FailureModeReturn; |
| switch (header.code) { |
| case TPM_CC_GetTestResult: |
| // make sure that the command size is correct |
| if(header.size != 10) |
| goto FailureModeReturn; |
| buffer = &response[10]; |
| bufferSize = MAX_RESPONSE_SIZE-10; |
| marshalSize = MarshalUint16(3 * sizeof(UINT32), &buffer, &bufferSize); |
| marshalSize += MarshalUint32(s_failFunction, &buffer, &bufferSize); |
| marshalSize += MarshalUint32(s_failLine, &buffer, &bufferSize); |
| marshalSize += MarshalUint32(s_failCode, &buffer, &bufferSize); |
| if(s_failCode == FATAL_ERROR_NV_UNRECOVERABLE) |
| marshalSize += MarshalUint32(TPM_RC_NV_UNINITIALIZED, &buffer, &bufferSize); |
| else |
| marshalSize += MarshalUint32(TPM_RC_FAILURE, &buffer, &bufferSize); |
| // |
| break; |
| case TPM_CC_GetCapability: |
| // make sure that the size of the command is exactly the size |
| // returned for the capability, property, and count |
| if( header.size!= (10 + (3 * sizeof(UINT32))) |
| // also verify that this is requesting TPM properties |
| || (UINT32_Unmarshal(&capability, &inRequest, |
| (INT32 *)&inRequestSize) |
| != TPM_RC_SUCCESS) |
| || (capability != TPM_CAP_TPM_PROPERTIES) |
| || (UINT32_Unmarshal(&pt, &inRequest, (INT32 *)&inRequestSize) |
| != TPM_RC_SUCCESS) |
| || (UINT32_Unmarshal(&count, &inRequest, (INT32 *)&inRequestSize) |
| != TPM_RC_SUCCESS) |
| ) |
| goto FailureModeReturn; |
| // If in failure mode because of an unrecoverable read error, and the |
| // property is 0 and the count is 0, then this is an indication to |
| // re-manufacture the TPM. Do the re-manufacture but stay in failure |
| // mode until the TPM is reset. |
| // Note: this behavior is not required by the specification and it is |
| // OK to leave the TPM permanently bricked due to an unrecoverable NV |
| // error. |
| if( count == 0 && pt == 0 && s_failCode == FATAL_ERROR_NV_UNRECOVERABLE) |
| { |
| g_manufactured = FALSE; |
| TPM_Manufacture(0); |
| } |
| if(count > 0) |
| count = 1; |
| else if(pt > TPM_PT_FIRMWARE_VERSION_2) |
| count = 0; |
| if(pt < TPM_PT_MANUFACTURER) |
| pt = TPM_PT_MANUFACTURER; |
| // set up for return |
| buffer = &response[10]; |
| bufferSize = MAX_RESPONSE_SIZE-10; |
| // if the request was for a PT less than the last one |
| // then we indicate more, otherwise, not. |
| if(pt < TPM_PT_FIRMWARE_VERSION_2) |
| *buffer++ = YES; |
| else |
| *buffer++ = NO; |
| marshalSize = 1; |
| // indicate the capability type |
| marshalSize += MarshalUint32(capability, &buffer, &bufferSize); |
| // indicate the number of values that are being returned (0 or 1) |
| marshalSize += MarshalUint32(count, &buffer, &bufferSize); |
| // indicate the property |
| marshalSize += MarshalUint32(pt, &buffer, &bufferSize); |
| if(count > 0) |
| switch (pt) { |
| case TPM_PT_MANUFACTURER: |
| // the vendor ID unique to each TPM manufacturer |
| #ifdef MANUFACTURER |
| pt = *(UINT32*)MANUFACTURER; |
| #else |
| pt = 0; |
| #endif |
| break; |
| case TPM_PT_VENDOR_STRING_1: |
| // the first four characters of the vendor ID string |
| #ifdef VENDOR_STRING_1 |
| pt = *(UINT32*)VENDOR_STRING_1; |
| #else |
| pt = 0; |
| #endif |
| break; |
| case TPM_PT_VENDOR_STRING_2: |
| // the second four characters of the vendor ID string |
| #ifdef VENDOR_STRING_2 |
| pt = *(UINT32*)VENDOR_STRING_2; |
| #else |
| pt = 0; |
| #endif |
| break; |
| case TPM_PT_VENDOR_STRING_3: |
| // the third four characters of the vendor ID string |
| #ifdef VENDOR_STRING_3 |
| pt = *(UINT32*)VENDOR_STRING_3; |
| #else |
| pt = 0; |
| #endif |
| break; |
| case TPM_PT_VENDOR_STRING_4: |
| // the fourth four characters of the vendor ID string |
| #ifdef VENDOR_STRING_4 |
| pt = *(UINT32*)VENDOR_STRING_4; |
| #else |
| pt = 0; |
| #endif |
| break; |
| case TPM_PT_VENDOR_TPM_TYPE: |
| // vendor-defined value indicating the TPM model |
| // We just make up a number here |
| pt = 1; |
| break; |
| case TPM_PT_FIRMWARE_VERSION_1: |
| // the more significant 32-bits of a vendor-specific value |
| // indicating the version of the firmware |
| #ifdef FIRMWARE_V1 |
| pt = FIRMWARE_V1; |
| #else |
| pt = 0; |
| #endif |
| break; |
| default: // TPM_PT_FIRMWARE_VERSION_2: |
| // the less significant 32-bits of a vendor-specific value |
| // indicating the version of the firmware |
| #ifdef FIRMWARE_V2 |
| pt = FIRMWARE_V2; |
| #else |
| pt = 0; |
| #endif |
| break; |
| } |
| marshalSize += MarshalUint32(pt, &buffer, &bufferSize); |
| break; |
| default: // default for switch (cc) |
| goto FailureModeReturn; |
| } |
| // Now do the header |
| buffer = response; |
| bufferSize = 10; |
| marshalSize = marshalSize + 10; // Add the header size to the |
| // stuff already marshaled |
| MarshalUint16(TPM_ST_NO_SESSIONS, &buffer, &bufferSize); // structure tag |
| MarshalUint32(marshalSize, &buffer, &bufferSize); // responseSize |
| MarshalUint32(TPM_RC_SUCCESS, &buffer, &bufferSize); // response code |
| *outResponseSize = marshalSize; |
| *outResponse = (unsigned char *)&response; |
| return; |
| FailureModeReturn: |
| buffer = response; |
| bufferSize = 10; |
| marshalSize = MarshalUint16(TPM_ST_NO_SESSIONS, &buffer, &bufferSize); |
| marshalSize += MarshalUint32(10, &buffer, &bufferSize); |
| marshalSize += MarshalUint32(TPM_RC_FAILURE, &buffer, &bufferSize); |
| *outResponseSize = marshalSize; |
| *outResponse = (unsigned char *)response; |
| return; |
| } |
