VirtualBox

Changeset 104961 in vbox


Ignore:
Timestamp:
Jun 19, 2024 10:47:52 AM (3 months ago)
Author:
vboxsync
Message:

Devices/Trace: Updates to the TPM trace decoding, properly decode handle, parameters and authorization areas of a command/response buffer, bugref:10701

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r104958 r104961  
    213213        pHlp->pfnErrorMsg(pHlp, "Failed to decode '%s' as there is not enough space in the buffer (required %u, available %u)",
    214214                          pszItem, sizeof(uint8_t), pCtx->cbLeft);
    215         AssertFailed();
     215        //AssertFailed();
    216216        pCtx->fError = true;
    217217        return 0;
    … …  
    232232        pHlp->pfnErrorMsg(pHlp, "Failed to decode '%s' as there is not enough space in the buffer (required %u, available %u)",
    233233                          pszItem, sizeof(uint16_t), pCtx->cbLeft);
    234         AssertFailed();
     234        //AssertFailed();
    235235        pCtx->fError = true;
    236236        return 0;
    … …  
    253253        pHlp->pfnErrorMsg(pHlp, "Failed to decode '%s' as there is not enough space in the buffer (required %u, available %u)",
    254254                          pszItem, sizeof(uint32_t), pCtx->cbLeft);
    255         AssertFailed();
     255        //AssertFailed();
    256256        pCtx->fError = true;
    257257        return 0;
    … …  
    265265
    266266
     267static int32_t vboxTraceLogDecodeEvtTpmDecodeCtxGetI32(PTPMDECODECTX pCtx, PRTTRACELOGDECODERHLP pHlp, const char *pszItem)
     268{
     269    return (int32_t)vboxTraceLogDecodeEvtTpmDecodeCtxGetU32(pCtx, pHlp, pszItem);
     270}
     271
     272
    267273static uint64_t vboxTraceLogDecodeEvtTpmDecodeCtxGetU64(PTPMDECODECTX pCtx, PRTTRACELOGDECODERHLP pHlp, const char *pszItem)
    268274{
    … …  
    274280        pHlp->pfnErrorMsg(pHlp, "Failed to decode '%s' as there is not enough space in the buffer (required %u, available %u)",
    275281                          pszItem, sizeof(uint64_t), pCtx->cbLeft);
    276         AssertFailed();
     282        //AssertFailed();
    277283        pCtx->fError = true;
    278284        return 0;
    … …  
    295301        pHlp->pfnErrorMsg(pHlp, "Failed to decode '%s' as there is not enough space in the buffer (required %u, available %u)",
    296302                          pszItem, cbBuf, pCtx->cbLeft);
    297         AssertFailed();
     303        //AssertFailed();
    298304        pCtx->fError = true;
    299305        return 0;
    … …  
    351357#define TPM_DECODE_U64(a_Var, a_Name) \
    352358    uint64_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU64(pCtx, pHlp, #a_Name); \
     359    if (pCtx->fError) break
     360
     361#define TPM_DECODE_I32(a_Var, a_Name) \
     362    int32_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetI32(pCtx, pHlp, #a_Name); \
    353363    if (pCtx->fError) break
    354364
    … …  
    435445
    436446
    437 static void vboxTraceLogDecodeEvtTpmAuthSession(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx)
     447static void vboxTraceLogDecodeEvtTpmAuthSessionReq(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx)
    438448{
    439449    TPM_DECODE_INIT();
    … …  
    455465        if (u16HmacSize)
    456466            pHlp->pfnPrintf(pHlp, "        abHmac:           %.*Rhxs\n", u16HmacSize, pbHmac);
     467    TPM_DECODE_END();
     468}
     469
     470
     471static void vboxTraceLogDecodeEvtTpmAuthSessionResp(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx)
     472{
     473    TPM_DECODE_INIT();
     474        TPM_DECODE_U16(u16NonceSize,     u16NonceSize);
     475        TPM_DECODE_BUF(pbNonce,          abNonce, u16NonceSize);
     476        TPM_DECODE_U8( u8Attr,           u8Attr);
     477        TPM_DECODE_U16(u16AckSize,       u16AckSize);
     478        TPM_DECODE_BUF(pbAck,            abAck,  u16AckSize);
     479
     480        pHlp->pfnPrintf(pHlp, "        u16NonceSize:     %u\n", u16NonceSize);
     481        if (u16NonceSize)
     482            pHlp->pfnPrintf(pHlp, "        abNonce:          %.*Rhxs\n", u16NonceSize, pbNonce);
     483        pHlp->pfnPrintf(pHlp, "        u8Attr:           %u\n", u8Attr);
     484        pHlp->pfnPrintf(pHlp, "        u16AckSize:       %u\n", u16AckSize);
     485        if (u16AckSize)
     486            pHlp->pfnPrintf(pHlp, "        abAck:            %.*Rhxs\n", u16AckSize, pbAck);
    457487    TPM_DECODE_END();
    458488}
    … …  
    494524}
    495525
     526
     527static void vboxTraceLogDecodeNvPublic(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx, const char *pszName)
     528{
     529    TPM_DECODE_INIT();
     530        pHlp->pfnPrintf(pHlp, "        %s:\n", pszName);
     531        TPM_DECODE_U16(u16Size, u16Size);
     532        pHlp->pfnPrintf(pHlp, "            u16Size:  %u\n", u16Size);
     533        if (u16Size)
     534        {
     535            TPM_DECODE_U32(hNvIndex,        hNvIndex);
     536            TPM_DECODE_U16(u16HashAlgName,  u16HashAlgName);
     537            TPM_DECODE_U32(u32Attr,         fAttr);
     538
     539            pHlp->pfnPrintf(pHlp, "            hNvIndex:         %#x\n", hNvIndex);
     540            pHlp->pfnPrintf(pHlp, "            u16HashAlgName:   %u\n",  u16HashAlgName);
     541            pHlp->pfnPrintf(pHlp, "            u32Attr:          %#x\n", u32Attr);
     542
     543            vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "AuthPolicy");
     544            TPM_DECODE_U16(u16DataSize, u16DataSize);
     545            pHlp->pfnPrintf(pHlp, "            u16DataSize:      %u\n",  u16DataSize);
     546        }
     547    TPM_DECODE_END();
     548}
     549
     550
     551static void vboxTraceLogDecodeTicket(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx, const char *pszName)
     552{
     553    TPM_DECODE_INIT();
     554        pHlp->pfnPrintf(pHlp, "        %s:\n", pszName);
     555
     556        TPM_DECODE_U16(u16Tag,      u16Tag);
     557        TPM_DECODE_U32(hHierarchy,  hHierarchy);
     558        pHlp->pfnPrintf(pHlp, "            u16Tag:       %#x\n", u16Tag);
     559        pHlp->pfnPrintf(pHlp, "            hHierarchy:   %#x\n", hHierarchy);
     560        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Digest");
     561    TPM_DECODE_END();
     562}
    496563
    497564static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeStartupShutdownReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
    … …  
    576643                }
    577644                default:
    578                     pHlp->pfnPrintf(pHlp, "%.*Rhxd\n", pCtx->cbLeft, pCtx->pbBuf);
    579645                    break;
    580646            }
    581647        }
    582648        else
    583         {
    584649            pHlp->pfnPrintf(pHlp, "        u32Cap:    %#x (UNKNOWN)\n", u32Cap);
    585             pHlp->pfnPrintf(pHlp, "%.*Rhxd\n", pCtx->cbLeft, pCtx->pbBuf);
    586         }
    587     TPM_DECODE_END();
    588 }
    589 
    590 
    591 static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeReadPublicReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
    592 {
    593     RT_NOREF(pThis);
    594 
    595     TPM_DECODE_INIT();
    596         TPM_DECODE_U32(hObj, hObj);
    597         pHlp->pfnPrintf(pHlp, "        hObj:      %#x\n", hObj);
    598     TPM_DECODE_END();
    599 }
     650    TPM_DECODE_END();
     651}
     652
     653
     654static const char *g_apszHandlesReadPublicReq[] =
     655{
     656    "hObj",
     657    NULL
     658};
    600659
    601660
    … …  
    667726
    668727
     728static const char *g_apszHandlesPcrExtendReq[] =
     729{
     730    "hPcr",
     731    NULL
     732};
     733
     734
    669735static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodePcrExtendReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
    670736{
    … …  
    672738
    673739    TPM_DECODE_INIT();
    674         TPM_DECODE_U32(hPcr, hPcr);
    675         pHlp->pfnPrintf(pHlp, "        hPcr:      %#x\n", hPcr);
    676 
    677         vboxTraceLogDecodeEvtTpmAuthSession(pHlp, pCtx);
    678         TPM_DECODE_END_IF_ERROR();
    679740        vboxTraceLogDecodeEvtTpmDigestValuesList(pHlp, pCtx);
    680741    TPM_DECODE_END();
    … …  
    704765
    705766
    706 static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeNvReadPublicReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
    707 {
    708     RT_NOREF(pThis);
    709 
    710     TPM_DECODE_INIT();
    711         TPM_DECODE_U32(hNvIndex, hNvIndex);
    712         pHlp->pfnPrintf(pHlp, "        hNvIndex: %#x\n", hNvIndex);
    713     TPM_DECODE_END();
    714 }
     767static const char *g_apszHandlesNvReadPublicReq[] =
     768{
     769    "hNvIndex",
     770    NULL
     771};
    715772
    716773
    … …  
    725782
    726783
     784static const char *g_apszHandlesStartAuthSessionReq[] =
     785{
     786    "hTpmKey",
     787    "hBind",
     788    NULL
     789};
     790
     791
    727792static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeStartAuthSessionReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
    728793{
    … …  
    730795
    731796    TPM_DECODE_INIT();
    732         TPM_DECODE_U32(hTpmKey, hTpmKey);
    733         pHlp->pfnPrintf(pHlp, "        hTpmKey:  %#x\n", hTpmKey);
    734         TPM_DECODE_U32(hBind, hBind);
    735         pHlp->pfnPrintf(pHlp, "        hBind:    %#x\n", hBind);
    736 
    737797        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "NonceCaller");
    738798        TPM_DECODE_END_IF_ERROR();
    … …  
    752812
    753813
     814static const char *g_apszHandlesStartAuthSessionResp[] =
     815{
     816    "hSession",
     817    NULL
     818};
     819
     820
    754821static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeStartAuthSessionResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
    755822{
    … …  
    757824
    758825    TPM_DECODE_INIT();
    759         TPM_DECODE_U32(hSession, hSession);
    760         pHlp->pfnPrintf(pHlp, "        hSession: %#x\n", hSession);
    761826        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "NonceTpm");
    762827    TPM_DECODE_END();
    … …  
    764829
    765830
     831static const char *g_apszHandlesHierarchyChangeAuthReq[] =
     832{
     833    "hAuth",
     834    NULL
     835};
     836
    766837static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeHierarchyChangeAuthReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
    767838{
    … …  
    769840
    770841    TPM_DECODE_INIT();
    771         TPM_DECODE_U32(hAuth, hAuth);
    772         pHlp->pfnPrintf(pHlp, "        hAuth:    %#x\n", hAuth);
    773         vboxTraceLogDecodeEvtTpmAuthSession(pHlp, pCtx);
    774         TPM_DECODE_END_IF_ERROR();
    775 
    776842        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "NewAuth");
    777      TPM_DECODE_END();
    778 }
    779 
     843    TPM_DECODE_END();
     844}
     845
     846
     847static const char *g_apszHandlesNvDefineSpaceReq[] =
     848{
     849    "hAuth",
     850    NULL
     851};
     852
     853static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeNvDefineSpaceReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
     854{
     855    RT_NOREF(pThis);
     856
     857    TPM_DECODE_INIT();
     858        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Auth");
     859        TPM_DECODE_END_IF_ERROR();
     860
     861        vboxTraceLogDecodeNvPublic(pHlp, pCtx, "PublicInfo");
     862    TPM_DECODE_END();
     863}
     864
     865
     866static const char *g_apszHandlesSetPrimaryPolicyReq[] =
     867{
     868    "hAuth",
     869    NULL
     870};
     871
     872static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeSetPrimaryPolicyReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
     873{
     874    RT_NOREF(pThis);
     875
     876    TPM_DECODE_INIT();
     877        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "AuthPolicy");
     878        TPM_DECODE_END_IF_ERROR();
     879
     880        TPM_DECODE_U16(u16HashAlg, u16HashAlg);
     881        pHlp->pfnPrintf(pHlp, "        u16HashAlg: %s\n", vboxTraceLogDecodeEvtTpmAlgId2Str(u16HashAlg));
     882    TPM_DECODE_END();
     883}
     884
     885
     886static const char *g_apszHandlesCreatePrimaryReq[] =
     887{
     888    "hPrimary",
     889    NULL
     890};
     891
     892static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeCreatePrimaryReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
     893{
     894    RT_NOREF(pThis);
     895
     896    TPM_DECODE_INIT();
     897        /** @todo Decode InSensitive. */
     898        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "InSensitive");
     899        TPM_DECODE_END_IF_ERROR();
     900        /** @todo Decode InPublic. */
     901        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "InPublic");
     902        TPM_DECODE_END_IF_ERROR();
     903
     904        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "OutsideInfo");
     905        TPM_DECODE_END_IF_ERROR();
     906
     907        vboxTraceLogDecodePcrSelectionList(pHlp, pCtx);
     908
     909    TPM_DECODE_END();
     910}
     911
     912
     913static const char *g_apszHandlesCreatePrimaryResp[] =
     914{
     915    "hObj",
     916    NULL
     917};
     918
     919
     920static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeCreatePrimaryResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
     921{
     922    RT_NOREF(pThis);
     923
     924    TPM_DECODE_INIT();
     925        /** @todo Decode OutPublic. */
     926        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "OutPublic");
     927        TPM_DECODE_END_IF_ERROR();
     928        /** @todo Decode CreationData. */
     929        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "CreationData");
     930        TPM_DECODE_END_IF_ERROR();
     931
     932        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "CreationHash");
     933        TPM_DECODE_END_IF_ERROR();
     934
     935        vboxTraceLogDecodeTicket(pHlp, pCtx, "Ticket");
     936        TPM_DECODE_END_IF_ERROR();
     937
     938        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Name");
     939    TPM_DECODE_END();
     940}
     941
     942
     943static const char *g_apszHandlesNvIncrementReq[] =
     944{
     945    "hAuth",
     946    "hNvIndex",
     947    NULL
     948};
     949
     950
     951static const char *g_apszHandlesNvSetBitsReq[] =
     952{
     953    "hAuth",
     954    "hNvIndex",
     955    NULL
     956};
     957
     958static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeNvSetBitsReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
     959{
     960    RT_NOREF(pThis);
     961
     962    TPM_DECODE_INIT();
     963        TPM_DECODE_U64(u64BitsOr, u64BitsOr);
     964        pHlp->pfnPrintf(pHlp, "        u64BitsOr:  %#RX64\n", u64BitsOr);
     965    TPM_DECODE_END();
     966}
     967
     968
     969static const char *g_apszHandlesNvWriteReq[] =
     970{
     971    "hAuth",
     972    "hNvIndex",
     973    NULL
     974};
     975
     976static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeNvWriteReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
     977{
     978    RT_NOREF(pThis);
     979
     980    TPM_DECODE_INIT();
     981        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Data");
     982        TPM_DECODE_END_IF_ERROR();
     983
     984        TPM_DECODE_U16(u16Offset, u16Offset);
     985        pHlp->pfnPrintf(pHlp, "        u16Offset:  %u\n", u16Offset);
     986    TPM_DECODE_END();
     987}
     988
     989
     990static const char *g_apszHandlesDictionaryAttackParametersReq[] =
     991{
     992    "hLock",
     993    NULL
     994};
     995
     996static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeDictionaryAttackParametersReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
     997{
     998    RT_NOREF(pThis);
     999
     1000    TPM_DECODE_INIT();
     1001        TPM_DECODE_U32(u32NewMaxTries,      u32NewMaxTries);
     1002        TPM_DECODE_U32(u32NewRecoveryTime,  u32NewRecoveryTime);
     1003        TPM_DECODE_U32(u32LockoutRecovery,  u32LockoutRecovery);
     1004
     1005        pHlp->pfnPrintf(pHlp, "        u32NewMaxTries:      %u\n", u32NewMaxTries);
     1006        pHlp->pfnPrintf(pHlp, "        u32NewRecoveryTime:  %u\n", u32NewRecoveryTime);
     1007        pHlp->pfnPrintf(pHlp, "        u32LockoutRecovery:  %u\n", u32LockoutRecovery);
     1008    TPM_DECODE_END();
     1009}
     1010
     1011
     1012static const char *g_apszHandlesCertifyCreationReq[] =
     1013{
     1014    "hSign",
     1015    "hObj",
     1016    NULL
     1017};
     1018
     1019static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeCertifyCreationReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
     1020{
     1021    RT_NOREF(pThis);
     1022
     1023    TPM_DECODE_INIT();
     1024        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "QualifyingData");
     1025        TPM_DECODE_END_IF_ERROR();
     1026        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "CreationHash");
     1027        TPM_DECODE_END_IF_ERROR();
     1028
     1029        TPM_DECODE_U16(u16SigningScheme, u16SigningScheme);
     1030        pHlp->pfnPrintf(pHlp, "        u16SigningScheme: %s\n", vboxTraceLogDecodeEvtTpmAlgId2Str(u16SigningScheme));
     1031
     1032        vboxTraceLogDecodeTicket(pHlp, pCtx, "CreationTicket");
     1033    TPM_DECODE_END();
     1034}
     1035
     1036
     1037static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeCertifyCreationResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
     1038{
     1039    RT_NOREF(pThis);
     1040
     1041    TPM_DECODE_INIT();
     1042        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "CertifyInfo");
     1043
     1044        /* Decode TPMT_SIGNATURE */
     1045        TPM_DECODE_U16(u16SigningAlg, u16SigningAlg);
     1046        pHlp->pfnPrintf(pHlp, "        u16SigningAlg: %s\n", vboxTraceLogDecodeEvtTpmAlgId2Str(u16SigningAlg));
     1047        TPM_DECODE_U16(u16HashAlg, u16HashAlg);
     1048        pHlp->pfnPrintf(pHlp, "        u16HashAlg:    %s\n", vboxTraceLogDecodeEvtTpmAlgId2Str(u16HashAlg));
     1049
     1050    TPM_DECODE_END();
     1051}
     1052
     1053
     1054static const char *g_apszHandlesNvReadReq[] =
     1055{
     1056    "hAuth",
     1057    "hNvIndex",
     1058    NULL
     1059};
    7801060
    7811061static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeNvReadReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
    … …  
    7841064
    7851065    TPM_DECODE_INIT();
    786         TPM_DECODE_U32(hAuth, hAuth);
    787         pHlp->pfnPrintf(pHlp, "        hAuth:    %#x\n", hAuth);
    788         TPM_DECODE_U32(hNvIndex, hNvIndex);
    789         pHlp->pfnPrintf(pHlp, "        hNvIndex: %#x\n", hNvIndex);
    790 
    791         vboxTraceLogDecodeEvtTpmAuthSession(pHlp, pCtx);
    792         TPM_DECODE_END_IF_ERROR();
    793 
    7941066        TPM_DECODE_U16(u16Size,   u16Size);
    7951067        pHlp->pfnPrintf(pHlp, "        u16Size:   %u\n", u16Size);
    … …  
    8061078    TPM_DECODE_INIT();
    8071079        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Data");
     1080    TPM_DECODE_END();
     1081}
     1082
     1083
     1084static const char *g_apszHandlesPolicySecretReq[] =
     1085{
     1086    "hAuth",
     1087    "hPolicySession",
     1088    NULL
     1089};
     1090
     1091static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodePolicySecretReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
     1092{
     1093    RT_NOREF(pThis);
     1094
     1095    TPM_DECODE_INIT();
     1096        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "NonceTpm");
     1097        TPM_DECODE_END_IF_ERROR();
     1098        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "CpHashA");
     1099        TPM_DECODE_END_IF_ERROR();
     1100        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "PolicyRef");
     1101        TPM_DECODE_END_IF_ERROR();
     1102
     1103        TPM_DECODE_I32(i32Expiration,   i32Expiration);
     1104        pHlp->pfnPrintf(pHlp, "        i32Expiration: %u\n", i32Expiration);
     1105    TPM_DECODE_END();
     1106}
     1107
     1108
     1109static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodePolicySecretResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
     1110{
     1111    RT_NOREF(pThis);
     1112
     1113    TPM_DECODE_INIT();
     1114        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Timeout");
     1115        TPM_DECODE_END_IF_ERROR();
     1116
     1117        vboxTraceLogDecodeTicket(pHlp, pCtx, "Ticket");
     1118    TPM_DECODE_END();
     1119}
     1120
     1121
     1122static const char *g_apszHandlesCreateReq[] =
     1123{
     1124    "hParent",
     1125    NULL
     1126};
     1127
     1128static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeCreateReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
     1129{
     1130    RT_NOREF(pThis);
     1131
     1132    TPM_DECODE_INIT();
     1133        /** @todo Decode InSensitive. */
     1134        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "InSensitive");
     1135        TPM_DECODE_END_IF_ERROR();
     1136        /** @todo Decode InPublic. */
     1137        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "InPublic");
     1138        TPM_DECODE_END_IF_ERROR();
     1139
     1140        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "OutsideInfo");
     1141        TPM_DECODE_END_IF_ERROR();
     1142
     1143        vboxTraceLogDecodePcrSelectionList(pHlp, pCtx);
     1144
     1145    TPM_DECODE_END();
     1146}
     1147
     1148
     1149static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeCreateResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
     1150{
     1151    RT_NOREF(pThis);
     1152
     1153    TPM_DECODE_INIT();
     1154        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "OutPrivate");
     1155        TPM_DECODE_END_IF_ERROR();
     1156        /** @todo Decode OutPublic. */
     1157        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "OutPublic");
     1158        TPM_DECODE_END_IF_ERROR();
     1159        /** @todo Decode CreationData. */
     1160        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "CreationData");
     1161        TPM_DECODE_END_IF_ERROR();
     1162
     1163        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "CreationHash");
     1164        TPM_DECODE_END_IF_ERROR();
     1165
     1166        vboxTraceLogDecodeTicket(pHlp, pCtx, "Ticket");
    8081167    TPM_DECODE_END();
    8091168}
    … …  
    8601219
    8611220
     1221static const char *g_apszHandlesQuoteReq[] =
     1222{
     1223    "hSign",
     1224    NULL
     1225};
     1226
     1227
    8621228static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeQuoteReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
    8631229{
    … …  
    8651231
    8661232    TPM_DECODE_INIT();
    867         TPM_DECODE_U32(hSign, hSign);
    868         pHlp->pfnPrintf(pHlp, "        hSign:    %#x\n", hSign);
    869 
    870         vboxTraceLogDecodeEvtTpmAuthSession(pHlp, pCtx);
    871         TPM_DECODE_END_IF_ERROR();
    8721233        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "QualifyingData");
    8731234        TPM_DECODE_END_IF_ERROR();
    … …  
    9051266
    9061267
     1268static const char *g_apszHandlesHmacMacReq[] =
     1269{
     1270    "hSymKey",
     1271    NULL
     1272};
     1273
     1274
    9071275static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeHmacMacReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
    9081276{
    … …  
    9101278
    9111279    TPM_DECODE_INIT();
    912         TPM_DECODE_U32(hSymKey, hSymKey);
    913         pHlp->pfnPrintf(pHlp, "        hSymKey:    %#x\n", hSymKey);
    914 
    915         vboxTraceLogDecodeEvtTpmAuthSession(pHlp, pCtx);
    916         TPM_DECODE_END_IF_ERROR();
    9171280        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Buffer");
    9181281        TPM_DECODE_END_IF_ERROR();
    … …  
    9341297
    9351298
    936 static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeFlushContextReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
    937 {
    938     RT_NOREF(pThis);
    939 
    940     TPM_DECODE_INIT();
    941         TPM_DECODE_U32(hFlush, hFlush);
    942         pHlp->pfnPrintf(pHlp, "        hFlush:      %#x\n", hFlush);
     1299static const char *g_apszHandlesFlushContextReq[] =
     1300{
     1301    "hFlush",
     1302    NULL
     1303};
     1304
     1305
     1306static const char *g_apszHandlesLoadReq[] =
     1307{
     1308    "hParent",
     1309    NULL
     1310};
     1311
     1312
     1313static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeLoadReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
     1314{
     1315    RT_NOREF(pThis);
     1316
     1317    TPM_DECODE_INIT();
     1318        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "InPrivate");
     1319        TPM_DECODE_END_IF_ERROR();
     1320        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "InPublic");
     1321        TPM_DECODE_END_IF_ERROR();
     1322    TPM_DECODE_END();
     1323}
     1324
     1325
     1326static const char *g_apszHandlesLoadResp[] =
     1327{
     1328    "hObj",
     1329    NULL
     1330};
     1331
     1332
     1333static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeLoadResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
     1334{
     1335    RT_NOREF(pThis);
     1336
     1337    TPM_DECODE_INIT();
     1338        vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Name");
     1339        TPM_DECODE_END_IF_ERROR();
    9431340    TPM_DECODE_END();
    9441341}
    … …  
    9491346    uint32_t              u32CmdCode;
    9501347    const char            *pszCmdCode;
    951     uint32_t              cbReqMin;
    952     uint32_t              cbRespMin;
     1348    const char            **papszHandlesReq;
     1349    const char            **papszHandlesResp;
    9531350    PFNFNDECODETPM2CCREQ  pfnDecodeReq;
    9541351    PFNFNDECODETPM2CCRESP pfnDecodeResp;
    9551352} s_aTpmCmdCodes[] =
    9561353{
    957 #define TPM_CMD_CODE_INIT_NOT_IMPL(a_CmdCode) { a_CmdCode, #a_CmdCode, 0, 0, NULL, NULL }
    958 #define TPM_CMD_CODE_INIT(a_CmdCode, a_ReqStruct, a_RespStruct, a_pfnReq, a_pfnResp) { a_CmdCode, #a_CmdCode, sizeof(a_ReqStruct), \
    959                                                                                        sizeof(a_RespStruct), a_pfnReq, a_pfnResp }
     1354#define TPM_CMD_CODE_INIT_NOT_IMPL(a_CmdCode) { a_CmdCode, #a_CmdCode, NULL, NULL, NULL, NULL }
     1355#define TPM_CMD_CODE_INIT(a_CmdCode, a_apszHandlesReq, a_apszHandlesResp, a_pfnReq, a_pfnResp) { a_CmdCode, #a_CmdCode, \
     1356                                                                                                 a_apszHandlesReq, a_apszHandlesResp, \
     1357                                                                                                 a_pfnReq, a_pfnResp }
    9601358    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_UNDEFINE_SPACE_SPECIAL),
    9611359    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_EVICT_CONTROL),
    … …  
    9671365    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CLEAR_CONTROL),
    9681366    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CLOCK_SET),
    969     TPM_CMD_CODE_INIT(         TPM2_CC_HIERARCHY_CHANGE_AUTH,             TPMREQHDR,            TPMRESPHDR,            vboxTraceLogDecodeEvtTpmDecodeHierarchyChangeAuthReq,   NULL),
    970     TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_DEFINE_SPACE),
     1367    TPM_CMD_CODE_INIT(         TPM2_CC_HIERARCHY_CHANGE_AUTH,             g_apszHandlesHierarchyChangeAuthReq,          NULL,                               vboxTraceLogDecodeEvtTpmDecodeHierarchyChangeAuthReq,           NULL),
     1368    TPM_CMD_CODE_INIT(         TPM2_CC_NV_DEFINE_SPACE,                   g_apszHandlesNvDefineSpaceReq,                NULL,                               vboxTraceLogDecodeEvtTpmDecodeNvDefineSpaceReq,                 NULL),
    9711369    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PCR_ALLOCATE),
    9721370    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PCR_SET_AUTH_POLICY),
    9731371    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PP_COMMANDS),
    974     TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_SET_PRIMARY_POLICY),
     1372    TPM_CMD_CODE_INIT(         TPM2_CC_SET_PRIMARY_POLICY,                g_apszHandlesSetPrimaryPolicyReq,             NULL,                               vboxTraceLogDecodeEvtTpmDecodeSetPrimaryPolicyReq,              NULL),
    9751373    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_FIELD_UPGRADE_START),
    9761374    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CLOCK_RATE_ADJUST),
    977     TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CREATE_PRIMARY),
     1375    TPM_CMD_CODE_INIT(         TPM2_CC_CREATE_PRIMARY,                    g_apszHandlesCreatePrimaryReq,                g_apszHandlesCreatePrimaryResp,     vboxTraceLogDecodeEvtTpmDecodeCreatePrimaryReq,                 vboxTraceLogDecodeEvtTpmDecodeCreatePrimaryResp),
    9781376    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_GLOBAL_WRITE_LOCK),
    9791377    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_GET_COMMAND_AUDIT_DIGEST),
    980     TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_INCREMENT),
    981     TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_SET_BITS),
     1378    TPM_CMD_CODE_INIT(         TPM2_CC_NV_INCREMENT,                      g_apszHandlesNvIncrementReq,                  NULL,                               NULL,                                                           NULL),
     1379    TPM_CMD_CODE_INIT(         TPM2_CC_NV_SET_BITS,                       g_apszHandlesNvSetBitsReq,                    NULL,                               vboxTraceLogDecodeEvtTpmDecodeNvSetBitsReq,                     NULL),
    9821380    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_EXTEND),
    983     TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_WRITE),
     1381    TPM_CMD_CODE_INIT(         TPM2_CC_NV_WRITE,                          g_apszHandlesNvWriteReq,                      NULL,                               vboxTraceLogDecodeEvtTpmDecodeNvWriteReq,                       NULL),
    9841382    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_WRITE_LOCK),
    9851383    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_DICTIONARY_ATTACK_LOCK_RESET),
    986     TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_DICTIONARY_ATTACK_PARAMETERS),
     1384    TPM_CMD_CODE_INIT(         TPM2_CC_DICTIONARY_ATTACK_PARAMETERS,      g_apszHandlesDictionaryAttackParametersReq,   NULL,                               vboxTraceLogDecodeEvtTpmDecodeDictionaryAttackParametersReq,    NULL),
    9871385    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_CHANGE_AUTH),
    9881386    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PCR_EVENT),
    … …  
    9941392    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_INCREMENTAL_SELF_TEST),
    9951393    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_SELF_TEST),
    996     TPM_CMD_CODE_INIT(         TPM2_CC_STARTUP,                          TPMREQHDR,             TPMRESPHDR,             vboxTraceLogDecodeEvtTpmDecodeStartupShutdownReq,   NULL),
    997     TPM_CMD_CODE_INIT(         TPM2_CC_SHUTDOWN,                         TPMREQHDR,             TPMRESPHDR,             vboxTraceLogDecodeEvtTpmDecodeStartupShutdownReq,   NULL),
     1394    TPM_CMD_CODE_INIT(         TPM2_CC_STARTUP,                          NULL,                                          NULL,                               vboxTraceLogDecodeEvtTpmDecodeStartupShutdownReq,               NULL),
     1395    TPM_CMD_CODE_INIT(         TPM2_CC_SHUTDOWN,                         NULL,                                          NULL,                               vboxTraceLogDecodeEvtTpmDecodeStartupShutdownReq,               NULL),
    9981396    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_STIR_RANDOM),
    9991397    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ACTIVATE_CREDENTIAL),
    10001398    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CERTIFY),
    10011399    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_NV),
    1002     TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CERTIFY_CREATION),
     1400    TPM_CMD_CODE_INIT(         TPM2_CC_CERTIFY_CREATION,                 g_apszHandlesCertifyCreationReq,               NULL,                               vboxTraceLogDecodeEvtTpmDecodeCertifyCreationReq,               vboxTraceLogDecodeEvtTpmDecodeCertifyCreationResp),
    10031401    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_DUPLICATE),
    10041402    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_GET_TIME),
    10051403    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_GET_SESSION_AUDIT_DIGEST),
    1006     TPM_CMD_CODE_INIT(         TPM2_CC_NV_READ,                          TPMREQHDR,             TPMRESPHDR,             vboxTraceLogDecodeEvtTpmDecodeNvReadReq,            vboxTraceLogDecodeEvtTpmDecodeNvReadResp),
     1404    TPM_CMD_CODE_INIT(         TPM2_CC_NV_READ,                          g_apszHandlesNvReadReq,                        NULL,                               vboxTraceLogDecodeEvtTpmDecodeNvReadReq,                        vboxTraceLogDecodeEvtTpmDecodeNvReadResp),
    10071405    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_READ_LOCK),
    10081406    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_OBJECT_CHANGE_AUTH),
    1009     TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_SECRET),
     1407    TPM_CMD_CODE_INIT(         TPM2_CC_POLICY_SECRET,                    g_apszHandlesPolicySecretReq,                  NULL,                               vboxTraceLogDecodeEvtTpmDecodePolicySecretReq,                  vboxTraceLogDecodeEvtTpmDecodePolicySecretResp),
    10101408    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_REWRAP),
    1011     TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CREATE),
     1409    TPM_CMD_CODE_INIT(         TPM2_CC_CREATE,                           g_apszHandlesCreateReq,                        NULL,                               vboxTraceLogDecodeEvtTpmDecodeCreateReq,                        vboxTraceLogDecodeEvtTpmDecodeCreateResp),
    10121410    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ECDH_ZGEN),
    1013     TPM_CMD_CODE_INIT(         TPM2_CC_HMAC_MAC,                         TPMREQHDR,            TPMRESPHDR,             vboxTraceLogDecodeEvtTpmDecodeHmacMacReq,            vboxTraceLogDecodeEvtTpmDecodeHmacMacResp),
     1411    TPM_CMD_CODE_INIT(         TPM2_CC_HMAC_MAC,                         g_apszHandlesHmacMacReq,                       NULL,                               vboxTraceLogDecodeEvtTpmDecodeHmacMacReq,                       vboxTraceLogDecodeEvtTpmDecodeHmacMacResp),
    10141412    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_IMPORT),
    1015     TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_LOAD),
    1016     TPM_CMD_CODE_INIT(         TPM2_CC_QUOTE,                            TPMREQHDR,            TPMRESPHDR,             vboxTraceLogDecodeEvtTpmDecodeQuoteReq,              vboxTraceLogDecodeEvtTpmDecodeQuoteResp),
     1413    TPM_CMD_CODE_INIT(         TPM2_CC_LOAD,                             g_apszHandlesLoadReq,                          g_apszHandlesLoadResp,              vboxTraceLogDecodeEvtTpmDecodeLoadReq,                          vboxTraceLogDecodeEvtTpmDecodeLoadResp),
     1414    TPM_CMD_CODE_INIT(         TPM2_CC_QUOTE,                            g_apszHandlesQuoteReq,                         NULL,                               vboxTraceLogDecodeEvtTpmDecodeQuoteReq,                         vboxTraceLogDecodeEvtTpmDecodeQuoteResp),
    10171415    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_RSA_DECRYPT),
    10181416    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_HMAC_MAC_START),
    … …  
    10251423    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ECDH_KEY_GEN),
    10261424    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ENCRYPT_DECRYPT),
    1027     TPM_CMD_CODE_INIT(         TPM2_CC_FLUSH_CONTEXT,                     TPMREQHDR,            TPMRESPHDR,             vboxTraceLogDecodeEvtTpmDecodeFlushContextReq,      NULL),
     1425    TPM_CMD_CODE_INIT(         TPM2_CC_FLUSH_CONTEXT,                     g_apszHandlesFlushContextReq,                 NULL,                               NULL,                                                           NULL),
    10281426    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_LOAD_EXTERNAL),
    10291427    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_MAKE_CREDENTIAL),
    1030     TPM_CMD_CODE_INIT(         TPM2_CC_NV_READ_PUBLIC,                    TPMREQHDR,            TPMRESPHDR,             vboxTraceLogDecodeEvtTpmDecodeNvReadPublicReq,      vboxTraceLogDecodeEvtTpmDecodeNvReadPublicResp),
     1428    TPM_CMD_CODE_INIT(         TPM2_CC_NV_READ_PUBLIC,                    g_apszHandlesNvReadPublicReq,                 NULL,                               NULL,                                                           vboxTraceLogDecodeEvtTpmDecodeNvReadPublicResp),
    10311429    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_AUTHORIZE),
    10321430    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_AUTH_VALUE),
    … …  
    10381436    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_OR),
    10391437    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_TICKET),
    1040     TPM_CMD_CODE_INIT(         TPM2_CC_READ_PUBLIC,                      TPM2REQREADPUBLIC,     TPMRESPHDR,             vboxTraceLogDecodeEvtTpmDecodeReadPublicReq,        vboxTraceLogDecodeEvtTpmDecodeReadPublicResp),
     1438    TPM_CMD_CODE_INIT(         TPM2_CC_READ_PUBLIC,                      g_apszHandlesReadPublicReq,                    NULL,                               NULL,                                                           vboxTraceLogDecodeEvtTpmDecodeReadPublicResp),
    10411439    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_RSA_ENCRYPT),
    1042     TPM_CMD_CODE_INIT(         TPM2_CC_START_AUTH_SESSION,               TPMREQHDR,             TPMRESPHDR,             vboxTraceLogDecodeEvtTpmDecodeStartAuthSessionReq,  vboxTraceLogDecodeEvtTpmDecodeStartAuthSessionResp),
     1440    TPM_CMD_CODE_INIT(         TPM2_CC_START_AUTH_SESSION,               g_apszHandlesStartAuthSessionReq,              g_apszHandlesStartAuthSessionResp,  vboxTraceLogDecodeEvtTpmDecodeStartAuthSessionReq,              vboxTraceLogDecodeEvtTpmDecodeStartAuthSessionResp),
    10431441    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_VERIFY_SIGNATURE),
    1044     TPM_CMD_CODE_INIT(         TPM2_CC_ECC_PARAMETERS,                   TPMREQHDR,             TPMRESPHDR,             vboxTraceLogDecodeEvtTpmDecodeEccParametersReq,     vboxTraceLogDecodeEvtTpmDecodeEccParametersResp),
     1442    TPM_CMD_CODE_INIT(         TPM2_CC_ECC_PARAMETERS,                   NULL,                                          NULL,                               vboxTraceLogDecodeEvtTpmDecodeEccParametersReq,                 vboxTraceLogDecodeEvtTpmDecodeEccParametersResp),
    10451443    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_FIRMWARE_READ),
    1046     TPM_CMD_CODE_INIT(         TPM2_CC_GET_CAPABILITY,                   TPM2REQGETCAPABILITY,  TPM2RESPGETCAPABILITY,  vboxTraceLogDecodeEvtTpmDecodeGetCapabilityReq,     vboxTraceLogDecodeEvtTpmDecodeGetCapabilityResp),
    1047     TPM_CMD_CODE_INIT(         TPM2_CC_GET_RANDOM,                       TPM2REQGETRANDOM,      TPM2RESPGETRANDOM,      vboxTraceLogDecodeEvtTpmDecodeGetRandomReq,         vboxTraceLogDecodeEvtTpmDecodeGetRandomResp),
     1444    TPM_CMD_CODE_INIT(         TPM2_CC_GET_CAPABILITY,                   NULL,                                          NULL,                               vboxTraceLogDecodeEvtTpmDecodeGetCapabilityReq,                 vboxTraceLogDecodeEvtTpmDecodeGetCapabilityResp),
     1445    TPM_CMD_CODE_INIT(         TPM2_CC_GET_RANDOM,                       NULL,                                          NULL,                               vboxTraceLogDecodeEvtTpmDecodeGetRandomReq,                     vboxTraceLogDecodeEvtTpmDecodeGetRandomResp),
    10481446    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_GET_TEST_RESULT),
    10491447    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_GET_HASH),
    1050     TPM_CMD_CODE_INIT(         TPM2_CC_PCR_READ,                         TPMREQHDR,             TPMRESPHDR,             vboxTraceLogDecodeEvtTpmDecodePcrReadReq,           vboxTraceLogDecodeEvtTpmDecodePcrReadResp),
     1448    TPM_CMD_CODE_INIT(         TPM2_CC_PCR_READ,                         NULL,                                          NULL,                               vboxTraceLogDecodeEvtTpmDecodePcrReadReq,                       vboxTraceLogDecodeEvtTpmDecodePcrReadResp),
    10511449    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_PCR),
    10521450    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_RESTART),
    1053     TPM_CMD_CODE_INIT(         TPM2_CC_READ_CLOCK,                       TPMREQHDR,             TPMRESPHDR,             NULL,                                               vboxTraceLogDecodeEvtTpmDecodeReadClockResp),
    1054     TPM_CMD_CODE_INIT(         TPM2_CC_PCR_EXTEND,                       TPMREQHDR,             TPMRESPHDR,             vboxTraceLogDecodeEvtTpmDecodePcrExtendReq,         NULL),
     1451    TPM_CMD_CODE_INIT(         TPM2_CC_READ_CLOCK,                       NULL,                                          NULL,                               NULL,                                                           vboxTraceLogDecodeEvtTpmDecodeReadClockResp),
     1452    TPM_CMD_CODE_INIT(         TPM2_CC_PCR_EXTEND,                       g_apszHandlesPcrExtendReq,                     NULL,                               vboxTraceLogDecodeEvtTpmDecodePcrExtendReq,                     NULL),
    10551453    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PCR_SET_AUTH_VALUE),
    10561454    TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_CERTIFY),
    … …  
    10901488    if (cbCmd >= sizeof(*pHdr))
    10911489    {
     1490        uint16_t  u16Tag       = RT_BE2H_U16(pHdr->u16Tag);
    10921491        uint32_t  u32CmdCode   = RT_BE2H_U32(pHdr->u32Ordinal);
    10931492        uint32_t  cbReqPayload = RT_BE2H_U32(pHdr->cbReq) - sizeof(*pHdr);
    … …  
    11101509            {
    11111510                pHlp->pfnPrintf(pHlp, "    %s (%u bytes):\n", s_aTpmCmdCodes[i].pszCmdCode, cbReqPayload);
     1511                pHlp->pfnPrintf(pHlp, "    u16Tag:      %#x\n", u16Tag);
     1512
     1513
     1514                TPMDECODECTX Ctx;
     1515                PTPMDECODECTX pCtx = &Ctx;
     1516                vboxTraceLogDecodeEvtTpmDecodeCtxInit(&Ctx, (const uint8_t *)(pHdr + 1), cbReqPayload);
     1517
     1518                /* Decode the handle area. */
     1519                if (s_aTpmCmdCodes[i].papszHandlesReq)
     1520                {
     1521                    pHlp->pfnPrintf(pHlp, "    Handles:\n");
     1522
     1523                    const char **papszHnd = s_aTpmCmdCodes[i].papszHandlesReq;
     1524                    while (*papszHnd)
     1525                    {
     1526                        TPM_DECODE_U32(u32Hnd, u32Hnd);
     1527                        pHlp->pfnPrintf(pHlp, "       %s: %#x\n", *papszHnd, u32Hnd);
     1528                        papszHnd++;
     1529                    }
     1530                }
     1531
     1532                /* Decode authorization area if available. */
     1533                if (u16Tag == TPM2_ST_SESSIONS)
     1534                {
     1535                    pHlp->pfnPrintf(pHlp, "    Authorization Area:\n");
     1536                    vboxTraceLogDecodeEvtTpmAuthSessionReq(pHlp, pCtx);
     1537                }
     1538
     1539                /* Decode parameters. */
    11121540                if (s_aTpmCmdCodes[i].pfnDecodeReq)
    11131541                {
    1114                     if (cbCmd >= s_aTpmCmdCodes[i].cbReqMin)
    1115                     {
    1116                         TPMDECODECTX Ctx;
    1117                         vboxTraceLogDecodeEvtTpmDecodeCtxInit(&Ctx, (const uint8_t *)(pHdr + 1), cbReqPayload);
    1118                         s_aTpmCmdCodes[i].pfnDecodeReq(pHlp, pTpmState, &Ctx);
    1119                     }
    1120                     else
    1121                         pHlp->pfnErrorMsg(pHlp, "Malformed %s command, not enough room for the input\n", s_aTpmCmdCodes[i].pszCmdCode);
     1542                    pHlp->pfnPrintf(pHlp, "    Parameters:\n");
     1543                    s_aTpmCmdCodes[i].pfnDecodeReq(pHlp, pTpmState, &Ctx);
    11221544                }
    1123                 else if (cbReqPayload)
    1124                     pHlp->pfnPrintf(pHlp, "%.*Rhxd\n", cbReqPayload, pHdr + 1);
     1545
     1546                if (pCtx->cbLeft)
     1547                    pHlp->pfnPrintf(pHlp, "    Leftover undecoded data:\n"
     1548                                          "%.*Rhxd\n", pCtx->cbLeft, pCtx->pbBuf);
    11251549                return;
    11261550            }
    … …  
    11451569        uint32_t cbRespPayload = RT_BE2H_U32(pHdr->cbResp) - sizeof(*pHdr);
    11461570        uint32_t u32ErrCode    = RT_BE2H_U32(pHdr->u32ErrCode);
     1571        uint16_t u16Tag        = RT_BE2H_U16(pHdr->u16Tag);
    11471572
    11481573        pHlp->pfnPrintf(pHlp, "    Status code: %#x (%u bytes)\n", u32ErrCode, cbRespPayload);
     1574        pHlp->pfnPrintf(pHlp, "    u16Tag:      %#x\n", u16Tag);
    11491575        PTPMSTATE pTpmState = (PTPMSTATE)pHlp->pfnDecoderStateGet(pHlp);
    11501576
    … …  
    11531579            && u32ErrCode == TPM_SUCCESS)
    11541580        {
     1581            TPMDECODECTX Ctx;
     1582            PTPMDECODECTX pCtx = &Ctx;
     1583            vboxTraceLogDecodeEvtTpmDecodeCtxInit(&Ctx, (const uint8_t *)(pHdr + 1), cbRespPayload);
     1584
    11551585            for (uint32_t i = 0; i < RT_ELEMENTS(s_aTpmCmdCodes); i++)
    11561586            {
    11571587                if (s_aTpmCmdCodes[i].u32CmdCode == pTpmState->u32CmdCode)
    11581588                {
     1589                    /* Decode the handle area. */
     1590                    if (s_aTpmCmdCodes[i].papszHandlesResp)
     1591                    {
     1592                        pHlp->pfnPrintf(pHlp, "    Handles:\n");
     1593
     1594                        const char **papszHnd = s_aTpmCmdCodes[i].papszHandlesResp;
     1595                        while (*papszHnd)
     1596                        {
     1597                            TPM_DECODE_U32(u32Hnd, u32Hnd);
     1598                            pHlp->pfnPrintf(pHlp, "       %s: %#x\n", *papszHnd, u32Hnd);
     1599                            papszHnd++;
     1600                        }
     1601                    }
     1602
     1603                    if (u16Tag == TPM2_ST_SESSIONS)
     1604                    {
     1605                        TPM_DECODE_INIT();
     1606                            TPM_DECODE_U32(u32ParamSz, u32ParamSize);
     1607                            pHlp->pfnPrintf(pHlp, "    u32ParamSize: %#x\n", u32ParamSz);
     1608                        TPM_DECODE_END();
     1609                    }
     1610
     1611                    /* Decode parameters. */
    11591612                    if (s_aTpmCmdCodes[i].pfnDecodeResp)
     1613                        s_aTpmCmdCodes[i].pfnDecodeResp(pHlp, pTpmState, pCtx);
     1614
     1615                    /* Decode authorization area if available. */
     1616                    if (u16Tag == TPM2_ST_SESSIONS)
    11601617                    {
    1161                         if (cbResp >= s_aTpmCmdCodes[i].cbRespMin)
    1162                         {
    1163                             TPMDECODECTX Ctx;
    1164                             vboxTraceLogDecodeEvtTpmDecodeCtxInit(&Ctx, (const uint8_t *)(pHdr + 1), cbRespPayload);
    1165                             s_aTpmCmdCodes[i].pfnDecodeResp(pHlp, pTpmState, &Ctx);
    1166                         }
    1167                         else
    1168                             pHlp->pfnErrorMsg(pHlp, "Malformed %s response buffer, not enough room for the output\n", s_aTpmCmdCodes[i].pszCmdCode);
    1169                         return;
     1618                        pHlp->pfnPrintf(pHlp, "    Authorization Area:\n");
     1619                        vboxTraceLogDecodeEvtTpmAuthSessionResp(pHlp, pCtx);
    11701620                    }
    1171                     break;
     1621
     1622                    if (pCtx->cbLeft)
     1623                        pHlp->pfnPrintf(pHlp, "    Leftover undecoded data:\n"
     1624                                              "%.*Rhxd\n", pCtx->cbLeft, pCtx->pbBuf);
     1625
     1626                    return;
    11721627                }
    11731628            }
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