VirtualBox

Changeset 104923 in vbox for trunk/src/VBox/Devices/Trace


Ignore:
Timestamp:
Jun 14, 2024 3:15:25 PM (8 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
163525
Message:

Devices/Trace: Some more TPM trace decoding, bugref:10701

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Trace/VBoxTraceLogDecoders.cpp

    r104920 r104923  
    3434#include <iprt/errcore.h>
    3535#include <iprt/log.h>
    36 #include <iprt/message.h>
    3736#include <iprt/tracelog-decoder-plugin.h>
    3837
    … …  
    4544
    4645/**
    47  */
    48 typedef DECLCALLBACKTYPE(void, FNDECODETPM2CC, (PRTTRACELOGDECODERHLP pHlp, PCTPMREQHDR pHdr, size_t cb));
    49 /** Pointer to an event decode callback. */
    50 typedef FNDECODETPM2CC *PFNFNDECODETPM2CC;
     46 * Algorithm ID to string mapping.
     47 */
     48typedef struct TPMALGID2STR
     49{
     50    uint16_t    u16AlgId;
     51    const char *pszAlgId;
     52} TPMALGID2STR;
     53typedef const TPMALGID2STR *PCTPMALGID2STR;
     54
     55
     56/**
     57 * The TPM state.
     58 */
     59typedef struct TPMSTATE
     60{
     61    /** Command code. */
     62    uint32_t                            u32CmdCode;
     63    /** Command code dependent state. */
     64    union
     65    {
     66        /** TPM2_CC_GET_CAPABILITY related state. */
     67        struct
     68        {
     69            /** The capability group to query. */
     70            uint32_t                    u32Cap;
     71            /** Property to query. */
     72            uint32_t                    u32Property;
     73            /** Number of values to return. */
     74            uint32_t                    u32Count;
     75        } GetCapability;
     76        /** TPM2_GET_RANDOM related state. */
     77        struct
     78        {
     79            /** Number of bytes of random data to produce. */
     80            uint16_t                    cbRnd;
     81        } GetRandom;
     82    } u;
     83} TPMSTATE;
     84typedef TPMSTATE *PTPMSTATE;
     85
     86
     87/**
     88 */
     89typedef DECLCALLBACKTYPE(void, FNDECODETPM2CCREQ, (PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PCTPMREQHDR pHdr, size_t cb));
     90/** Pointer to an event decode request callback. */
     91typedef FNDECODETPM2CCREQ *PFNFNDECODETPM2CCREQ;
     92
     93
     94/**
     95 */
     96typedef DECLCALLBACKTYPE(void, FNDECODETPM2CCRESP, (PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PCTPMRESPHDR pHdr, size_t cb));
     97/** Pointer to an event decode request callback. */
     98typedef FNDECODETPM2CCRESP *PFNFNDECODETPM2CCRESP;
    5199
    52100
    … …  
    55103*********************************************************************************************************************************/
    56104
     105/**
     106 * Algorithm ID to string mapping array.
     107 */
     108static const TPMALGID2STR g_aAlgId2Str[] =
     109{
     110#define TPM_ALGID_2_STR(a_AlgId) { a_AlgId, #a_AlgId }
     111    TPM_ALGID_2_STR(TPM2_ALG_ERROR),
     112    TPM_ALGID_2_STR(TPM2_ALG_RSA),
     113    TPM_ALGID_2_STR(TPM2_ALG_TDES),
     114    TPM_ALGID_2_STR(TPM2_ALG_SHA1),
     115    TPM_ALGID_2_STR(TPM2_ALG_HMAC),
     116    TPM_ALGID_2_STR(TPM2_ALG_AES),
     117    TPM_ALGID_2_STR(TPM2_ALG_MGF1),
     118    TPM_ALGID_2_STR(TPM2_ALG_KEYEDHASH),
     119    TPM_ALGID_2_STR(TPM2_ALG_XOR),
     120    TPM_ALGID_2_STR(TPM2_ALG_SHA256),
     121    TPM_ALGID_2_STR(TPM2_ALG_SHA384),
     122    TPM_ALGID_2_STR(TPM2_ALG_SHA512),
     123    TPM_ALGID_2_STR(TPM2_ALG_SHA256_192),
     124    TPM_ALGID_2_STR(TPM2_ALG_NULL),
     125    TPM_ALGID_2_STR(TPM2_ALG_SM3_256),
     126    TPM_ALGID_2_STR(TPM2_ALG_SM4),
     127    TPM_ALGID_2_STR(TPM2_ALG_RSASSA),
     128    TPM_ALGID_2_STR(TPM2_ALG_RSAES),
     129    TPM_ALGID_2_STR(TPM2_ALG_RSAPSS),
     130    TPM_ALGID_2_STR(TPM2_ALG_OAEP),
     131    TPM_ALGID_2_STR(TPM2_ALG_ECDSA),
     132    TPM_ALGID_2_STR(TPM2_ALG_ECDH),
     133    TPM_ALGID_2_STR(TPM2_ALG_ECDAA),
     134    TPM_ALGID_2_STR(TPM2_ALG_SM2),
     135    TPM_ALGID_2_STR(TPM2_ALG_ECSCHNORR),
     136    TPM_ALGID_2_STR(TPM2_ALG_ECMQV),
     137    TPM_ALGID_2_STR(TPM2_ALG_KDF1_SP800_56A),
     138    TPM_ALGID_2_STR(TPM2_ALG_KDF2),
     139    TPM_ALGID_2_STR(TPM2_ALG_KDF1_SP800_108),
     140    TPM_ALGID_2_STR(TPM2_ALG_ECC),
     141    TPM_ALGID_2_STR(TPM2_ALG_SYMCIPHER),
     142    TPM_ALGID_2_STR(TPM2_ALG_CAMELLIA),
     143    TPM_ALGID_2_STR(TPM2_ALG_SHA3_256),
     144    TPM_ALGID_2_STR(TPM2_ALG_SHA3_384),
     145    TPM_ALGID_2_STR(TPM2_ALG_SHA3_512),
     146    TPM_ALGID_2_STR(TPM2_ALG_SHAKE128),
     147    TPM_ALGID_2_STR(TPM2_ALG_SHAKE256),
     148    TPM_ALGID_2_STR(TPM2_ALG_SHAKE256_192),
     149    TPM_ALGID_2_STR(TPM2_ALG_SHAKE256_256),
     150    TPM_ALGID_2_STR(TPM2_ALG_SHAKE256_512),
     151    TPM_ALGID_2_STR(TPM2_ALG_CMAC),
     152    TPM_ALGID_2_STR(TPM2_ALG_CTR),
     153    TPM_ALGID_2_STR(TPM2_ALG_OFB),
     154    TPM_ALGID_2_STR(TPM2_ALG_CBC),
     155    TPM_ALGID_2_STR(TPM2_ALG_CFB),
     156    TPM_ALGID_2_STR(TPM2_ALG_ECB),
     157    TPM_ALGID_2_STR(TPM2_ALG_CCM),
     158    TPM_ALGID_2_STR(TPM2_ALG_GCM),
     159    TPM_ALGID_2_STR(TPM2_ALG_KW),
     160    TPM_ALGID_2_STR(TPM2_ALG_KWP),
     161    TPM_ALGID_2_STR(TPM2_ALG_EAX),
     162    TPM_ALGID_2_STR(TPM2_ALG_EDDSA),
     163    TPM_ALGID_2_STR(TPM2_ALG_EDDSA_PH),
     164    TPM_ALGID_2_STR(TPM2_ALG_LMS),
     165    TPM_ALGID_2_STR(TPM2_ALG_XMSS),
     166    TPM_ALGID_2_STR(TPM2_ALG_KEYEDXOF),
     167    TPM_ALGID_2_STR(TPM2_ALG_KMACXOF128),
     168    TPM_ALGID_2_STR(TPM2_ALG_KMACXOF256),
     169    TPM_ALGID_2_STR(TPM2_ALG_KMAC128),
     170    TPM_ALGID_2_STR(TPM2_ALG_KMAC256)
     171#undef TPM_ALGID_2_STR
     172};
     173
    57174
    58175/*********************************************************************************************************************************
    … …  
    60177*********************************************************************************************************************************/
    61178
    62 static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeStartupShutdown(PRTTRACELOGDECODERHLP pHlp, PCTPMREQHDR pHdr, size_t cb)
    63 {
    64     if (cb >= sizeof(uint16_t))
    65     {
    66         uint16_t u16TpmSu = RT_BE2H_U16(*(const uint16_t *)(pHdr + 1));
    67         if (u16TpmSu == TPM2_SU_CLEAR)
    68             RTMsgInfo("        TPM2_SU_CLEAR\n");
    69         else if (u16TpmSu == TPM2_SU_STATE)
    70             RTMsgInfo("        TPM2_SU_STATE\n");
    71         else
    72             RTMsgInfo("        Unknown: %#x\n", u16TpmSu);
    73         return;
    74     }
    75 
    76     pHlp->pfnErrorMsg(pHlp, "Malformed TPM2_CC_STARTUP/TPM2_CC_SHUTDOWN command, not enough room for TPM_SU constant\n");
     179static const char *vboxTraceLogDecodeEvtTpmAlgId2Str(uint16_t u16AlgId)
     180{
     181    for (uint32_t i = 0; i < RT_ELEMENTS(g_aAlgId2Str); i++)
     182        if (g_aAlgId2Str[i].u16AlgId == u16AlgId)
     183            return g_aAlgId2Str[i].pszAlgId;
     184
     185    return "<UNKNOWN>";
     186}
     187
     188
     189static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeStartupShutdownReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PCTPMREQHDR pHdr, size_t cb)
     190{
     191    RT_NOREF(pThis, cb);
     192
     193    uint16_t u16TpmSu = RT_BE2H_U16(*(const uint16_t *)(pHdr + 1));
     194    if (u16TpmSu == TPM2_SU_CLEAR)
     195        pHlp->pfnPrintf(pHlp, "        TPM2_SU_CLEAR\n");
     196    else if (u16TpmSu == TPM2_SU_STATE)
     197        pHlp->pfnPrintf(pHlp, "        TPM2_SU_STATE\n");
     198    else
     199        pHlp->pfnPrintf(pHlp, "        Unknown: %#x\n", u16TpmSu);
    77200}
    78201
    … …  
    97220};
    98221
    99 static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeGetCapability(PRTTRACELOGDECODERHLP pHlp, PCTPMREQHDR pHdr, size_t cb)
    100 {
    101     if (cb >= sizeof(TPM2REQGETCAPABILITY))
    102     {
    103         PCTPM2REQGETCAPABILITY pReq = (PCTPM2REQGETCAPABILITY)pHdr;
    104         uint32_t u32Cap      = RT_BE2H_U32(pReq->u32Cap);
    105         uint32_t u32Property = RT_BE2H_U32(pReq->u32Property);
    106         uint32_t u32Count    = RT_BE2H_U32(pReq->u32Count);
    107         if (u32Cap < RT_ELEMENTS(s_aTpm2Caps))
    108             RTMsgInfo("        u32Cap:      %s\n"
    109                       "        u32Property: %#x\n"
    110                       "        u32Count:    %#x\n",
    111                       s_aTpm2Caps[u32Cap], u32Property, u32Count);
    112         else
    113             RTMsgInfo("        u32Cap:      %#x (UNKNOWN)\n"
    114                       "        u32Property: %#x\n"
    115                       "        u32Count:    %#x\n",
    116                       u32Cap, u32Property, u32Count);
    117         return;
     222static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeGetCapabilityReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PCTPMREQHDR pHdr, size_t cb)
     223{
     224    RT_NOREF(cb);
     225
     226    PCTPM2REQGETCAPABILITY pReq = (PCTPM2REQGETCAPABILITY)pHdr;
     227    uint32_t u32Cap      = RT_BE2H_U32(pReq->u32Cap);
     228    uint32_t u32Property = RT_BE2H_U32(pReq->u32Property);
     229    uint32_t u32Count    = RT_BE2H_U32(pReq->u32Count);
     230
     231    pThis->u.GetCapability.u32Cap      = u32Cap;
     232    pThis->u.GetCapability.u32Property = u32Property;
     233    pThis->u.GetCapability.u32Count    = u32Count;
     234
     235    if (u32Cap < RT_ELEMENTS(s_aTpm2Caps))
     236        pHlp->pfnPrintf(pHlp, "        u32Cap:      %s\n"
     237                              "        u32Property: %#x\n"
     238                              "        u32Count:    %#x\n",
     239                        s_aTpm2Caps[u32Cap], u32Property, u32Count);
     240    else
     241        pHlp->pfnPrintf(pHlp, "        u32Cap:      %#x (UNKNOWN)\n"
     242                              "        u32Property: %#x\n"
     243                              "        u32Count:    %#x\n",
     244                        u32Cap, u32Property, u32Count);
     245}
     246
     247
     248static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeGetCapabilityResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PCTPMRESPHDR pHdr, size_t cb)
     249{
     250    RT_NOREF(pThis, cb);
     251
     252    PCTPM2RESPGETCAPABILITY pResp  = (PCTPM2RESPGETCAPABILITY)pHdr;
     253    TPMCAP                  u32Cap = RT_BE2H_U32(pResp->u32Cap);
     254    pHlp->pfnPrintf(pHlp, "        fMoreData: %RTbool\n", pResp->fMoreData);
     255    if (u32Cap < RT_ELEMENTS(s_aTpm2Caps))
     256    {
     257        pHlp->pfnPrintf(pHlp, "        u32Cap:    %s\n", s_aTpm2Caps[u32Cap]);
     258        switch (u32Cap)
     259        {
     260            case TPM2_CAP_PCRS:
     261            {
     262                uint32_t u32Count = RT_BE2H_U32(*(uint32_t *)&pResp->abCap[0]);
     263                pHlp->pfnPrintf(pHlp, "        u32Count:  %u\n", u32Count);
     264
     265                /* Walk the list of PCR selection entries. */
     266                const uint8_t *pbPcrSelection = &pResp->abCap[sizeof(u32Count)];
     267                for (uint32_t i = 0; i < u32Count; i++)
     268                {
     269                    uint16_t u16AlgId       = RT_BE2H_U16(*(const uint16_t *)pbPcrSelection);
     270                    uint8_t  cbPcrSelection = *(pbPcrSelection + 2);
     271                    const char *pszAlgId = vboxTraceLogDecodeEvtTpmAlgId2Str(u16AlgId);
     272
     273                    pbPcrSelection += 3;
     274                    pHlp->pfnPrintf(pHlp, "            u16AlgId:      %s\n", pszAlgId);
     275                    pHlp->pfnPrintf(pHlp, "            u8SizeOfSlect: %u\n", cbPcrSelection);
     276                    pHlp->pfnPrintf(pHlp, "            PCRs:          ");
     277                    for (uint8_t idxPcr = 0; idxPcr < cbPcrSelection * 8; idxPcr++)
     278                        if (RT_BOOL(*(pbPcrSelection + (idxPcr / 8)) & RT_BIT(idxPcr % 8)))
     279                            pHlp->pfnPrintf(pHlp, "%u ", idxPcr);
     280                    pbPcrSelection += cbPcrSelection;
     281                    pHlp->pfnPrintf(pHlp, "\n");
     282                }
     283                break;
     284            }
     285            default:
     286                pHlp->pfnPrintf(pHlp, "%.*Rhxd\n", cb - sizeof(TPMYESNO) - sizeof(TPMCAP), &pResp->abCap[0]);
     287                break;
     288        }
    118289    }
    119 
    120     pHlp->pfnErrorMsg(pHlp, "Malformed TPM2_CC_GET_CAPABILITY command, not enough room for the input\n");
    121 }
    122 
    123 
    124 static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeReadPublic(PRTTRACELOGDECODERHLP pHlp, PCTPMREQHDR pHdr, size_t cb)
    125 {
    126     if (cb >= sizeof(TPM2REQREADPUBLIC))
    127     {
    128         PCTPM2REQREADPUBLIC pReq = (PCTPM2REQREADPUBLIC)pHdr;
    129         TPMIDHOBJECT hObj = RT_BE2H_U32(pReq->hObj);
    130         RTMsgInfo("        hObj:      %#x\n", hObj);
    131         return;
     290    else
     291    {
     292        pHlp->pfnPrintf(pHlp, "        u32Cap:    %#x (UNKNOWN)\n", u32Cap);
     293        pHlp->pfnPrintf(pHlp, "%.*Rhxd\n", cb - sizeof(TPMYESNO) - sizeof(TPMCAP), &pResp->abCap[0]);
    132294    }
    133 
    134     pHlp->pfnErrorMsg(pHlp, "Malformed TPM2_CC_READ_PUBLIC command, not enough room for the input\n");
     295}
     296
     297
     298static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeReadPublicReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PCTPMREQHDR pHdr, size_t cb)
     299{
     300    RT_NOREF(pThis, cb);
     301
     302    PCTPM2REQREADPUBLIC pReq = (PCTPM2REQREADPUBLIC)pHdr;
     303    TPMIDHOBJECT hObj = RT_BE2H_U32(pReq->hObj);
     304    pHlp->pfnPrintf(pHlp, "        hObj:      %#x\n", hObj);
     305}
     306
     307
     308static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeGetRandomReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PCTPMREQHDR pHdr, size_t cb)
     309{
     310    RT_NOREF(pThis, cb);
     311
     312    PCTPM2REQGETRANDOM pReq = (PCTPM2REQGETRANDOM)pHdr;
     313    pThis->u.GetRandom.cbRnd = RT_BE2H_U16(pReq->u16RandomBytes);
     314    pHlp->pfnPrintf(pHlp, "        u16RandomBytes: %u\n", pThis->u.GetRandom.cbRnd);
     315}
     316
     317
     318static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeGetRandomResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PCTPMRESPHDR pHdr, size_t cb)
     319{
     320    RT_NOREF(pHlp, pThis, cb);
     321    PCTPM2RESPGETRANDOM pResp = (PCTPM2RESPGETRANDOM)pHdr;
     322    uint16_t cbBuf = RT_BE2H_U16(pResp->Buf.u16Size);
     323    if (pThis->u.GetRandom.cbRnd != cbBuf)
     324    {
     325        pHlp->pfnErrorMsg(pHlp, "Requested random data size doesn't match returned data size (requested %u, returned %u), using smaller value\n",
     326                          pThis->u.GetRandom.cbRnd, cbBuf);
     327        cbBuf = RT_MIN(cbBuf, pThis->u.GetRandom.cbRnd);
     328    }
     329
     330    /** @todo Validate against cb. */
     331
     332    pHlp->pfnPrintf(pHlp, "%.*Rhxd\n", cbBuf, pResp->Buf.abBuf);
    135333}
    136334
    … …  
    138336static struct
    139337{
    140     uint32_t          u32CmdCode;
    141     const char        *pszCmdCode;
    142     PFNFNDECODETPM2CC pfnDecode;
     338    uint32_t              u32CmdCode;
     339    const char            *pszCmdCode;
     340    uint32_t              cbReqMin;
     341    uint32_t              cbRespMin;
     342    PFNFNDECODETPM2CCREQ  pfnDecodeReq;
     343    PFNFNDECODETPM2CCRESP pfnDecodeResp;
    143344} s_aTpmCmdCodes[] =
    144345{
    145 #define TPM_CMD_CODE_INIT(a_CmdCode, a_Desc) { a_CmdCode, #a_CmdCode, a_Desc }
    146     TPM_CMD_CODE_INIT(TPM2_CC_NV_UNDEFINE_SPACE_SPECIAL,        NULL),
    147     TPM_CMD_CODE_INIT(TPM2_CC_EVICT_CONTROL,                    NULL),
    148     TPM_CMD_CODE_INIT(TPM2_CC_HIERARCHY_CONTROL,                NULL),
    149     TPM_CMD_CODE_INIT(TPM2_CC_NV_UNDEFINE_SPACE,                NULL),
    150     TPM_CMD_CODE_INIT(TPM2_CC_CHANGE_EPS,                       NULL),
    151     TPM_CMD_CODE_INIT(TPM2_CC_CHANGE_PPS,                       NULL),
    152     TPM_CMD_CODE_INIT(TPM2_CC_CLEAR,                            NULL),
    153     TPM_CMD_CODE_INIT(TPM2_CC_CLEAR_CONTROL,                    NULL),
    154     TPM_CMD_CODE_INIT(TPM2_CC_CLOCK_SET,                        NULL),
    155     TPM_CMD_CODE_INIT(TPM2_CC_HIERARCHY_CHANGE_AUTH,            NULL),
    156     TPM_CMD_CODE_INIT(TPM2_CC_NV_DEFINE_SPACE,                  NULL),
    157     TPM_CMD_CODE_INIT(TPM2_CC_PCR_ALLOCATE,                     NULL),
    158     TPM_CMD_CODE_INIT(TPM2_CC_PCR_SET_AUTH_POLICY,              NULL),
    159     TPM_CMD_CODE_INIT(TPM2_CC_PP_COMMANDS,                      NULL),
    160     TPM_CMD_CODE_INIT(TPM2_CC_SET_PRIMARY_POLICY,               NULL),
    161     TPM_CMD_CODE_INIT(TPM2_CC_FIELD_UPGRADE_START,              NULL),
    162     TPM_CMD_CODE_INIT(TPM2_CC_CLOCK_RATE_ADJUST,                NULL),
    163     TPM_CMD_CODE_INIT(TPM2_CC_CREATE_PRIMARY,                   NULL),
    164     TPM_CMD_CODE_INIT(TPM2_CC_NV_GLOBAL_WRITE_LOCK,             NULL),
    165     TPM_CMD_CODE_INIT(TPM2_CC_GET_COMMAND_AUDIT_DIGEST,         NULL),
    166     TPM_CMD_CODE_INIT(TPM2_CC_NV_INCREMENT,                     NULL),
    167     TPM_CMD_CODE_INIT(TPM2_CC_NV_SET_BITS,                      NULL),
    168     TPM_CMD_CODE_INIT(TPM2_CC_NV_EXTEND,                        NULL),
    169     TPM_CMD_CODE_INIT(TPM2_CC_NV_WRITE,                         NULL),
    170     TPM_CMD_CODE_INIT(TPM2_CC_NV_WRITE_LOCK,                    NULL),
    171     TPM_CMD_CODE_INIT(TPM2_CC_DICTIONARY_ATTACK_LOCK_RESET,     NULL),
    172     TPM_CMD_CODE_INIT(TPM2_CC_DICTIONARY_ATTACK_PARAMETERS,     NULL),
    173     TPM_CMD_CODE_INIT(TPM2_CC_NV_CHANGE_AUTH,                   NULL),
    174     TPM_CMD_CODE_INIT(TPM2_CC_PCR_EVENT,                        NULL),
    175     TPM_CMD_CODE_INIT(TPM2_CC_PCR_RESET,                        NULL),
    176     TPM_CMD_CODE_INIT(TPM2_CC_SEQUENCE_COMPLETE,                NULL),
    177     TPM_CMD_CODE_INIT(TPM2_CC_SET_ALGORITHM_SET,                NULL),
    178     TPM_CMD_CODE_INIT(TPM2_CC_SET_COMMAND_CODE_AUDIT_STATUS,    NULL),
    179     TPM_CMD_CODE_INIT(TPM2_CC_FIELD_UPGRADE_DATA,               NULL),
    180     TPM_CMD_CODE_INIT(TPM2_CC_INCREMENTAL_SELF_TEST,            NULL),
    181     TPM_CMD_CODE_INIT(TPM2_CC_SELF_TEST,                        NULL),
    182     TPM_CMD_CODE_INIT(TPM2_CC_STARTUP,                          vboxTraceLogDecodeEvtTpmDecodeStartupShutdown),
    183     TPM_CMD_CODE_INIT(TPM2_CC_SHUTDOWN,                         vboxTraceLogDecodeEvtTpmDecodeStartupShutdown),
    184     TPM_CMD_CODE_INIT(TPM2_CC_STIR_RANDOM,                      NULL),
    185     TPM_CMD_CODE_INIT(TPM2_CC_ACTIVATE_CREDENTIAL,              NULL),
    186     TPM_CMD_CODE_INIT(TPM2_CC_CERTIFY,                          NULL),
    187     TPM_CMD_CODE_INIT(TPM2_CC_POLICY_NV,                        NULL),
    188     TPM_CMD_CODE_INIT(TPM2_CC_CERTIFY_CREATION,                 NULL),
    189     TPM_CMD_CODE_INIT(TPM2_CC_DUPLICATE,                        NULL),
    190     TPM_CMD_CODE_INIT(TPM2_CC_GET_TIME,                         NULL),
    191     TPM_CMD_CODE_INIT(TPM2_CC_GET_SESSION_AUDIT_DIGEST,         NULL),
    192     TPM_CMD_CODE_INIT(TPM2_CC_NV_READ,                          NULL),
    193     TPM_CMD_CODE_INIT(TPM2_CC_NV_READ_LOCK,                     NULL),
    194     TPM_CMD_CODE_INIT(TPM2_CC_OBJECT_CHANGE_AUTH,               NULL),
    195     TPM_CMD_CODE_INIT(TPM2_CC_POLICY_SECRET,                    NULL),
    196     TPM_CMD_CODE_INIT(TPM2_CC_REWRAP,                           NULL),
    197     TPM_CMD_CODE_INIT(TPM2_CC_CREATE,                           NULL),
    198     TPM_CMD_CODE_INIT(TPM2_CC_ECDH_ZGEN,                        NULL),
    199     TPM_CMD_CODE_INIT(TPM2_CC_HMAC_MAC,                         NULL),
    200     TPM_CMD_CODE_INIT(TPM2_CC_IMPORT,                           NULL),
    201     TPM_CMD_CODE_INIT(TPM2_CC_LOAD,                             NULL),
    202     TPM_CMD_CODE_INIT(TPM2_CC_QUOTE,                            NULL),
    203     TPM_CMD_CODE_INIT(TPM2_CC_RSA_DECRYPT,                      NULL),
    204     TPM_CMD_CODE_INIT(TPM2_CC_HMAC_MAC_START,                   NULL),
    205     TPM_CMD_CODE_INIT(TPM2_CC_SEQUENCE_UPDATE,                  NULL),
    206     TPM_CMD_CODE_INIT(TPM2_CC_SIGN,                             NULL),
    207     TPM_CMD_CODE_INIT(TPM2_CC_UNSEAL,                           NULL),
    208     TPM_CMD_CODE_INIT(TPM2_CC_POLICY_SIGNED,                    NULL),
    209     TPM_CMD_CODE_INIT(TPM2_CC_CONTEXT_LOAD,                     NULL),
    210     TPM_CMD_CODE_INIT(TPM2_CC_CONTEXT_SAVE,                     NULL),
    211     TPM_CMD_CODE_INIT(TPM2_CC_ECDH_KEY_GEN,                     NULL),
    212     TPM_CMD_CODE_INIT(TPM2_CC_ENCRYPT_DECRYPT,                  NULL),
    213     TPM_CMD_CODE_INIT(TPM2_CC_FLUSH_CONTEXT,                    NULL),
    214     TPM_CMD_CODE_INIT(TPM2_CC_LOAD_EXTERNAL,                    NULL),
    215     TPM_CMD_CODE_INIT(TPM2_CC_MAKE_CREDENTIAL,                  NULL),
    216     TPM_CMD_CODE_INIT(TPM2_CC_NV_READ_PUBLIC,                   NULL),
    217     TPM_CMD_CODE_INIT(TPM2_CC_POLICY_AUTHORIZE,                 NULL),
    218     TPM_CMD_CODE_INIT(TPM2_CC_POLICY_AUTH_VALUE,                NULL),
    219     TPM_CMD_CODE_INIT(TPM2_CC_POLICY_COMMAND_CODE,              NULL),
    220     TPM_CMD_CODE_INIT(TPM2_CC_POLICY_COUNTER_TIMER,             NULL),
    221     TPM_CMD_CODE_INIT(TPM2_CC_POLICY_CP_HASH,                   NULL),
    222     TPM_CMD_CODE_INIT(TPM2_CC_POLICY_LOCALITY,                  NULL),
    223     TPM_CMD_CODE_INIT(TPM2_CC_POLICY_NAME_HASH,                 NULL),
    224     TPM_CMD_CODE_INIT(TPM2_CC_POLICY_OR,                        NULL),
    225     TPM_CMD_CODE_INIT(TPM2_CC_POLICY_TICKET,                    NULL),
    226     TPM_CMD_CODE_INIT(TPM2_CC_READ_PUBLIC,                      vboxTraceLogDecodeEvtTpmDecodeReadPublic),
    227     TPM_CMD_CODE_INIT(TPM2_CC_RSA_ENCRYPT,                      NULL),
    228     TPM_CMD_CODE_INIT(TPM2_CC_START_AUTH_SESSION,               NULL),
    229     TPM_CMD_CODE_INIT(TPM2_CC_VERIFY_SIGNATURE,                 NULL),
    230     TPM_CMD_CODE_INIT(TPM2_CC_ECC_PARAMETERS,                   NULL),
    231     TPM_CMD_CODE_INIT(TPM2_CC_FIRMWARE_READ,                    NULL),
    232     TPM_CMD_CODE_INIT(TPM2_CC_GET_CAPABILITY,                   vboxTraceLogDecodeEvtTpmDecodeGetCapability),
    233     TPM_CMD_CODE_INIT(TPM2_CC_GET_RANDOM,                       NULL),
    234     TPM_CMD_CODE_INIT(TPM2_CC_GET_TEST_RESULT,                  NULL),
    235     TPM_CMD_CODE_INIT(TPM2_CC_GET_HASH,                         NULL),
    236     TPM_CMD_CODE_INIT(TPM2_CC_PCR_READ,                         NULL),
    237     TPM_CMD_CODE_INIT(TPM2_CC_POLICY_PCR,                       NULL),
    238     TPM_CMD_CODE_INIT(TPM2_CC_POLICY_RESTART,                   NULL),
    239     TPM_CMD_CODE_INIT(TPM2_CC_READ_CLOCK,                       NULL),
    240     TPM_CMD_CODE_INIT(TPM2_CC_PCR_EXTEND,                       NULL),
    241     TPM_CMD_CODE_INIT(TPM2_CC_PCR_SET_AUTH_VALUE,               NULL),
    242     TPM_CMD_CODE_INIT(TPM2_CC_NV_CERTIFY,                       NULL),
    243     TPM_CMD_CODE_INIT(TPM2_CC_EVENT_SEQUENCE_COMPLETE,          NULL),
    244     TPM_CMD_CODE_INIT(TPM2_CC_HASH_SEQUENCE_START,              NULL),
    245     TPM_CMD_CODE_INIT(TPM2_CC_POLICY_PHYSICAL_PRESENCE,         NULL),
    246     TPM_CMD_CODE_INIT(TPM2_CC_POLICY_DUPLICATION_SELECT,        NULL),
    247     TPM_CMD_CODE_INIT(TPM2_CC_POLICY_GET_DIGEST,                NULL),
    248     TPM_CMD_CODE_INIT(TPM2_CC_TEST_PARMS,                       NULL),
    249     TPM_CMD_CODE_INIT(TPM2_CC_COMMIT,                           NULL),
    250     TPM_CMD_CODE_INIT(TPM2_CC_POLICY_PASSWORD,                  NULL),
    251     TPM_CMD_CODE_INIT(TPM2_CC_ZGEN_2PHASE,                      NULL),
    252     TPM_CMD_CODE_INIT(TPM2_CC_EC_EPHEMERAL,                     NULL),
    253     TPM_CMD_CODE_INIT(TPM2_CC_POLICY_NV_WRITTEN,                NULL),
    254     TPM_CMD_CODE_INIT(TPM2_CC_POLICY_TEMPLATE,                  NULL),
    255     TPM_CMD_CODE_INIT(TPM2_CC_CREATE_LOADED,                    NULL),
    256     TPM_CMD_CODE_INIT(TPM2_CC_POLICY_AUTHORIZE_NV,              NULL),
    257     TPM_CMD_CODE_INIT(TPM2_CC_ENCRYPT_DECRYPT_2,                NULL),
    258     TPM_CMD_CODE_INIT(TPM2_CC_AC_GET_CAPABILITY,                NULL),
    259     TPM_CMD_CODE_INIT(TPM2_CC_AC_SEND,                          NULL),
    260     TPM_CMD_CODE_INIT(TPM2_CC_POLICY_AC_SEND_SELECT,            NULL),
    261     TPM_CMD_CODE_INIT(TPM2_CC_CERTIFY_X509,                     NULL),
    262     TPM_CMD_CODE_INIT(TPM2_CC_ACT_SET_TIMEOUT,                  NULL),
    263     TPM_CMD_CODE_INIT(TPM2_CC_ECC_ENCRYPT,                      NULL),
    264     TPM_CMD_CODE_INIT(TPM2_CC_ECC_DECRYPT,                      NULL),
    265     TPM_CMD_CODE_INIT(TPM2_CC_POLICY_CAPABILITY,                NULL),
    266     TPM_CMD_CODE_INIT(TPM2_CC_POLICY_PARAMETERS,                NULL),
    267     TPM_CMD_CODE_INIT(TPM2_CC_NV_DEFINE_SPACE_2,                NULL),
    268     TPM_CMD_CODE_INIT(TPM2_CC_NV_READ_PUBLIC_2,                 NULL),
    269     TPM_CMD_CODE_INIT(TPM2_CC_SET_CAPABILITY,                   NULL)
     346#define TPM_CMD_CODE_INIT_NOT_IMPL(a_CmdCode) { a_CmdCode, #a_CmdCode, 0, 0, NULL, NULL }
     347#define TPM_CMD_CODE_INIT(a_CmdCode, a_ReqStruct, a_RespStruct, a_pfnReq, a_pfnResp) { a_CmdCode, #a_CmdCode, sizeof(a_ReqStruct), \
     348                                                                                       sizeof(a_RespStruct), a_pfnReq, a_pfnResp }
     349    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_UNDEFINE_SPACE_SPECIAL),
     350    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_EVICT_CONTROL),
     351    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_HIERARCHY_CONTROL),
     352    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_UNDEFINE_SPACE),
     353    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CHANGE_EPS),
     354    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CHANGE_PPS),
     355    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CLEAR),
     356    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CLEAR_CONTROL),
     357    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CLOCK_SET),
     358    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_HIERARCHY_CHANGE_AUTH),
     359    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_DEFINE_SPACE),
     360    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PCR_ALLOCATE),
     361    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PCR_SET_AUTH_POLICY),
     362    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PP_COMMANDS),
     363    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_SET_PRIMARY_POLICY),
     364    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_FIELD_UPGRADE_START),
     365    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CLOCK_RATE_ADJUST),
     366    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CREATE_PRIMARY),
     367    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_GLOBAL_WRITE_LOCK),
     368    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_GET_COMMAND_AUDIT_DIGEST),
     369    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_INCREMENT),
     370    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_SET_BITS),
     371    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_EXTEND),
     372    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_WRITE),
     373    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_WRITE_LOCK),
     374    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_DICTIONARY_ATTACK_LOCK_RESET),
     375    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_DICTIONARY_ATTACK_PARAMETERS),
     376    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_CHANGE_AUTH),
     377    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PCR_EVENT),
     378    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PCR_RESET),
     379    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_SEQUENCE_COMPLETE),
     380    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_SET_ALGORITHM_SET),
     381    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_SET_COMMAND_CODE_AUDIT_STATUS),
     382    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_FIELD_UPGRADE_DATA),
     383    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_INCREMENTAL_SELF_TEST),
     384    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_SELF_TEST),
     385    TPM_CMD_CODE_INIT(         TPM2_CC_STARTUP,                          TPMREQHDR,             TPMRESPHDR,             vboxTraceLogDecodeEvtTpmDecodeStartupShutdownReq,   NULL),
     386    TPM_CMD_CODE_INIT(         TPM2_CC_SHUTDOWN,                         TPMREQHDR,             TPMRESPHDR,             vboxTraceLogDecodeEvtTpmDecodeStartupShutdownReq,   NULL),
     387    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_STIR_RANDOM),
     388    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ACTIVATE_CREDENTIAL),
     389    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CERTIFY),
     390    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_NV),
     391    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CERTIFY_CREATION),
     392    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_DUPLICATE),
     393    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_GET_TIME),
     394    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_GET_SESSION_AUDIT_DIGEST),
     395    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_READ),
     396    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_READ_LOCK),
     397    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_OBJECT_CHANGE_AUTH),
     398    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_SECRET),
     399    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_REWRAP),
     400    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CREATE),
     401    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ECDH_ZGEN),
     402    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_HMAC_MAC),
     403    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_IMPORT),
     404    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_LOAD),
     405    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_QUOTE),
     406    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_RSA_DECRYPT),
     407    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_HMAC_MAC_START),
     408    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_SEQUENCE_UPDATE),
     409    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_SIGN),
     410    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_UNSEAL),
     411    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_SIGNED),
     412    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CONTEXT_LOAD),
     413    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CONTEXT_SAVE),
     414    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ECDH_KEY_GEN),
     415    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ENCRYPT_DECRYPT),
     416    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_FLUSH_CONTEXT),
     417    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_LOAD_EXTERNAL),
     418    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_MAKE_CREDENTIAL),
     419    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_READ_PUBLIC),
     420    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_AUTHORIZE),
     421    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_AUTH_VALUE),
     422    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_COMMAND_CODE),
     423    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_COUNTER_TIMER),
     424    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_CP_HASH),
     425    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_LOCALITY),
     426    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_NAME_HASH),
     427    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_OR),
     428    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_TICKET),
     429    TPM_CMD_CODE_INIT(         TPM2_CC_READ_PUBLIC,                      TPM2REQREADPUBLIC,     TPMRESPHDR,             vboxTraceLogDecodeEvtTpmDecodeReadPublicReq,        NULL),
     430    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_RSA_ENCRYPT),
     431    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_START_AUTH_SESSION),
     432    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_VERIFY_SIGNATURE),
     433    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ECC_PARAMETERS),
     434    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_FIRMWARE_READ),
     435    TPM_CMD_CODE_INIT(         TPM2_CC_GET_CAPABILITY,                   TPM2REQGETCAPABILITY,  TPM2RESPGETCAPABILITY,  vboxTraceLogDecodeEvtTpmDecodeGetCapabilityReq,     vboxTraceLogDecodeEvtTpmDecodeGetCapabilityResp),
     436    TPM_CMD_CODE_INIT(         TPM2_CC_GET_RANDOM,                       TPM2REQGETRANDOM,      TPM2RESPGETRANDOM,      vboxTraceLogDecodeEvtTpmDecodeGetRandomReq,         vboxTraceLogDecodeEvtTpmDecodeGetRandomResp),
     437    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_GET_TEST_RESULT),
     438    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_GET_HASH),
     439    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PCR_READ),
     440    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_PCR),
     441    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_RESTART),
     442    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_READ_CLOCK),
     443    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PCR_EXTEND),
     444    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PCR_SET_AUTH_VALUE),
     445    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_CERTIFY),
     446    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_EVENT_SEQUENCE_COMPLETE),
     447    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_HASH_SEQUENCE_START),
     448    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_PHYSICAL_PRESENCE),
     449    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_DUPLICATION_SELECT),
     450    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_GET_DIGEST),
     451    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_TEST_PARMS),
     452    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_COMMIT),
     453    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_PASSWORD),
     454    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ZGEN_2PHASE),
     455    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_EC_EPHEMERAL),
     456    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_NV_WRITTEN),
     457    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_TEMPLATE),
     458    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CREATE_LOADED),
     459    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_AUTHORIZE_NV),
     460    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ENCRYPT_DECRYPT_2),
     461    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_AC_GET_CAPABILITY),
     462    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_AC_SEND),
     463    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_AC_SEND_SELECT),
     464    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CERTIFY_X509),
     465    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ACT_SET_TIMEOUT),
     466    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ECC_ENCRYPT),
     467    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ECC_DECRYPT),
     468    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_CAPABILITY),
     469    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_PARAMETERS),
     470    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_DEFINE_SPACE_2),
     471    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_READ_PUBLIC_2),
     472    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_SET_CAPABILITY)
    270473#undef TPM_CMD_CODE_INIT
    271474};
    … …  
    276479    if (cbCmd >= sizeof(*pHdr))
    277480    {
    278         uint32_t u32CmdCode = RT_BE2H_U32(pHdr->u32Ordinal);
     481        uint32_t  u32CmdCode   = RT_BE2H_U32(pHdr->u32Ordinal);
     482        uint32_t  cbReqPayload = RT_BE2H_U32(pHdr->cbReq) - sizeof(*pHdr);
     483        PTPMSTATE pTpmState    = (PTPMSTATE)pHlp->pfnDecoderStateGet(pHlp);
     484
     485        if (!pTpmState)
     486        {
     487            int rc = pHlp->pfnDecoderStateCreate(pHlp, sizeof(*pTpmState), NULL, (void **)&pTpmState);
     488            if (RT_SUCCESS(rc))
     489                pTpmState->u32CmdCode = u32CmdCode;
     490            else
     491                pHlp->pfnErrorMsg(pHlp, "Failed to allocate TPM decoder state: %Rrc\n", rc);
     492        }
     493        else
     494            pTpmState->u32CmdCode = u32CmdCode;
     495
    279496        for (uint32_t i = 0; i < RT_ELEMENTS(s_aTpmCmdCodes); i++)
    280497        {
    281498            if (s_aTpmCmdCodes[i].u32CmdCode == u32CmdCode)
    282499            {
    283                 RTMsgInfo("    %s:\n", s_aTpmCmdCodes[i].pszCmdCode);
    284                 if (s_aTpmCmdCodes[i].pfnDecode)
    285                     s_aTpmCmdCodes[i].pfnDecode(pHlp, pHdr, RT_BE2H_U32(pHdr->cbReq));
     500                pHlp->pfnPrintf(pHlp, "    %s (%u bytes):\n", s_aTpmCmdCodes[i].pszCmdCode, cbReqPayload);
     501                if (s_aTpmCmdCodes[i].pfnDecodeReq)
     502                {
     503                    if (cbCmd >= s_aTpmCmdCodes[i].cbReqMin)
     504                        s_aTpmCmdCodes[i].pfnDecodeReq(pHlp, pTpmState, pHdr, cbReqPayload);
     505                    else
     506                        pHlp->pfnErrorMsg(pHlp, "Malformed %s command, not enough room for the input\n", s_aTpmCmdCodes[i].pszCmdCode);
     507                }
     508                else if (cbReqPayload)
     509                    pHlp->pfnPrintf(pHlp, "%.*Rhxd\n", cbReqPayload, pHdr + 1);
    286510                return;
    287511            }
    288512        }
    289         RTMsgInfo("    <Unknown command code>: %#x\n", u32CmdCode);
     513        pHlp->pfnPrintf(pHlp, "    <Unknown command code>: %#x\n", u32CmdCode);
     514
     515        if (cbReqPayload)
     516            pHlp->pfnPrintf(pHlp, "%.*Rhxd\n", cbReqPayload, pHdr + 1);
    290517    }
    291518    else
    292         RTMsgError("Command buffer is smaller than the request header (required %u, given %zu\n", sizeof(*pHdr), cbCmd);
     519        pHlp->pfnErrorMsg(pHlp, "Command buffer is smaller than the request header (required %u, given %zu\n", sizeof(*pHdr), cbCmd);
    293520}
    294521
    … …  
    301528    if (cbResp >= sizeof(*pHdr))
    302529    {
    303         RTMsgInfo("    Status code: %#x\n", RT_BE2H_U32(pHdr->u32ErrCode));
     530        uint32_t cbRespPayload = RT_BE2H_U32(pHdr->cbResp) - sizeof(*pHdr);
     531
     532        pHlp->pfnPrintf(pHlp, "    Status code: %#x (%u bytes)\n", RT_BE2H_U32(pHdr->u32ErrCode), cbRespPayload);
     533        PTPMSTATE pTpmState = (PTPMSTATE)pHlp->pfnDecoderStateGet(pHlp);
     534
     535        /* Can only decode the response buffer if we know the command code. */
     536        if (pTpmState)
     537        {
     538            for (uint32_t i = 0; i < RT_ELEMENTS(s_aTpmCmdCodes); i++)
     539            {
     540                if (s_aTpmCmdCodes[i].u32CmdCode == pTpmState->u32CmdCode)
     541                {
     542                    if (s_aTpmCmdCodes[i].pfnDecodeResp)
     543                    {
     544                        s_aTpmCmdCodes[i].pfnDecodeResp(pHlp, pTpmState, pHdr, cbRespPayload);
     545                        return;
     546                    }
     547                    break;
     548                }
     549            }
     550        }
     551
     552        if (cbRespPayload)
     553            pHlp->pfnPrintf(pHlp, "%.*Rhxd\n", cbRespPayload, pHdr + 1);
    304554    }
    305555    else
    306         RTMsgError("Response buffer is smaller than the request header (required %u, given %zu\n", sizeof(*pHdr), cbResp);
     556        pHlp->pfnErrorMsg(pHlp, "Response buffer is smaller than the request header (required %u, given %zu\n", sizeof(*pHdr), cbResp);
    307557}
    308558
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette