path: root/TpmFail.c

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