VirtualBox

source: vbox/trunk/src/VBox/Devices/Trace/VBoxTraceLogDecoders.cpp@ 104973

Last change on this file since 104973 was 104973, checked in by vboxsync, 11 months ago

Devices/Trace: Updates to the TPM trace decoding, bugref:10701
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 73.8 KB
Line 
1/* $Id: VBoxTraceLogDecoders.cpp 104973 2024-06-20 09:25:36Z vboxsync $ */
2/** @file
3 * RTTraceLogDecoders - Implement decoders for the tracing driver.
4 */
5
6/*
7 * Copyright (C) 2024 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * SPDX-License-Identifier: GPL-3.0-only
26 */
27
28
29/*********************************************************************************************************************************
30* Header Files *
31*********************************************************************************************************************************/
32#define LOG_GROUP RTLOGGROUP_DEFAULT
33#include <iprt/assert.h>
34#include <iprt/errcore.h>
35#include <iprt/log.h>
36#include <iprt/tracelog-decoder-plugin.h>
37
38#include <iprt/formats/tpm.h>
39
40
41/*********************************************************************************************************************************
42* Structures and Typedefs *
43*********************************************************************************************************************************/
44
45/**
46 * TPM decoder context.
47 */
48typedef struct TPMDECODECTX
49{
50 /** Pointer to the next data item. */
51 const uint8_t *pbBuf;
52 /** Number of bytes left for the buffer. */
53 size_t cbLeft;
54 /** Flag whether an error was encountered. */
55 bool fError;
56} TPMDECODECTX;
57/** Pointer to a TPM decoder context. */
58typedef TPMDECODECTX *PTPMDECODECTX;
59
60
61/**
62 * Algorithm ID to string mapping.
63 */
64typedef struct TPMALGID2STR
65{
66 uint16_t u16AlgId;
67 const char *pszAlgId;
68 size_t cbDigest;
69} TPMALGID2STR;
70typedef const TPMALGID2STR *PCTPMALGID2STR;
71
72
73/**
74 * The TPM state.
75 */
76typedef struct TPMSTATE
77{
78 /** Command code. */
79 uint32_t u32CmdCode;
80 /** Command code dependent state. */
81 union
82 {
83 /** TPM2_CC_GET_CAPABILITY related state. */
84 struct
85 {
86 /** The capability group to query. */
87 uint32_t u32Cap;
88 /** Property to query. */
89 uint32_t u32Property;
90 /** Number of values to return. */
91 uint32_t u32Count;
92 } GetCapability;
93 /** TPM2_GET_RANDOM related state. */
94 struct
95 {
96 /** Number of bytes of random data to produce. */
97 uint16_t cbRnd;
98 } GetRandom;
99 } u;
100} TPMSTATE;
101typedef TPMSTATE *PTPMSTATE;
102
103
104/**
105 */
106typedef DECLCALLBACKTYPE(void, FNDECODETPM2CCREQ, (PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx));
107/** Pointer to an event decode request callback. */
108typedef FNDECODETPM2CCREQ *PFNFNDECODETPM2CCREQ;
109
110
111/**
112 */
113typedef DECLCALLBACKTYPE(void, FNDECODETPM2CCRESP, (PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx));
114/** Pointer to an event decode request callback. */
115typedef FNDECODETPM2CCRESP *PFNFNDECODETPM2CCRESP;
116
117
118/*********************************************************************************************************************************
119* Static Variables *
120*********************************************************************************************************************************/
121
122/**
123 * Algorithm ID to string mapping array.
124 */
125static const RTTRACELOGDECODERSTRUCTBLDENUM g_aAlgId2Str[] =
126{
127#define TPM_ALGID_2_STR(a_AlgId) { a_AlgId, #a_AlgId, 0 }
128#define TPM_ALGID_2_STR_DIGEST(a_AlgId, a_cbDigest) { a_AlgId, #a_AlgId, a_cbDigest }
129
130 TPM_ALGID_2_STR(TPM2_ALG_ERROR),
131 TPM_ALGID_2_STR(TPM2_ALG_RSA),
132 TPM_ALGID_2_STR(TPM2_ALG_TDES),
133 TPM_ALGID_2_STR_DIGEST(TPM2_ALG_SHA1, 20),
134 TPM_ALGID_2_STR(TPM2_ALG_HMAC),
135 TPM_ALGID_2_STR(TPM2_ALG_AES),
136 TPM_ALGID_2_STR(TPM2_ALG_MGF1),
137 TPM_ALGID_2_STR(TPM2_ALG_KEYEDHASH),
138 TPM_ALGID_2_STR(TPM2_ALG_XOR),
139 TPM_ALGID_2_STR_DIGEST(TPM2_ALG_SHA256, 32),
140 TPM_ALGID_2_STR_DIGEST(TPM2_ALG_SHA384, 48),
141 TPM_ALGID_2_STR_DIGEST(TPM2_ALG_SHA512, 64),
142 TPM_ALGID_2_STR_DIGEST(TPM2_ALG_SHA256_192, 24),
143 TPM_ALGID_2_STR(TPM2_ALG_NULL),
144 TPM_ALGID_2_STR(TPM2_ALG_SM3_256),
145 TPM_ALGID_2_STR(TPM2_ALG_SM4),
146 TPM_ALGID_2_STR(TPM2_ALG_RSASSA),
147 TPM_ALGID_2_STR(TPM2_ALG_RSAES),
148 TPM_ALGID_2_STR(TPM2_ALG_RSAPSS),
149 TPM_ALGID_2_STR(TPM2_ALG_OAEP),
150 TPM_ALGID_2_STR(TPM2_ALG_ECDSA),
151 TPM_ALGID_2_STR(TPM2_ALG_ECDH),
152 TPM_ALGID_2_STR(TPM2_ALG_ECDAA),
153 TPM_ALGID_2_STR(TPM2_ALG_SM2),
154 TPM_ALGID_2_STR(TPM2_ALG_ECSCHNORR),
155 TPM_ALGID_2_STR(TPM2_ALG_ECMQV),
156 TPM_ALGID_2_STR(TPM2_ALG_KDF1_SP800_56A),
157 TPM_ALGID_2_STR(TPM2_ALG_KDF2),
158 TPM_ALGID_2_STR(TPM2_ALG_KDF1_SP800_108),
159 TPM_ALGID_2_STR(TPM2_ALG_ECC),
160 TPM_ALGID_2_STR(TPM2_ALG_SYMCIPHER),
161 TPM_ALGID_2_STR(TPM2_ALG_CAMELLIA),
162 TPM_ALGID_2_STR_DIGEST(TPM2_ALG_SHA3_256, 32),
163 TPM_ALGID_2_STR_DIGEST(TPM2_ALG_SHA3_384, 48),
164 TPM_ALGID_2_STR_DIGEST(TPM2_ALG_SHA3_512, 64),
165 TPM_ALGID_2_STR(TPM2_ALG_SHAKE128),
166 TPM_ALGID_2_STR(TPM2_ALG_SHAKE256),
167 TPM_ALGID_2_STR(TPM2_ALG_SHAKE256_192),
168 TPM_ALGID_2_STR(TPM2_ALG_SHAKE256_256),
169 TPM_ALGID_2_STR(TPM2_ALG_SHAKE256_512),
170 TPM_ALGID_2_STR(TPM2_ALG_CMAC),
171 TPM_ALGID_2_STR(TPM2_ALG_CTR),
172 TPM_ALGID_2_STR(TPM2_ALG_OFB),
173 TPM_ALGID_2_STR(TPM2_ALG_CBC),
174 TPM_ALGID_2_STR(TPM2_ALG_CFB),
175 TPM_ALGID_2_STR(TPM2_ALG_ECB),
176 TPM_ALGID_2_STR(TPM2_ALG_CCM),
177 TPM_ALGID_2_STR(TPM2_ALG_GCM),
178 TPM_ALGID_2_STR(TPM2_ALG_KW),
179 TPM_ALGID_2_STR(TPM2_ALG_KWP),
180 TPM_ALGID_2_STR(TPM2_ALG_EAX),
181 TPM_ALGID_2_STR(TPM2_ALG_EDDSA),
182 TPM_ALGID_2_STR(TPM2_ALG_EDDSA_PH),
183 TPM_ALGID_2_STR(TPM2_ALG_LMS),
184 TPM_ALGID_2_STR(TPM2_ALG_XMSS),
185 TPM_ALGID_2_STR(TPM2_ALG_KEYEDXOF),
186 TPM_ALGID_2_STR(TPM2_ALG_KMACXOF128),
187 TPM_ALGID_2_STR(TPM2_ALG_KMACXOF256),
188 TPM_ALGID_2_STR(TPM2_ALG_KMAC128),
189 TPM_ALGID_2_STR(TPM2_ALG_KMAC256),
190 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_TERM
191#undef TPM_ALGID_2_STR
192};
193
194
195/*********************************************************************************************************************************
196* Internal Functions *
197*********************************************************************************************************************************/
198
199DECLINLINE(void) vboxTraceLogDecodeEvtTpmDecodeCtxInit(PTPMDECODECTX pCtx, const uint8_t *pbBuf, size_t cbBuf)
200{
201 pCtx->pbBuf = pbBuf;
202 pCtx->cbLeft = cbBuf;
203 pCtx->fError = false;
204}
205
206
207static uint8_t vboxTraceLogDecodeEvtTpmDecodeCtxGetU8(PTPMDECODECTX pCtx, PRTTRACELOGDECODERHLP pHlp, const char *pszItem)
208{
209 if (RT_UNLIKELY(pCtx->fError))
210 return 0;
211
212 if (RT_UNLIKELY(!pCtx->cbLeft))
213 {
214 pHlp->pfnErrorMsg(pHlp, "Failed to decode '%s' as there is not enough space in the buffer (required %u, available %u)",
215 pszItem, sizeof(uint8_t), pCtx->cbLeft);
216 AssertFailed();
217 pCtx->fError = true;
218 return 0;
219 }
220
221 pCtx->cbLeft--;
222 return *pCtx->pbBuf++;
223}
224
225
226static uint16_t vboxTraceLogDecodeEvtTpmDecodeCtxGetU16(PTPMDECODECTX pCtx, PRTTRACELOGDECODERHLP pHlp, const char *pszItem)
227{
228 if (RT_UNLIKELY(pCtx->fError))
229 return 0;
230
231 if (RT_UNLIKELY(pCtx->cbLeft < sizeof(uint16_t)))
232 {
233 pHlp->pfnErrorMsg(pHlp, "Failed to decode '%s' as there is not enough space in the buffer (required %u, available %u)",
234 pszItem, sizeof(uint16_t), pCtx->cbLeft);
235 AssertFailed();
236 pCtx->fError = true;
237 return 0;
238 }
239
240 uint16_t u16 = *(uint16_t *)pCtx->pbBuf;
241 pCtx->pbBuf += sizeof(uint16_t);
242 pCtx->cbLeft -= sizeof(uint16_t);
243 return RT_BE2H_U16(u16);
244}
245
246
247static uint32_t vboxTraceLogDecodeEvtTpmDecodeCtxGetU32(PTPMDECODECTX pCtx, PRTTRACELOGDECODERHLP pHlp, const char *pszItem)
248{
249 if (RT_UNLIKELY(pCtx->fError))
250 return 0;
251
252 if (RT_UNLIKELY(pCtx->cbLeft < sizeof(uint32_t)))
253 {
254 pHlp->pfnErrorMsg(pHlp, "Failed to decode '%s' as there is not enough space in the buffer (required %u, available %u)",
255 pszItem, sizeof(uint32_t), pCtx->cbLeft);
256 AssertFailed();
257 pCtx->fError = true;
258 return 0;
259 }
260
261 uint32_t u32 = *(uint32_t *)pCtx->pbBuf;
262 pCtx->pbBuf += sizeof(uint32_t);
263 pCtx->cbLeft -= sizeof(uint32_t);
264 return RT_BE2H_U32(u32);
265}
266
267
268static int32_t vboxTraceLogDecodeEvtTpmDecodeCtxGetI32(PTPMDECODECTX pCtx, PRTTRACELOGDECODERHLP pHlp, const char *pszItem)
269{
270 return (int32_t)vboxTraceLogDecodeEvtTpmDecodeCtxGetU32(pCtx, pHlp, pszItem);
271}
272
273
274static uint64_t vboxTraceLogDecodeEvtTpmDecodeCtxGetU64(PTPMDECODECTX pCtx, PRTTRACELOGDECODERHLP pHlp, const char *pszItem)
275{
276 if (RT_UNLIKELY(pCtx->fError))
277 return 0;
278
279 if (RT_UNLIKELY(pCtx->cbLeft < sizeof(uint64_t)))
280 {
281 pHlp->pfnErrorMsg(pHlp, "Failed to decode '%s' as there is not enough space in the buffer (required %u, available %u)",
282 pszItem, sizeof(uint64_t), pCtx->cbLeft);
283 AssertFailed();
284 pCtx->fError = true;
285 return 0;
286 }
287
288 uint64_t u64 = *(uint64_t *)pCtx->pbBuf;
289 pCtx->pbBuf += sizeof(uint64_t);
290 pCtx->cbLeft -= sizeof(uint64_t);
291 return RT_BE2H_U64(u64);
292}
293
294
295static const uint8_t *vboxTraceLogDecodeEvtTpmDecodeCtxGetBuf(PTPMDECODECTX pCtx, PRTTRACELOGDECODERHLP pHlp, const char *pszItem, size_t cbBuf)
296{
297 if (RT_UNLIKELY(pCtx->fError))
298 return 0;
299
300 if (RT_UNLIKELY(pCtx->cbLeft < cbBuf))
301 {
302 pHlp->pfnErrorMsg(pHlp, "Failed to decode '%s' as there is not enough space in the buffer (required %u, available %u)",
303 pszItem, cbBuf, pCtx->cbLeft);
304 AssertFailed();
305 pCtx->fError = true;
306 return 0;
307 }
308
309 /* Just return nothing if nothing is requested. */
310 if (!cbBuf)
311 return NULL;
312
313 const uint8_t *pb = pCtx->pbBuf;
314 pCtx->pbBuf += cbBuf;
315 pCtx->cbLeft -= cbBuf;
316 return pb;
317}
318
319
320static size_t vboxTraceLogDecodeEvtTpmAlgId2DigestSize(uint16_t u16AlgId)
321{
322 for (uint32_t i = 0; i < RT_ELEMENTS(g_aAlgId2Str); i++)
323 if (g_aAlgId2Str[i].u64EnumVal == u16AlgId)
324 return g_aAlgId2Str[i].uPtrUser;
325
326 return 0;
327}
328
329
330#define TPM_DECODE_INIT() do {
331
332#define TPM_DECODE_END() \
333 } while (0); \
334 if (pCtx->fError) return
335
336#define TPM_DECODE_BOOL(a_Var, a_Name) \
337 uint8_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU8(pCtx, pHlp, #a_Name); \
338 if (pCtx->fError) break; \
339 pHlp->pfnStructBldAddBool(pHlp, #a_Name, 0 /*fFlags*/, RT_BOOL(a_Var))
340
341#define TPM_DECODE_U8(a_Var, a_Name) \
342 uint8_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU8(pCtx, pHlp, #a_Name); \
343 if (pCtx->fError) break; \
344 pHlp->pfnStructBldAddU8(pHlp, #a_Name, 0 /*fFlags*/, a_Var)
345
346#define TPM_DECODE_U16(a_Var, a_Name) \
347 uint16_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU16(pCtx, pHlp, #a_Name); \
348 if (pCtx->fError) break; \
349 pHlp->pfnStructBldAddU16(pHlp, #a_Name, 0 /*fFlags*/, a_Var)
350
351#define TPM_DECODE_U32(a_Var, a_Name) \
352 uint32_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU32(pCtx, pHlp, #a_Name); \
353 if (pCtx->fError) break; \
354 pHlp->pfnStructBldAddU32(pHlp, #a_Name, 0 /*fFlags*/, a_Var)
355
356#define TPM_DECODE_U64(a_Var, a_Name) \
357 uint64_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU64(pCtx, pHlp, #a_Name); \
358 if (pCtx->fError) break; \
359 pHlp->pfnStructBldAddU64(pHlp, #a_Name, 0 /*fFlags*/, a_Var)
360
361#define TPM_DECODE_I32(a_Var, a_Name) \
362 int32_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetI32(pCtx, pHlp, #a_Name); \
363 if (pCtx->fError) break; \
364 pHlp->pfnStructBldAddS32(pHlp, #a_Name, 0 /*fFlags*/, a_Var)
365
366#define TPM_DECODE_U8_HEX(a_Var, a_Name) \
367 uint8_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU8(pCtx, pHlp, #a_Name); \
368 if (pCtx->fError) break; \
369 pHlp->pfnStructBldAddU8(pHlp, #a_Name, RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX, a_Var)
370
371#define TPM_DECODE_U16_HEX(a_Var, a_Name) \
372 uint16_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU16(pCtx, pHlp, #a_Name); \
373 if (pCtx->fError) break; \
374 pHlp->pfnStructBldAddU16(pHlp, #a_Name, RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX, a_Var)
375
376#define TPM_DECODE_U32_HEX(a_Var, a_Name) \
377 uint32_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU32(pCtx, pHlp, #a_Name); \
378 if (pCtx->fError) break; \
379 pHlp->pfnStructBldAddU32(pHlp, #a_Name, RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX, a_Var)
380
381#define TPM_DECODE_U32_HEX_STR(a_Var, a_pszName) \
382 uint32_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU32(pCtx, pHlp, a_pszName); \
383 if (pCtx->fError) break; \
384 pHlp->pfnStructBldAddU32(pHlp, a_pszName, RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX, a_Var)
385
386#define TPM_DECODE_U64_HEX(a_Var, a_Name) \
387 uint64_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU64(pCtx, pHlp, #a_Name); \
388 if (pCtx->fError) break; \
389 pHlp->pfnStructBldAddU64(pHlp, #a_Name, RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX, a_Var)
390
391#define TPM_DECODE_I32_HEX(a_Var, a_Name) \
392 int32_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetI32(pCtx, pHlp, #a_Name); \
393 if (pCtx->fError) break; \
394 pHlp->pfnStructBldAddS32(pHlp, #a_Name, 0 /*fFlags*/, a_Var)
395
396#define TPM_DECODE_BUF_EX(a_Var, a_Name, a_cb) \
397 const uint8_t *a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetBuf(pCtx, pHlp, #a_Name, a_cb); \
398 if (pCtx->fError) break
399
400#define TPM_DECODE_BUF(a_Var, a_Name, a_cb) \
401 const uint8_t *a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetBuf(pCtx, pHlp, #a_Name, a_cb); \
402 if (pCtx->fError) break; \
403 if (a_Var) \
404 pHlp->pfnStructBldAddBuf(pHlp, #a_Name, 0 /*fFlags*/, a_Var, a_cb);
405
406#define TPM_DECODE_BUF_HEX_STRING(a_Var, a_Name, a_cb) \
407 const uint8_t *a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetBuf(pCtx, pHlp, #a_Name, a_cb); \
408 if (pCtx->fError) break; \
409 if (a_Var) \
410 pHlp->pfnStructBldAddBuf(pHlp, #a_Name, RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX_DUMP_STR, a_Var, a_cb);
411
412#define TPM_DECODE_U16_ENUM(a_Var, a_Name, a_aEnums) \
413 uint16_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU16(pCtx, pHlp, #a_Name); \
414 if (pCtx->fError) break; \
415 pHlp->pfnStructBldAddEnum(pHlp, #a_Name, RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX, 16, a_aEnums, a_Var)
416
417#define TPM_DECODE_U32_ENUM(a_Var, a_Name, a_aEnums) \
418 uint32_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU32(pCtx, pHlp, #a_Name); \
419 if (pCtx->fError) break; \
420 pHlp->pfnStructBldAddEnum(pHlp, #a_Name, RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX, 32, a_aEnums, a_Var)
421
422#define TPM_DECODE_BUF_STR(a_Var, a_pszName, a_cb) \
423 const uint8_t *a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetBuf(pCtx, pHlp, a_pszName, a_cb); \
424 if (pCtx->fError) break; \
425 if (a_Var) \
426 pHlp->pfnStructBldAddBuf(pHlp, a_pszName, 0 /*fFlags*/, a_Var, a_cb);
427
428#define TPM_DECODE_END_IF_ERROR() \
429 if (pCtx->fError) return
430
431static void vboxTraceLogDecodePcrSelection(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx)
432{
433 TPM_DECODE_INIT();
434 TPM_DECODE_U16_ENUM(u16AlgId, u16AlgId, g_aAlgId2Str );
435 TPM_DECODE_U8( cbPcrSelection, u8SizeOfSelect );
436 TPM_DECODE_BUF_EX( pb, PCRs, cbPcrSelection);
437
438 pHlp->pfnStructBldArrayBegin(pHlp, "PCRs");
439
440 for (uint8_t idxPcr = 0; idxPcr < cbPcrSelection * 8; idxPcr++)
441 if (RT_BOOL(*(pb + (idxPcr / 8)) & RT_BIT(idxPcr % 8)))
442 pHlp->pfnStructBldAddU8(pHlp, NULL, 0 /*fFlags*/, idxPcr);
443
444 pHlp->pfnStructBldArrayEnd(pHlp);
445
446 TPM_DECODE_END();
447}
448
449
450static void vboxTraceLogDecodePcrSelectionList(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx)
451{
452 TPM_DECODE_INIT();
453 TPM_DECODE_U32(u32Count, u32Count);
454
455 pHlp->pfnStructBldBegin(pHlp, "aPcrSelection");
456
457 /* Walk the list of PCR selection entries. */
458 for (uint32_t i = 0; i < u32Count; i++)
459 {
460 vboxTraceLogDecodePcrSelection(pHlp, pCtx);
461 TPM_DECODE_END_IF_ERROR();
462 }
463
464 pHlp->pfnStructBldEnd(pHlp);
465
466 TPM_DECODE_END();
467}
468
469
470static void vboxTraceLogDecodeEvtTpmDigestList(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx)
471{
472 TPM_DECODE_INIT();
473 TPM_DECODE_U32(u32DigestCount, u32DigestCount);
474
475 pHlp->pfnStructBldBegin(pHlp, "aDigests");
476
477 for (uint32_t i = 0; i < u32DigestCount; i++)
478 {
479 TPM_DECODE_U16(u16DigestSize, u16DigestSize);
480 TPM_DECODE_BUF_HEX_STRING(pbDigest, abDigest, u16DigestSize);
481 }
482
483 pHlp->pfnStructBldEnd(pHlp);
484
485 TPM_DECODE_END();
486}
487
488
489static void vboxTraceLogDecodeEvtTpmDigestValuesList(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx)
490{
491 TPM_DECODE_INIT();
492 TPM_DECODE_U32(u32DigestCount, u32DigestCount);
493
494 pHlp->pfnStructBldBegin(pHlp, "aDigests");
495
496 for (uint32_t i = 0; i < u32DigestCount; i++)
497 {
498 TPM_DECODE_U16_ENUM(u16HashAlg, u16HashAlg, g_aAlgId2Str);
499
500 size_t cbDigest = vboxTraceLogDecodeEvtTpmAlgId2DigestSize(u16HashAlg);
501 TPM_DECODE_BUF_HEX_STRING(pb, abDigest, cbDigest);
502 }
503
504 pHlp->pfnStructBldEnd(pHlp);
505
506 TPM_DECODE_END();
507}
508
509
510static void vboxTraceLogDecodeEvtTpmAuthSessionReq(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx)
511{
512 TPM_DECODE_INIT();
513 TPM_DECODE_U32_HEX(u32SessionHandle, u32SessionHandle);
514 TPM_DECODE_U16( u16NonceSize, u16NonceSize);
515 TPM_DECODE_BUF( pbNonce, abNonce, u16NonceSize);
516 TPM_DECODE_U8( u8Attr, u8Attr);
517 TPM_DECODE_U16( u16HmacSize, u16HmacSize);
518 TPM_DECODE_BUF( pbHmac, abHmac, u16HmacSize);
519 TPM_DECODE_END();
520}
521
522
523static void vboxTraceLogDecodeEvtTpmAuthSessionResp(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx)
524{
525 pHlp->pfnStructBldBegin(pHlp, "AuthArea");
526 TPM_DECODE_INIT();
527 TPM_DECODE_U16(u16NonceSize, u16NonceSize);
528 TPM_DECODE_BUF(pbNonce, abNonce, u16NonceSize);
529 TPM_DECODE_U8( u8Attr, u8Attr);
530 TPM_DECODE_U16(u16AckSize, u16AckSize);
531 TPM_DECODE_BUF(pbAck, abAck, u16AckSize);
532 TPM_DECODE_END();
533 pHlp->pfnStructBldEnd(pHlp);
534}
535
536
537static void vboxTraceLogDecodeSizedBufU16(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx, const char *pszName)
538{
539 pHlp->pfnStructBldBegin(pHlp, pszName);
540 TPM_DECODE_INIT();
541 TPM_DECODE_U16(u16Size, u16Size);
542 if (u16Size)
543 {
544 TPM_DECODE_BUF_STR(pb, pszName, u16Size);
545 }
546 TPM_DECODE_END();
547 pHlp->pfnStructBldEnd(pHlp);
548}
549
550
551static void vboxTraceLogDecodeSymEncDef(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx, const char *pszName)
552{
553 pHlp->pfnStructBldBegin(pHlp, pszName);
554 TPM_DECODE_INIT();
555 TPM_DECODE_U16_ENUM(u16HashAlg, u16HashAlg, g_aAlgId2Str);
556 if (u16HashAlg != TPM2_ALG_NULL)
557 {
558 TPM_DECODE_U16(u16KeyBits, u16KeyBits);
559 TPM_DECODE_U16_ENUM(u16SymMode, u16SymMode, g_aAlgId2Str);
560 /* Symmetric details are not required as of now. */
561 }
562 TPM_DECODE_END();
563 pHlp->pfnStructBldEnd(pHlp);
564}
565
566
567static void vboxTraceLogDecodeNvPublic(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx, const char *pszName)
568{
569 pHlp->pfnStructBldBegin(pHlp, pszName);
570 TPM_DECODE_INIT();
571 TPM_DECODE_U16(u16Size, u16Size);
572 if (u16Size)
573 {
574 TPM_DECODE_U32_HEX(hNvIndex, hNvIndex);
575 TPM_DECODE_U16(u16HashAlgName, u16HashAlgName);
576 TPM_DECODE_U32(u32Attr, fAttr);
577 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "AuthPolicy");
578 TPM_DECODE_U16(u16DataSize, u16DataSize);
579 }
580 TPM_DECODE_END();
581 pHlp->pfnStructBldEnd(pHlp);
582}
583
584
585static void vboxTraceLogDecodeTicket(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx, const char *pszName)
586{
587 pHlp->pfnStructBldBegin(pHlp, pszName);
588 TPM_DECODE_INIT();
589 TPM_DECODE_U16_HEX(u16Tag, u16Tag);
590 TPM_DECODE_U32_HEX(hHierarchy, hHierarchy);
591 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Digest");
592 TPM_DECODE_END();
593 pHlp->pfnStructBldEnd(pHlp);
594}
595
596
597static void vboxTraceLogDecode_TPMT_SIGNATURE(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx, const char *pszName)
598{
599 pHlp->pfnStructBldBegin(pHlp, pszName);
600 TPM_DECODE_INIT();
601 TPM_DECODE_U16_ENUM(u16SigningAlg, u16SigningAlg, g_aAlgId2Str);
602 if (u16SigningAlg != TPM2_ALG_NULL)
603 {
604 TPM_DECODE_U16_ENUM(u16HashAlg, u16HashAlg, g_aAlgId2Str);
605 }
606 TPM_DECODE_END();
607 pHlp->pfnStructBldEnd(pHlp);
608}
609
610
611static void vboxTraceLogDecode_TPMT_SIG_SCHEME(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx, const char *pszName)
612{
613 pHlp->pfnStructBldBegin(pHlp, pszName);
614 TPM_DECODE_INIT();
615 TPM_DECODE_U16_ENUM(u16Scheme, u16Scheme, g_aAlgId2Str);
616 if (u16Scheme != TPM2_ALG_NULL)
617 {
618 TPM_DECODE_U16_ENUM(u16HashAlg, u16HashAlg, g_aAlgId2Str);
619 }
620 TPM_DECODE_END();
621 pHlp->pfnStructBldEnd(pHlp);
622}
623
624
625static void vboxTraceLogDecode_TPML_DIGEST(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx, const char *pszName)
626{
627 pHlp->pfnStructBldBegin(pHlp, pszName);
628 TPM_DECODE_INIT();
629 TPM_DECODE_U32(u32Count, u32Count);
630 for (uint32_t i = 0; i < u32Count; i++)
631 {
632 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Digest");
633 TPM_DECODE_END_IF_ERROR();
634 }
635 TPM_DECODE_END();
636 pHlp->pfnStructBldEnd(pHlp);
637}
638
639
640static void vboxTraceLogDecode_TPMS_CONTEXT(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx, const char *pszName)
641{
642 pHlp->pfnStructBldBegin(pHlp, pszName);
643 TPM_DECODE_INIT();
644 TPM_DECODE_U64( u64Sequence, u64Sequence);
645 TPM_DECODE_U32_HEX(hSaved, hSaved);
646 TPM_DECODE_U32_HEX(hHierarchy, hHierarchy);
647 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "ContextBlob");
648 TPM_DECODE_END();
649 pHlp->pfnStructBldEnd(pHlp);
650}
651
652
653static const char *g_apszHandlesEvictControlReq[] =
654{
655 "hAuth",
656 "hObj",
657 NULL
658};
659
660static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeEvictControlReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
661{
662 RT_NOREF(pThis);
663
664 TPM_DECODE_INIT();
665 TPM_DECODE_U32_HEX(hPersistent, hPersistent);
666 TPM_DECODE_END();
667}
668
669
670static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeSelfTestReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
671{
672 RT_NOREF(pThis);
673
674 TPM_DECODE_INIT();
675 TPM_DECODE_BOOL(fFullTest, fFullTest);
676 TPM_DECODE_END();
677}
678
679
680static RTTRACELOGDECODERSTRUCTBLDENUM g_aStartupShutdownParam[] =
681{
682 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_SU_CLEAR),
683 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_SU_STATE)
684};
685
686static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeStartupShutdownReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
687{
688 RT_NOREF(pThis);
689
690 TPM_DECODE_INIT();
691 TPM_DECODE_U16_ENUM(u16TpmSu, u16State, g_aStartupShutdownParam);
692 TPM_DECODE_END();
693}
694
695
696static RTTRACELOGDECODERSTRUCTBLDENUM g_aTpm2Caps[] =
697{
698 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_CAP_ALGS),
699 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_CAP_HANDLES),
700 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_CAP_COMMANDS),
701 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_CAP_PP_COMMANDS),
702 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_CAP_AUDIT_COMMANDS),
703 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_CAP_PCRS),
704 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_CAP_TPM_PROPERTIES),
705 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_CAP_PCR_PROPERTIES),
706 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_CAP_ECC_CURVES),
707 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_CAP_AUTH_POLICIES),
708 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_CAP_ACT),
709 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_TERM
710};
711
712static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeGetCapabilityReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
713{
714 TPM_DECODE_INIT();
715 TPM_DECODE_U32_ENUM(u32Cap, u32Cap, g_aTpm2Caps);
716 TPM_DECODE_U32_HEX( u32Property, u32Property );
717 TPM_DECODE_U32( u32Count, u32Count );
718
719 pThis->u.GetCapability.u32Cap = u32Cap;
720 pThis->u.GetCapability.u32Property = u32Property;
721 pThis->u.GetCapability.u32Count = u32Count;
722 TPM_DECODE_END();
723}
724
725
726static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeGetCapabilityResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
727{
728 RT_NOREF(pThis);
729
730 TPM_DECODE_INIT();
731 TPM_DECODE_BOOL( fMoreData, fMoreData);
732 TPM_DECODE_U32_ENUM(u32Cap, u32Cap, g_aTpm2Caps);
733
734 switch (u32Cap)
735 {
736 case TPM2_CAP_PCRS:
737 {
738 vboxTraceLogDecodePcrSelectionList(pHlp, pCtx);
739 break;
740 }
741 case TPM2_CAP_TPM_PROPERTIES:
742 {
743 TPM_DECODE_U32(u32Count, u32Count);
744 pHlp->pfnStructBldBegin(pHlp, "aProperties");
745 for (uint32_t i = 0; i < u32Count; i++)
746 {
747 TPM_DECODE_U32_HEX(u32Property, u32Property);
748 TPM_DECODE_U32_HEX(u32Value, u32Value);
749 }
750 pHlp->pfnStructBldEnd(pHlp);
751 break;
752 }
753 case TPM2_CAP_COMMANDS:
754 {
755 TPM_DECODE_U32(u32Count, u32Count);
756 pHlp->pfnStructBldBegin(pHlp, "aCommands");
757 for (uint32_t i = 0; i < u32Count; i++)
758 {
759 TPM_DECODE_U32_HEX(u32CmdCode, u32CmdCode);
760 }
761 pHlp->pfnStructBldEnd(pHlp);
762 break;
763 }
764 case TPM2_CAP_HANDLES:
765 {
766 TPM_DECODE_U32(u32Count, u32Count);
767 pHlp->pfnStructBldBegin(pHlp, "aCommands");
768 for (uint32_t i = 0; i < u32Count; i++)
769 {
770 TPM_DECODE_U32_HEX(u32Handle, u32Handle);
771 }
772 pHlp->pfnStructBldEnd(pHlp);
773 break;
774 }
775 default:
776 break;
777 }
778 TPM_DECODE_END();
779}
780
781
782static const char *g_apszHandlesReadPublicReq[] =
783{
784 "hObj",
785 NULL
786};
787
788
789static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeReadPublicResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
790{
791 RT_NOREF(pThis);
792
793 TPM_DECODE_INIT();
794 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "OutPublic");
795 TPM_DECODE_END_IF_ERROR();
796 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Name");
797 TPM_DECODE_END_IF_ERROR();
798 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "QualifiedName");
799 TPM_DECODE_END_IF_ERROR();
800 TPM_DECODE_END();
801}
802
803
804static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeGetRandomReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
805{
806 TPM_DECODE_INIT();
807 TPM_DECODE_U16(u16RandomBytes, u16RandomBytes);
808 pThis->u.GetRandom.cbRnd = u16RandomBytes;
809 TPM_DECODE_END();
810}
811
812
813static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeGetRandomResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
814{
815 TPM_DECODE_INIT();
816 TPM_DECODE_U16(cbBuf, u16Size);
817 if (pThis->u.GetRandom.cbRnd != cbBuf)
818 {
819 pHlp->pfnErrorMsg(pHlp, "Requested random data size doesn't match returned data size (requested %u, returned %u), using smaller value\n",
820 pThis->u.GetRandom.cbRnd, cbBuf);
821 cbBuf = RT_MIN(cbBuf, pThis->u.GetRandom.cbRnd);
822 }
823
824 TPM_DECODE_BUF(pb, RndBuf, cbBuf);
825 TPM_DECODE_END();
826}
827
828
829static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodePcrReadReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
830{
831 RT_NOREF(pThis);
832
833 TPM_DECODE_INIT();
834 vboxTraceLogDecodePcrSelectionList(pHlp, pCtx);
835 TPM_DECODE_END();
836}
837
838
839static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodePcrReadResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
840{
841 RT_NOREF(pThis);
842
843 TPM_DECODE_INIT();
844 TPM_DECODE_U32(u32PcrUpdateCounter, u32PcrUpdateCounter);
845 vboxTraceLogDecodePcrSelectionList(pHlp, pCtx);
846 TPM_DECODE_END_IF_ERROR();
847 vboxTraceLogDecodeEvtTpmDigestList(pHlp, pCtx);
848 TPM_DECODE_END();
849}
850
851
852static const char *g_apszHandlesPcrExtendReq[] =
853{
854 "hPcr",
855 NULL
856};
857
858
859static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodePcrExtendReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
860{
861 RT_NOREF(pThis);
862
863 TPM_DECODE_INIT();
864 vboxTraceLogDecodeEvtTpmDigestValuesList(pHlp, pCtx);
865 TPM_DECODE_END();
866}
867
868
869static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeReadClockResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
870{
871 RT_NOREF(pThis);
872
873 TPM_DECODE_INIT();
874 TPM_DECODE_U64(u64Time, u64Time);
875
876 /* Decode TPMS_CLOCK_INFO. */
877 TPM_DECODE_U64( u64Clock, u64Clock);
878 TPM_DECODE_U32( u32ResetCount, u32ResetCount);
879 TPM_DECODE_U32( u32RestartCount, u32RestartCount);
880 TPM_DECODE_BOOL(fSafe, fSafe);
881 TPM_DECODE_END();
882}
883
884
885static const char *g_apszHandlesContextLoadResp[] =
886{
887 "hLoaded",
888 NULL
889};
890
891
892static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeContextLoadReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
893{
894 RT_NOREF(pThis);
895
896 TPM_DECODE_INIT();
897 vboxTraceLogDecode_TPMS_CONTEXT(pHlp, pCtx, "Context");
898 TPM_DECODE_END();
899}
900
901
902static const char *g_apszHandlesContextSaveReq[] =
903{
904 "hSave",
905 NULL
906};
907
908
909static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeContextSaveResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
910{
911 RT_NOREF(pThis);
912
913 TPM_DECODE_INIT();
914 vboxTraceLogDecode_TPMS_CONTEXT(pHlp, pCtx, "Context");
915 TPM_DECODE_END();
916}
917
918
919static const char *g_apszHandlesNvReadPublicReq[] =
920{
921 "hNvIndex",
922 NULL
923};
924
925
926static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeNvReadPublicResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
927{
928 RT_NOREF(pThis);
929
930 TPM_DECODE_INIT();
931 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "NvPublic");
932 TPM_DECODE_END();
933}
934
935
936static const char *g_apszHandlesStartAuthSessionReq[] =
937{
938 "hTpmKey",
939 "hBind",
940 NULL
941};
942
943
944static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeStartAuthSessionReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
945{
946 RT_NOREF(pThis);
947
948 TPM_DECODE_INIT();
949 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "NonceCaller");
950 TPM_DECODE_END_IF_ERROR();
951 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "EncryptedSalt");
952 TPM_DECODE_END_IF_ERROR();
953
954 TPM_DECODE_U8_HEX(u8SessionType, u8SessionType);
955
956 vboxTraceLogDecodeSymEncDef(pHlp, pCtx, "Symmetric");
957 TPM_DECODE_END_IF_ERROR();
958
959 TPM_DECODE_U16_ENUM(u16HashAlg, u16HashAlg, g_aAlgId2Str);
960 TPM_DECODE_END();
961}
962
963
964static const char *g_apszHandlesStartAuthSessionResp[] =
965{
966 "hSession",
967 NULL
968};
969
970
971static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeStartAuthSessionResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
972{
973 RT_NOREF(pThis);
974
975 TPM_DECODE_INIT();
976 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "NonceTpm");
977 TPM_DECODE_END();
978}
979
980
981static const char *g_apszHandlesClearReq[] =
982{
983 "hAuth",
984 NULL
985};
986
987
988static const char *g_apszHandlesHierarchyChangeAuthReq[] =
989{
990 "hAuth",
991 NULL
992};
993
994static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeHierarchyChangeAuthReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
995{
996 RT_NOREF(pThis);
997
998 TPM_DECODE_INIT();
999 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "NewAuth");
1000 TPM_DECODE_END();
1001}
1002
1003
1004static const char *g_apszHandlesNvDefineSpaceReq[] =
1005{
1006 "hAuth",
1007 NULL
1008};
1009
1010static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeNvDefineSpaceReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1011{
1012 RT_NOREF(pThis);
1013
1014 TPM_DECODE_INIT();
1015 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Auth");
1016 TPM_DECODE_END_IF_ERROR();
1017
1018 vboxTraceLogDecodeNvPublic(pHlp, pCtx, "PublicInfo");
1019 TPM_DECODE_END();
1020}
1021
1022
1023static const char *g_apszHandlesSetPrimaryPolicyReq[] =
1024{
1025 "hAuth",
1026 NULL
1027};
1028
1029static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeSetPrimaryPolicyReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1030{
1031 RT_NOREF(pThis);
1032
1033 TPM_DECODE_INIT();
1034 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "AuthPolicy");
1035 TPM_DECODE_END_IF_ERROR();
1036
1037 TPM_DECODE_U16_ENUM(u16HashAlg, u16HashAlg, g_aAlgId2Str);
1038 TPM_DECODE_END();
1039}
1040
1041
1042static const char *g_apszHandlesCreatePrimaryReq[] =
1043{
1044 "hPrimary",
1045 NULL
1046};
1047
1048static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeCreatePrimaryReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1049{
1050 RT_NOREF(pThis);
1051
1052 TPM_DECODE_INIT();
1053 /** @todo Decode InSensitive. */
1054 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "InSensitive");
1055 TPM_DECODE_END_IF_ERROR();
1056 /** @todo Decode InPublic. */
1057 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "InPublic");
1058 TPM_DECODE_END_IF_ERROR();
1059
1060 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "OutsideInfo");
1061 TPM_DECODE_END_IF_ERROR();
1062
1063 vboxTraceLogDecodePcrSelectionList(pHlp, pCtx);
1064
1065 TPM_DECODE_END();
1066}
1067
1068
1069static const char *g_apszHandlesCreatePrimaryResp[] =
1070{
1071 "hObj",
1072 NULL
1073};
1074
1075
1076static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeCreatePrimaryResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1077{
1078 RT_NOREF(pThis);
1079
1080 TPM_DECODE_INIT();
1081 /** @todo Decode OutPublic. */
1082 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "OutPublic");
1083 TPM_DECODE_END_IF_ERROR();
1084 /** @todo Decode CreationData. */
1085 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "CreationData");
1086 TPM_DECODE_END_IF_ERROR();
1087
1088 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "CreationHash");
1089 TPM_DECODE_END_IF_ERROR();
1090
1091 vboxTraceLogDecodeTicket(pHlp, pCtx, "Ticket");
1092 TPM_DECODE_END_IF_ERROR();
1093
1094 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Name");
1095 TPM_DECODE_END();
1096}
1097
1098
1099static const char *g_apszHandlesNvIncrementReq[] =
1100{
1101 "hAuth",
1102 "hNvIndex",
1103 NULL
1104};
1105
1106
1107static const char *g_apszHandlesNvSetBitsReq[] =
1108{
1109 "hAuth",
1110 "hNvIndex",
1111 NULL
1112};
1113
1114static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeNvSetBitsReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1115{
1116 RT_NOREF(pThis);
1117
1118 TPM_DECODE_INIT();
1119 TPM_DECODE_U64_HEX(u64BitsOr, u64BitsOr);
1120 TPM_DECODE_END();
1121}
1122
1123
1124static const char *g_apszHandlesNvWriteReq[] =
1125{
1126 "hAuth",
1127 "hNvIndex",
1128 NULL
1129};
1130
1131static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeNvWriteReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1132{
1133 RT_NOREF(pThis);
1134
1135 TPM_DECODE_INIT();
1136 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Data");
1137 TPM_DECODE_END_IF_ERROR();
1138
1139 TPM_DECODE_U16(u16Offset, u16Offset);
1140 TPM_DECODE_END();
1141}
1142
1143
1144static const char *g_apszHandlesDictionaryAttackParametersReq[] =
1145{
1146 "hLock",
1147 NULL
1148};
1149
1150static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeDictionaryAttackParametersReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1151{
1152 RT_NOREF(pThis);
1153
1154 TPM_DECODE_INIT();
1155 TPM_DECODE_U32(u32NewMaxTries, u32NewMaxTries);
1156 TPM_DECODE_U32(u32NewRecoveryTime, u32NewRecoveryTime);
1157 TPM_DECODE_U32(u32LockoutRecovery, u32LockoutRecovery);
1158 TPM_DECODE_END();
1159}
1160
1161
1162static const char *g_apszHandlesCertifyReq[] =
1163{
1164 "hSign",
1165 "hObj",
1166 NULL
1167};
1168
1169static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeCertifyReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1170{
1171 RT_NOREF(pThis);
1172
1173 TPM_DECODE_INIT();
1174 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "QualifyingData");
1175 TPM_DECODE_END_IF_ERROR();
1176
1177 /* Decode TPMT_SIG_SCHEME+ */
1178 TPM_DECODE_U16_ENUM(u16SigningScheme, u16SigningScheme, g_aAlgId2Str);
1179 if (u16SigningScheme != TPM2_ALG_NULL)
1180 {
1181 TPM_DECODE_U16_ENUM(u16HashAlg, u16HashAlg, g_aAlgId2Str);
1182 }
1183 TPM_DECODE_END();
1184}
1185
1186
1187static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeCertifyResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1188{
1189 RT_NOREF(pThis);
1190
1191 TPM_DECODE_INIT();
1192 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "CertifyInfo");
1193 vboxTraceLogDecode_TPMT_SIGNATURE(pHlp, pCtx, "Signature");
1194 TPM_DECODE_END();
1195}
1196
1197
1198static const char *g_apszHandlesCertifyCreationReq[] =
1199{
1200 "hSign",
1201 "hObj",
1202 NULL
1203};
1204
1205static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeCertifyCreationReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1206{
1207 RT_NOREF(pThis);
1208
1209 TPM_DECODE_INIT();
1210 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "QualifyingData");
1211 TPM_DECODE_END_IF_ERROR();
1212 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "CreationHash");
1213 TPM_DECODE_END_IF_ERROR();
1214
1215 TPM_DECODE_U16_ENUM(u16SigningScheme, u16SigningScheme, g_aAlgId2Str);
1216 vboxTraceLogDecodeTicket(pHlp, pCtx, "CreationTicket");
1217 TPM_DECODE_END();
1218}
1219
1220
1221static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeCertifyCreationResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1222{
1223 RT_NOREF(pThis);
1224
1225 TPM_DECODE_INIT();
1226 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "CertifyInfo");
1227 vboxTraceLogDecode_TPMT_SIGNATURE(pHlp, pCtx, "Signature");
1228 TPM_DECODE_END();
1229}
1230
1231
1232static const char *g_apszHandlesNvReadReq[] =
1233{
1234 "hAuth",
1235 "hNvIndex",
1236 NULL
1237};
1238
1239static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeNvReadReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1240{
1241 RT_NOREF(pThis);
1242
1243 TPM_DECODE_INIT();
1244 TPM_DECODE_U16(u16Size, u16Size);
1245 TPM_DECODE_U16(u16Offset, u16Offset);
1246 TPM_DECODE_END();
1247}
1248
1249
1250static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeNvReadResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1251{
1252 RT_NOREF(pThis);
1253
1254 TPM_DECODE_INIT();
1255 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Data");
1256 TPM_DECODE_END();
1257}
1258
1259
1260static const char *g_apszHandlesPolicySecretReq[] =
1261{
1262 "hAuth",
1263 "hPolicySession",
1264 NULL
1265};
1266
1267static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodePolicySecretReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1268{
1269 RT_NOREF(pThis);
1270
1271 TPM_DECODE_INIT();
1272 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "NonceTpm");
1273 TPM_DECODE_END_IF_ERROR();
1274 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "CpHashA");
1275 TPM_DECODE_END_IF_ERROR();
1276 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "PolicyRef");
1277 TPM_DECODE_END_IF_ERROR();
1278
1279 TPM_DECODE_I32(i32Expiration, i32Expiration);
1280 TPM_DECODE_END();
1281}
1282
1283
1284static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodePolicySecretResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1285{
1286 RT_NOREF(pThis);
1287
1288 TPM_DECODE_INIT();
1289 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Timeout");
1290 TPM_DECODE_END_IF_ERROR();
1291
1292 vboxTraceLogDecodeTicket(pHlp, pCtx, "Ticket");
1293 TPM_DECODE_END();
1294}
1295
1296
1297static const char *g_apszHandlesCreateReq[] =
1298{
1299 "hParent",
1300 NULL
1301};
1302
1303static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeCreateReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1304{
1305 RT_NOREF(pThis);
1306
1307 TPM_DECODE_INIT();
1308 /** @todo Decode InSensitive. */
1309 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "InSensitive");
1310 TPM_DECODE_END_IF_ERROR();
1311 /** @todo Decode InPublic. */
1312 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "InPublic");
1313 TPM_DECODE_END_IF_ERROR();
1314
1315 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "OutsideInfo");
1316 TPM_DECODE_END_IF_ERROR();
1317
1318 vboxTraceLogDecodePcrSelectionList(pHlp, pCtx);
1319
1320 TPM_DECODE_END();
1321}
1322
1323
1324static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeCreateResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1325{
1326 RT_NOREF(pThis);
1327
1328 TPM_DECODE_INIT();
1329 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "OutPrivate");
1330 TPM_DECODE_END_IF_ERROR();
1331 /** @todo Decode OutPublic. */
1332 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "OutPublic");
1333 TPM_DECODE_END_IF_ERROR();
1334 /** @todo Decode CreationData. */
1335 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "CreationData");
1336 TPM_DECODE_END_IF_ERROR();
1337
1338 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "CreationHash");
1339 TPM_DECODE_END_IF_ERROR();
1340
1341 vboxTraceLogDecodeTicket(pHlp, pCtx, "Ticket");
1342 TPM_DECODE_END();
1343}
1344
1345
1346static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeEccParametersReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1347{
1348 RT_NOREF(pThis);
1349
1350 TPM_DECODE_INIT();
1351 TPM_DECODE_U16(u16CurveId, u16CurveId);
1352 TPM_DECODE_END();
1353}
1354
1355
1356static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeEccParametersResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1357{
1358 RT_NOREF(pThis);
1359
1360 TPM_DECODE_INIT();
1361 TPM_DECODE_U16_HEX( u16CurveId, u16CurveId);
1362 TPM_DECODE_U16( u16KeySize, u16KeySize);
1363 TPM_DECODE_U16_ENUM(u16KdfScheme, u16KdfScheme, g_aAlgId2Str);
1364 TPM_DECODE_U16_ENUM(u16KdfSchemeHash, u16KdfSchemeHash, g_aAlgId2Str);
1365 TPM_DECODE_U16_ENUM(u16EccScheme, u16EccScheme, g_aAlgId2Str);
1366 if (u16EccScheme != TPM2_ALG_NULL)
1367 {
1368 TPM_DECODE_U16_ENUM(u16EccSchemeHash, u16EccSchemeHash, g_aAlgId2Str);
1369 }
1370 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "p");
1371 TPM_DECODE_END_IF_ERROR();
1372 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "a");
1373 TPM_DECODE_END_IF_ERROR();
1374 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "b");
1375 TPM_DECODE_END_IF_ERROR();
1376 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "gX");
1377 TPM_DECODE_END_IF_ERROR();
1378 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "gY");
1379 TPM_DECODE_END_IF_ERROR();
1380 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "n");
1381 TPM_DECODE_END_IF_ERROR();
1382 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "h");
1383 TPM_DECODE_END_IF_ERROR();
1384 TPM_DECODE_END();
1385}
1386
1387
1388static const char *g_apszHandlesQuoteReq[] =
1389{
1390 "hSign",
1391 NULL
1392};
1393
1394
1395static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeQuoteReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1396{
1397 RT_NOREF(pThis);
1398
1399 TPM_DECODE_INIT();
1400 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "QualifyingData");
1401 TPM_DECODE_END_IF_ERROR();
1402
1403 TPM_DECODE_U16_ENUM(u16SigScheme, u16SigScheme, g_aAlgId2Str);
1404 if (u16SigScheme != TPM2_ALG_NULL)
1405 {
1406 TPM_DECODE_U16_ENUM(u16SigSchemeHash, u16SigSchemeHash, g_aAlgId2Str);
1407 }
1408
1409 vboxTraceLogDecodePcrSelectionList(pHlp, pCtx);
1410 TPM_DECODE_END();
1411}
1412
1413
1414static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeQuoteResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1415{
1416 RT_NOREF(pThis);
1417
1418 TPM_DECODE_INIT();
1419 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Quoted");
1420 TPM_DECODE_END_IF_ERROR();
1421 vboxTraceLogDecode_TPMT_SIGNATURE(pHlp, pCtx, "Signature");
1422 TPM_DECODE_END();
1423}
1424
1425
1426static const char *g_apszHandlesSignReq[] =
1427{
1428 "hKey",
1429 NULL
1430};
1431
1432
1433static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeSignReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1434{
1435 RT_NOREF(pThis);
1436
1437 TPM_DECODE_INIT();
1438 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Digest");
1439 TPM_DECODE_END_IF_ERROR();
1440
1441 vboxTraceLogDecode_TPMT_SIG_SCHEME(pHlp, pCtx, "InScheme");
1442 vboxTraceLogDecodeTicket(pHlp, pCtx, "Validation"); /* TPMT_TK_HASHCHECK */
1443 TPM_DECODE_END();
1444}
1445
1446
1447static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeSignResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1448{
1449 RT_NOREF(pThis);
1450
1451 TPM_DECODE_INIT();
1452 vboxTraceLogDecode_TPMT_SIGNATURE(pHlp, pCtx, "Signature");
1453 TPM_DECODE_END();
1454}
1455
1456
1457static const char *g_apszHandlesHmacMacReq[] =
1458{
1459 "hSymKey",
1460 NULL
1461};
1462
1463
1464static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeHmacMacReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1465{
1466 RT_NOREF(pThis);
1467
1468 TPM_DECODE_INIT();
1469 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Buffer");
1470 TPM_DECODE_END_IF_ERROR();
1471
1472 TPM_DECODE_U16_ENUM(u16HashAlg, u16HashAlg, g_aAlgId2Str);
1473 TPM_DECODE_END();
1474}
1475
1476
1477static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeHmacMacResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1478{
1479 RT_NOREF(pThis);
1480
1481 TPM_DECODE_INIT();
1482 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "OutHmacMac");
1483 TPM_DECODE_END();
1484}
1485
1486
1487static const char *g_apszHandlesFlushContextReq[] =
1488{
1489 "hFlush",
1490 NULL
1491};
1492
1493
1494static const char *g_apszHandlesImportReq[] =
1495{
1496 "hParent",
1497 NULL
1498};
1499
1500
1501static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeImportReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1502{
1503 RT_NOREF(pThis);
1504
1505 TPM_DECODE_INIT();
1506 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "EncryptionKey");
1507 TPM_DECODE_END_IF_ERROR();
1508 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "ObjectPublic");
1509 TPM_DECODE_END_IF_ERROR();
1510 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Duplicate");
1511 TPM_DECODE_END_IF_ERROR();
1512 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "InSymSeed");
1513 TPM_DECODE_END_IF_ERROR();
1514 vboxTraceLogDecodeSymEncDef(pHlp, pCtx, "SymmetricAlg");
1515 TPM_DECODE_END();
1516}
1517
1518
1519static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeImportResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1520{
1521 RT_NOREF(pThis);
1522
1523 TPM_DECODE_INIT();
1524 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "OutPrivate");
1525 TPM_DECODE_END_IF_ERROR();
1526 TPM_DECODE_END();
1527}
1528
1529
1530static const char *g_apszHandlesLoadReq[] =
1531{
1532 "hParent",
1533 NULL
1534};
1535
1536
1537static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeLoadReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1538{
1539 RT_NOREF(pThis);
1540
1541 TPM_DECODE_INIT();
1542 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "InPrivate");
1543 TPM_DECODE_END_IF_ERROR();
1544 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "InPublic");
1545 TPM_DECODE_END_IF_ERROR();
1546 TPM_DECODE_END();
1547}
1548
1549
1550static const char *g_apszHandlesLoadResp[] =
1551{
1552 "hObj",
1553 NULL
1554};
1555
1556
1557static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeLoadResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1558{
1559 RT_NOREF(pThis);
1560
1561 TPM_DECODE_INIT();
1562 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Name");
1563 TPM_DECODE_END_IF_ERROR();
1564 TPM_DECODE_END();
1565}
1566
1567
1568static const char *g_apszHandlesPolicyGetDigestReq[] =
1569{
1570 "hPolicySession",
1571 NULL
1572};
1573
1574
1575static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodePolicyGetDigestResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1576{
1577 RT_NOREF(pThis);
1578
1579 TPM_DECODE_INIT();
1580 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "PolicyDigest");
1581 TPM_DECODE_END();
1582}
1583
1584
1585static const char *g_apszHandlesPolicyAuthValueReq[] =
1586{
1587 "hPolicySession",
1588 NULL
1589};
1590
1591
1592static const char *g_apszHandlesPolicyCommandCodeReq[] =
1593{
1594 "hPolicySession",
1595 NULL
1596};
1597
1598
1599static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodePolicyCommandCodeReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1600{
1601 RT_NOREF(pThis);
1602
1603 TPM_DECODE_INIT();
1604 TPM_DECODE_U32_HEX(u32CmdCode, u32CmdCode);
1605 TPM_DECODE_END();
1606}
1607
1608
1609static const char *g_apszHandlesPolicyOrReq[] =
1610{
1611 "hPolicySession",
1612 NULL
1613};
1614
1615
1616static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodePolicyOrReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1617{
1618 RT_NOREF(pThis);
1619
1620 TPM_DECODE_INIT();
1621 vboxTraceLogDecode_TPML_DIGEST(pHlp, pCtx, "HashList");
1622 TPM_DECODE_END();
1623}
1624
1625
1626static struct
1627{
1628 uint32_t u32CmdCode;
1629 const char *pszCmdCode;
1630 const char **papszHandlesReq;
1631 const char **papszHandlesResp;
1632 PFNFNDECODETPM2CCREQ pfnDecodeReq;
1633 PFNFNDECODETPM2CCRESP pfnDecodeResp;
1634} s_aTpmCmdCodes[] =
1635{
1636#define TPM_CMD_CODE_INIT_NOT_IMPL(a_CmdCode) { a_CmdCode, #a_CmdCode, NULL, NULL, NULL, NULL }
1637#define TPM_CMD_CODE_INIT(a_CmdCode, a_apszHandlesReq, a_apszHandlesResp, a_pfnReq, a_pfnResp) { a_CmdCode, #a_CmdCode, \
1638 a_apszHandlesReq, a_apszHandlesResp, \
1639 a_pfnReq, a_pfnResp }
1640 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_UNDEFINE_SPACE_SPECIAL),
1641 TPM_CMD_CODE_INIT( TPM2_CC_EVICT_CONTROL, g_apszHandlesEvictControlReq, NULL, vboxTraceLogDecodeEvtTpmDecodeEvictControlReq, NULL),
1642 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_HIERARCHY_CONTROL),
1643 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_UNDEFINE_SPACE),
1644 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CHANGE_EPS),
1645 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CHANGE_PPS),
1646 TPM_CMD_CODE_INIT( TPM2_CC_CLEAR, g_apszHandlesClearReq, NULL, NULL, NULL),
1647 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CLEAR_CONTROL),
1648 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CLOCK_SET),
1649 TPM_CMD_CODE_INIT( TPM2_CC_HIERARCHY_CHANGE_AUTH, g_apszHandlesHierarchyChangeAuthReq, NULL, vboxTraceLogDecodeEvtTpmDecodeHierarchyChangeAuthReq, NULL),
1650 TPM_CMD_CODE_INIT( TPM2_CC_NV_DEFINE_SPACE, g_apszHandlesNvDefineSpaceReq, NULL, vboxTraceLogDecodeEvtTpmDecodeNvDefineSpaceReq, NULL),
1651 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PCR_ALLOCATE),
1652 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PCR_SET_AUTH_POLICY),
1653 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PP_COMMANDS),
1654 TPM_CMD_CODE_INIT( TPM2_CC_SET_PRIMARY_POLICY, g_apszHandlesSetPrimaryPolicyReq, NULL, vboxTraceLogDecodeEvtTpmDecodeSetPrimaryPolicyReq, NULL),
1655 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_FIELD_UPGRADE_START),
1656 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CLOCK_RATE_ADJUST),
1657 TPM_CMD_CODE_INIT( TPM2_CC_CREATE_PRIMARY, g_apszHandlesCreatePrimaryReq, g_apszHandlesCreatePrimaryResp, vboxTraceLogDecodeEvtTpmDecodeCreatePrimaryReq, vboxTraceLogDecodeEvtTpmDecodeCreatePrimaryResp),
1658 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_GLOBAL_WRITE_LOCK),
1659 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_GET_COMMAND_AUDIT_DIGEST),
1660 TPM_CMD_CODE_INIT( TPM2_CC_NV_INCREMENT, g_apszHandlesNvIncrementReq, NULL, NULL, NULL),
1661 TPM_CMD_CODE_INIT( TPM2_CC_NV_SET_BITS, g_apszHandlesNvSetBitsReq, NULL, vboxTraceLogDecodeEvtTpmDecodeNvSetBitsReq, NULL),
1662 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_EXTEND),
1663 TPM_CMD_CODE_INIT( TPM2_CC_NV_WRITE, g_apszHandlesNvWriteReq, NULL, vboxTraceLogDecodeEvtTpmDecodeNvWriteReq, NULL),
1664 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_WRITE_LOCK),
1665 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_DICTIONARY_ATTACK_LOCK_RESET),
1666 TPM_CMD_CODE_INIT( TPM2_CC_DICTIONARY_ATTACK_PARAMETERS, g_apszHandlesDictionaryAttackParametersReq, NULL, vboxTraceLogDecodeEvtTpmDecodeDictionaryAttackParametersReq, NULL),
1667 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_CHANGE_AUTH),
1668 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PCR_EVENT),
1669 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PCR_RESET),
1670 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_SEQUENCE_COMPLETE),
1671 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_SET_ALGORITHM_SET),
1672 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_SET_COMMAND_CODE_AUDIT_STATUS),
1673 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_FIELD_UPGRADE_DATA),
1674 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_INCREMENTAL_SELF_TEST),
1675 TPM_CMD_CODE_INIT( TPM2_CC_SELF_TEST, NULL, NULL, vboxTraceLogDecodeEvtTpmDecodeSelfTestReq, NULL),
1676 TPM_CMD_CODE_INIT( TPM2_CC_STARTUP, NULL, NULL, vboxTraceLogDecodeEvtTpmDecodeStartupShutdownReq, NULL),
1677 TPM_CMD_CODE_INIT( TPM2_CC_SHUTDOWN, NULL, NULL, vboxTraceLogDecodeEvtTpmDecodeStartupShutdownReq, NULL),
1678 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_STIR_RANDOM),
1679 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ACTIVATE_CREDENTIAL),
1680 TPM_CMD_CODE_INIT( TPM2_CC_CERTIFY, g_apszHandlesCertifyReq, NULL, vboxTraceLogDecodeEvtTpmDecodeCertifyReq, vboxTraceLogDecodeEvtTpmDecodeCertifyResp),
1681 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_NV),
1682 TPM_CMD_CODE_INIT( TPM2_CC_CERTIFY_CREATION, g_apszHandlesCertifyCreationReq, NULL, vboxTraceLogDecodeEvtTpmDecodeCertifyCreationReq, vboxTraceLogDecodeEvtTpmDecodeCertifyCreationResp),
1683 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_DUPLICATE),
1684 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_GET_TIME),
1685 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_GET_SESSION_AUDIT_DIGEST),
1686 TPM_CMD_CODE_INIT( TPM2_CC_NV_READ, g_apszHandlesNvReadReq, NULL, vboxTraceLogDecodeEvtTpmDecodeNvReadReq, vboxTraceLogDecodeEvtTpmDecodeNvReadResp),
1687 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_READ_LOCK),
1688 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_OBJECT_CHANGE_AUTH),
1689 TPM_CMD_CODE_INIT( TPM2_CC_POLICY_SECRET, g_apszHandlesPolicySecretReq, NULL, vboxTraceLogDecodeEvtTpmDecodePolicySecretReq, vboxTraceLogDecodeEvtTpmDecodePolicySecretResp),
1690 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_REWRAP),
1691 TPM_CMD_CODE_INIT( TPM2_CC_CREATE, g_apszHandlesCreateReq, NULL, vboxTraceLogDecodeEvtTpmDecodeCreateReq, vboxTraceLogDecodeEvtTpmDecodeCreateResp),
1692 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ECDH_ZGEN),
1693 TPM_CMD_CODE_INIT( TPM2_CC_HMAC_MAC, g_apszHandlesHmacMacReq, NULL, vboxTraceLogDecodeEvtTpmDecodeHmacMacReq, vboxTraceLogDecodeEvtTpmDecodeHmacMacResp),
1694 TPM_CMD_CODE_INIT( TPM2_CC_IMPORT, g_apszHandlesImportReq, NULL, vboxTraceLogDecodeEvtTpmDecodeImportReq, vboxTraceLogDecodeEvtTpmDecodeImportResp),
1695 TPM_CMD_CODE_INIT( TPM2_CC_LOAD, g_apszHandlesLoadReq, g_apszHandlesLoadResp, vboxTraceLogDecodeEvtTpmDecodeLoadReq, vboxTraceLogDecodeEvtTpmDecodeLoadResp),
1696 TPM_CMD_CODE_INIT( TPM2_CC_QUOTE, g_apszHandlesQuoteReq, NULL, vboxTraceLogDecodeEvtTpmDecodeQuoteReq, vboxTraceLogDecodeEvtTpmDecodeQuoteResp),
1697 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_RSA_DECRYPT),
1698 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_HMAC_MAC_START),
1699 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_SEQUENCE_UPDATE),
1700 TPM_CMD_CODE_INIT( TPM2_CC_SIGN, g_apszHandlesSignReq, NULL, vboxTraceLogDecodeEvtTpmDecodeSignReq, vboxTraceLogDecodeEvtTpmDecodeSignResp),
1701 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_UNSEAL),
1702 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_SIGNED),
1703 TPM_CMD_CODE_INIT( TPM2_CC_CONTEXT_LOAD, NULL, g_apszHandlesContextLoadResp, vboxTraceLogDecodeEvtTpmDecodeContextLoadReq, NULL),
1704 TPM_CMD_CODE_INIT( TPM2_CC_CONTEXT_SAVE, g_apszHandlesContextSaveReq, NULL, NULL, vboxTraceLogDecodeEvtTpmDecodeContextSaveResp),
1705 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ECDH_KEY_GEN),
1706 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ENCRYPT_DECRYPT),
1707 TPM_CMD_CODE_INIT( TPM2_CC_FLUSH_CONTEXT, g_apszHandlesFlushContextReq, NULL, NULL, NULL),
1708 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_LOAD_EXTERNAL),
1709 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_MAKE_CREDENTIAL),
1710 TPM_CMD_CODE_INIT( TPM2_CC_NV_READ_PUBLIC, g_apszHandlesNvReadPublicReq, NULL, NULL, vboxTraceLogDecodeEvtTpmDecodeNvReadPublicResp),
1711 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_AUTHORIZE),
1712 TPM_CMD_CODE_INIT( TPM2_CC_POLICY_AUTH_VALUE, g_apszHandlesPolicyAuthValueReq, NULL, NULL, NULL),
1713 TPM_CMD_CODE_INIT( TPM2_CC_POLICY_COMMAND_CODE, g_apszHandlesPolicyCommandCodeReq, NULL, vboxTraceLogDecodeEvtTpmDecodePolicyCommandCodeReq, NULL),
1714 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_COUNTER_TIMER),
1715 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_CP_HASH),
1716 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_LOCALITY),
1717 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_NAME_HASH),
1718 TPM_CMD_CODE_INIT( TPM2_CC_POLICY_OR, g_apszHandlesPolicyOrReq, NULL, vboxTraceLogDecodeEvtTpmDecodePolicyOrReq, NULL),
1719 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_TICKET),
1720 TPM_CMD_CODE_INIT( TPM2_CC_READ_PUBLIC, g_apszHandlesReadPublicReq, NULL, NULL, vboxTraceLogDecodeEvtTpmDecodeReadPublicResp),
1721 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_RSA_ENCRYPT),
1722 TPM_CMD_CODE_INIT( TPM2_CC_START_AUTH_SESSION, g_apszHandlesStartAuthSessionReq, g_apszHandlesStartAuthSessionResp, vboxTraceLogDecodeEvtTpmDecodeStartAuthSessionReq, vboxTraceLogDecodeEvtTpmDecodeStartAuthSessionResp),
1723 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_VERIFY_SIGNATURE),
1724 TPM_CMD_CODE_INIT( TPM2_CC_ECC_PARAMETERS, NULL, NULL, vboxTraceLogDecodeEvtTpmDecodeEccParametersReq, vboxTraceLogDecodeEvtTpmDecodeEccParametersResp),
1725 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_FIRMWARE_READ),
1726 TPM_CMD_CODE_INIT( TPM2_CC_GET_CAPABILITY, NULL, NULL, vboxTraceLogDecodeEvtTpmDecodeGetCapabilityReq, vboxTraceLogDecodeEvtTpmDecodeGetCapabilityResp),
1727 TPM_CMD_CODE_INIT( TPM2_CC_GET_RANDOM, NULL, NULL, vboxTraceLogDecodeEvtTpmDecodeGetRandomReq, vboxTraceLogDecodeEvtTpmDecodeGetRandomResp),
1728 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_GET_TEST_RESULT),
1729 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_GET_HASH),
1730 TPM_CMD_CODE_INIT( TPM2_CC_PCR_READ, NULL, NULL, vboxTraceLogDecodeEvtTpmDecodePcrReadReq, vboxTraceLogDecodeEvtTpmDecodePcrReadResp),
1731 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_PCR),
1732 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_RESTART),
1733 TPM_CMD_CODE_INIT( TPM2_CC_READ_CLOCK, NULL, NULL, NULL, vboxTraceLogDecodeEvtTpmDecodeReadClockResp),
1734 TPM_CMD_CODE_INIT( TPM2_CC_PCR_EXTEND, g_apszHandlesPcrExtendReq, NULL, vboxTraceLogDecodeEvtTpmDecodePcrExtendReq, NULL),
1735 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PCR_SET_AUTH_VALUE),
1736 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_CERTIFY),
1737 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_EVENT_SEQUENCE_COMPLETE),
1738 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_HASH_SEQUENCE_START),
1739 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_PHYSICAL_PRESENCE),
1740 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_DUPLICATION_SELECT),
1741 TPM_CMD_CODE_INIT( TPM2_CC_POLICY_GET_DIGEST, g_apszHandlesPolicyGetDigestReq, NULL, NULL, vboxTraceLogDecodeEvtTpmDecodePolicyGetDigestResp),
1742 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_TEST_PARMS),
1743 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_COMMIT),
1744 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_PASSWORD),
1745 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ZGEN_2PHASE),
1746 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_EC_EPHEMERAL),
1747 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_NV_WRITTEN),
1748 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_TEMPLATE),
1749 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CREATE_LOADED),
1750 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_AUTHORIZE_NV),
1751 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ENCRYPT_DECRYPT_2),
1752 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_AC_GET_CAPABILITY),
1753 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_AC_SEND),
1754 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_AC_SEND_SELECT),
1755 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CERTIFY_X509),
1756 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ACT_SET_TIMEOUT),
1757 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ECC_ENCRYPT),
1758 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ECC_DECRYPT),
1759 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_CAPABILITY),
1760 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_PARAMETERS),
1761 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_DEFINE_SPACE_2),
1762 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_READ_PUBLIC_2),
1763 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_SET_CAPABILITY)
1764#undef TPM_CMD_CODE_INIT
1765};
1766
1767static void vboxTraceLogDecodeEvtTpmDecodeCmdBuffer(PRTTRACELOGDECODERHLP pHlp, const uint8_t *pbCmd, size_t cbCmd)
1768{
1769 PCTPMREQHDR pHdr = (PCTPMREQHDR)pbCmd;
1770 if (cbCmd >= sizeof(*pHdr))
1771 {
1772 uint16_t u16Tag = RT_BE2H_U16(pHdr->u16Tag);
1773 uint32_t u32CmdCode = RT_BE2H_U32(pHdr->u32Ordinal);
1774 uint32_t cbReqPayload = RT_BE2H_U32(pHdr->cbReq) - sizeof(*pHdr);
1775 PTPMSTATE pTpmState = (PTPMSTATE)pHlp->pfnDecoderStateGet(pHlp);
1776
1777 if (!pTpmState)
1778 {
1779 int rc = pHlp->pfnDecoderStateCreate(pHlp, sizeof(*pTpmState), NULL, (void **)&pTpmState);
1780 if (RT_SUCCESS(rc))
1781 pTpmState->u32CmdCode = u32CmdCode;
1782 else
1783 pHlp->pfnErrorMsg(pHlp, "Failed to allocate TPM decoder state: %Rrc\n", rc);
1784 }
1785 else
1786 pTpmState->u32CmdCode = u32CmdCode;
1787
1788 for (uint32_t i = 0; i < RT_ELEMENTS(s_aTpmCmdCodes); i++)
1789 {
1790 if (s_aTpmCmdCodes[i].u32CmdCode == u32CmdCode)
1791 {
1792 pHlp->pfnStructBldBegin(pHlp, "Command");
1793 pHlp->pfnStructBldAddStr(pHlp, "CmdCode", 0 /*fFlags*/, s_aTpmCmdCodes[i].pszCmdCode);
1794 pHlp->pfnStructBldAddU32(pHlp, "PayloadSize", 0 /*fFlags*/, cbReqPayload);
1795 pHlp->pfnStructBldAddU16(pHlp, "u16Tag", RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX, u16Tag);
1796
1797 TPMDECODECTX Ctx;
1798 PTPMDECODECTX pCtx = &Ctx;
1799 vboxTraceLogDecodeEvtTpmDecodeCtxInit(&Ctx, (const uint8_t *)(pHdr + 1), cbReqPayload);
1800
1801 /* Decode the handle area. */
1802 if (s_aTpmCmdCodes[i].papszHandlesReq)
1803 {
1804 pHlp->pfnStructBldBegin(pHlp, "Handles");
1805
1806 const char **papszHnd = s_aTpmCmdCodes[i].papszHandlesReq;
1807 while (*papszHnd)
1808 {
1809 TPM_DECODE_U32_HEX_STR(u32Hnd, *papszHnd);
1810 papszHnd++;
1811 }
1812
1813 pHlp->pfnStructBldEnd(pHlp);
1814 }
1815
1816 /* Decode authorization area if available. */
1817 if (u16Tag == TPM2_ST_SESSIONS)
1818 {
1819 size_t cbAuthArea = 0;
1820 TPM_DECODE_INIT();
1821 TPM_DECODE_U32(u32AuthSize, u32AuthSize);
1822 cbAuthArea = u32AuthSize;
1823 TPM_DECODE_END();
1824
1825 if (cbAuthArea)
1826 {
1827 const uint8_t *pb = vboxTraceLogDecodeEvtTpmDecodeCtxGetBuf(pCtx, pHlp, "AuthArea", cbAuthArea);
1828 if (!pCtx->fError)
1829 {
1830 TPMDECODECTX CtxAuth;
1831 vboxTraceLogDecodeEvtTpmDecodeCtxInit(&CtxAuth, pb, cbAuthArea);
1832
1833 pHlp->pfnStructBldBegin(pHlp, "AuthArea");
1834 while ( CtxAuth.cbLeft
1835 && !CtxAuth.fError)
1836 vboxTraceLogDecodeEvtTpmAuthSessionReq(pHlp, &CtxAuth);
1837 pHlp->pfnStructBldEnd(pHlp);
1838 }
1839 }
1840 }
1841
1842 /* Decode parameters. */
1843 if (s_aTpmCmdCodes[i].pfnDecodeReq)
1844 {
1845 pHlp->pfnStructBldBegin(pHlp, "Parameters");
1846 s_aTpmCmdCodes[i].pfnDecodeReq(pHlp, pTpmState, &Ctx);
1847 pHlp->pfnStructBldEnd(pHlp);
1848 }
1849
1850 if (pCtx->cbLeft)
1851 pHlp->pfnStructBldAddBuf(pHlp, "Leftover undecoded data", 0 /*fFlags*/, pCtx->pbBuf, pCtx->cbLeft);
1852
1853 pHlp->pfnStructBldEnd(pHlp);
1854 return;
1855 }
1856 }
1857 pHlp->pfnPrintf(pHlp, " <Unknown command code>: %#x\n", u32CmdCode);
1858
1859 if (cbReqPayload)
1860 pHlp->pfnPrintf(pHlp, "%.*Rhxd\n", cbReqPayload, pHdr + 1);
1861 }
1862 else
1863 pHlp->pfnErrorMsg(pHlp, "Command buffer is smaller than the request header (required %u, given %zu\n", sizeof(*pHdr), cbCmd);
1864}
1865
1866
1867static void vboxTraceLogDecodeEvtTpmDecodeRespBuffer(PRTTRACELOGDECODERHLP pHlp, const uint8_t *pbResp, size_t cbResp)
1868{
1869 RT_NOREF(pHlp);
1870
1871 PCTPMRESPHDR pHdr = (PCTPMRESPHDR)pbResp;
1872 if (cbResp >= sizeof(*pHdr))
1873 {
1874 uint32_t cbRespPayload = RT_BE2H_U32(pHdr->cbResp) - sizeof(*pHdr);
1875 uint32_t u32ErrCode = RT_BE2H_U32(pHdr->u32ErrCode);
1876 uint16_t u16Tag = RT_BE2H_U16(pHdr->u16Tag);
1877
1878 pHlp->pfnStructBldBegin(pHlp, "Response");
1879
1880 pHlp->pfnStructBldAddU16(pHlp, "u16Tag", RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX, u16Tag);
1881 pHlp->pfnStructBldAddU32(pHlp, "u32ErrCode", 0 /*fFlags*/, u32ErrCode);
1882 pHlp->pfnStructBldAddU32(pHlp, "cbResponse", 0 /*fFlags*/, cbRespPayload);
1883
1884 PTPMSTATE pTpmState = (PTPMSTATE)pHlp->pfnDecoderStateGet(pHlp);
1885
1886 /* Can only decode the response buffer if we know the command code. */
1887 if ( pTpmState
1888 && u32ErrCode == TPM_SUCCESS)
1889 {
1890 TPMDECODECTX Ctx;
1891 PTPMDECODECTX pCtx = &Ctx;
1892 vboxTraceLogDecodeEvtTpmDecodeCtxInit(&Ctx, (const uint8_t *)(pHdr + 1), cbRespPayload);
1893
1894 for (uint32_t i = 0; i < RT_ELEMENTS(s_aTpmCmdCodes); i++)
1895 {
1896 if (s_aTpmCmdCodes[i].u32CmdCode == pTpmState->u32CmdCode)
1897 {
1898 /* Decode the handle area. */
1899 uint32_t cHandles = 0;
1900 if (s_aTpmCmdCodes[i].papszHandlesResp)
1901 {
1902 pHlp->pfnStructBldBegin(pHlp, "Handles");
1903
1904 const char **papszHnd = s_aTpmCmdCodes[i].papszHandlesResp;
1905 while (*papszHnd)
1906 {
1907 TPM_DECODE_U32_HEX_STR(u32Hnd, *papszHnd);
1908 papszHnd++;
1909 cHandles++;
1910 }
1911
1912 pHlp->pfnStructBldEnd(pHlp);
1913 }
1914
1915 size_t cbParams = cbRespPayload - cHandles * sizeof(uint32_t);
1916 if (u16Tag == TPM2_ST_SESSIONS)
1917 {
1918 TPM_DECODE_INIT();
1919 TPM_DECODE_U32(u32ParamSz, u32ParamSize);
1920 cbParams = u32ParamSz;
1921 TPM_DECODE_END();
1922 }
1923
1924 /* Decode parameters. */
1925 if ( s_aTpmCmdCodes[i].pfnDecodeResp
1926 && cbParams)
1927 {
1928 const uint8_t *pb = vboxTraceLogDecodeEvtTpmDecodeCtxGetBuf(pCtx, pHlp, "Parameters", cbParams);
1929 if (!pCtx->fError)
1930 {
1931 TPMDECODECTX CtxParams;
1932 vboxTraceLogDecodeEvtTpmDecodeCtxInit(&CtxParams, pb, cbParams);
1933
1934 pHlp->pfnStructBldBegin(pHlp, "Parameters");
1935 s_aTpmCmdCodes[i].pfnDecodeResp(pHlp, pTpmState, &CtxParams);
1936
1937 if (CtxParams.cbLeft)
1938 pHlp->pfnStructBldAddBuf(pHlp, "Leftover undecoded data", 0 /*fFlags*/, CtxParams.pbBuf, CtxParams.cbLeft);
1939 pHlp->pfnStructBldEnd(pHlp);
1940 }
1941 }
1942
1943 /* Decode authorization area if available. */
1944 if (u16Tag == TPM2_ST_SESSIONS)
1945 vboxTraceLogDecodeEvtTpmAuthSessionResp(pHlp, pCtx);
1946
1947 if (pCtx->cbLeft)
1948 pHlp->pfnStructBldAddBuf(pHlp, "Leftover undecoded data", 0 /*fFlags*/, pCtx->pbBuf, pCtx->cbLeft);
1949 pHlp->pfnStructBldEnd(pHlp);
1950 return;
1951 }
1952 }
1953 }
1954
1955 if (cbRespPayload)
1956 pHlp->pfnStructBldAddBuf(pHlp, "Data", 0 /*fFlags*/, (const uint8_t *)(pHdr + 1), cbRespPayload);
1957
1958 pHlp->pfnStructBldEnd(pHlp);
1959 }
1960 else
1961 pHlp->pfnErrorMsg(pHlp, "Response buffer is smaller than the request header (required %u, given %zu\n", sizeof(*pHdr), cbResp);
1962}
1963
1964
1965static DECLCALLBACK(int) vboxTraceLogDecodeEvtTpm(PRTTRACELOGDECODERHLP pHlp, uint32_t idDecodeEvt, RTTRACELOGRDREVT hTraceLogEvt,
1966 PCRTTRACELOGEVTDESC pEvtDesc, PRTTRACELOGEVTVAL paVals, uint32_t cVals)
1967{
1968 RT_NOREF(hTraceLogEvt, pEvtDesc);
1969 if (idDecodeEvt == 0)
1970 {
1971 for (uint32_t i = 0; i < cVals; i++)
1972 {
1973 /* Look for the pvCmd item which stores the command buffer. */
1974 if ( !strcmp(paVals[i].pItemDesc->pszName, "pvCmd")
1975 && paVals[i].pItemDesc->enmType == RTTRACELOGTYPE_RAWDATA)
1976 {
1977 vboxTraceLogDecodeEvtTpmDecodeCmdBuffer(pHlp, paVals[i].u.RawData.pb, paVals[i].u.RawData.cb);
1978 return VINF_SUCCESS;
1979 }
1980 }
1981
1982 pHlp->pfnErrorMsg(pHlp, "Failed to find the TPM command data buffer for the given event\n");
1983 }
1984 else if (idDecodeEvt == 1)
1985 {
1986 for (uint32_t i = 0; i < cVals; i++)
1987 {
1988 /* Look for the pvCmd item which stores the response buffer. */
1989 if ( !strcmp(paVals[i].pItemDesc->pszName, "pvResp")
1990 && paVals[i].pItemDesc->enmType == RTTRACELOGTYPE_RAWDATA)
1991 {
1992 vboxTraceLogDecodeEvtTpmDecodeRespBuffer(pHlp, paVals[i].u.RawData.pb, paVals[i].u.RawData.cb);
1993 return VINF_SUCCESS;
1994 }
1995 }
1996 pHlp->pfnErrorMsg(pHlp, "Failed to find the TPM command response buffer for the given event\n");
1997 }
1998
1999 pHlp->pfnErrorMsg(pHlp, "Decode event ID %u is not known to this decoder\n", idDecodeEvt);
2000 return VERR_NOT_FOUND;
2001}
2002
2003
2004/**
2005 * TPM decoder event IDs.
2006 */
2007static const RTTRACELOGDECODEEVT s_aDecodeEvtTpm[] =
2008{
2009 { "ITpmConnector.CmdExecReq", 0 },
2010 { "ITpmConnector.CmdExecResp", 1 },
2011 { NULL, UINT32_MAX }
2012};
2013
2014
2015/**
2016 * Decoder plugin interface.
2017 */
2018static const RTTRACELOGDECODERREG g_TraceLogDecoderTpm =
2019{
2020 /** pszName */
2021 "TPM",
2022 /** pszDesc */
2023 "Decodes events from the ITpmConnector interface generated with the IfTrace driver.",
2024 /** paEvtIds */
2025 s_aDecodeEvtTpm,
2026 /** pfnDecode */
2027 vboxTraceLogDecodeEvtTpm,
2028};
2029
2030
2031/**
2032 * Shared object initialization callback.
2033 */
2034extern "C" DECLCALLBACK(DECLEXPORT(int)) RTTraceLogDecoderLoad(void *pvUser, PRTTRACELOGDECODERREGISTER pRegisterCallbacks)
2035{
2036 AssertLogRelMsgReturn(pRegisterCallbacks->u32Version == RT_TRACELOG_DECODERREG_CB_VERSION,
2037 ("pRegisterCallbacks->u32Version=%#x RT_TRACELOG_DECODERREG_CB_VERSION=%#x\n",
2038 pRegisterCallbacks->u32Version, RT_TRACELOG_DECODERREG_CB_VERSION),
2039 VERR_VERSION_MISMATCH);
2040
2041 return pRegisterCallbacks->pfnRegisterDecoders(pvUser, &g_TraceLogDecoderTpm, 1);
2042}
2043
Note: See TracBrowser for help on using the repository browser.

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