VirtualBox

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

Last change on this file since 104966 was 104966, checked in by vboxsync, 10 months ago

Runtime/tools/RTTraceLogTool,Devices/Trace: Decouple decoding from outputting by introducing a structure building interface, this simplifies the decoding plugin and allows outputting to different formats (later), bugref:10701
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 62.2 KB
Line 
1/* $Id: VBoxTraceLogDecoders.cpp 104966 2024-06-19 15:40:02Z 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 { 0, NULL, 0 }
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 const char *vboxTraceLogDecodeEvtTpmAlgId2Str(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].pszString;
325
326 return "<UNKNOWN>";
327}
328
329
330static size_t vboxTraceLogDecodeEvtTpmAlgId2DigestSize(uint16_t u16AlgId)
331{
332 for (uint32_t i = 0; i < RT_ELEMENTS(g_aAlgId2Str); i++)
333 if (g_aAlgId2Str[i].u64EnumVal == u16AlgId)
334 return g_aAlgId2Str[i].uPtrUser;
335
336 return 0;
337}
338
339
340#define TPM_DECODE_INIT() do {
341
342#define TPM_DECODE_END() \
343 } while (0); \
344 if (pCtx->fError) return
345
346#define TPM_DECODE_BOOL(a_Var, a_Name) \
347 uint8_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU8(pCtx, pHlp, #a_Name); \
348 if (pCtx->fError) break; \
349 pHlp->pfnStructBldAddBool(pHlp, #a_Name, 0 /*fFlags*/, RT_BOOL(a_Var))
350
351#define TPM_DECODE_U8(a_Var, a_Name) \
352 uint8_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU8(pCtx, pHlp, #a_Name); \
353 if (pCtx->fError) break; \
354 pHlp->pfnStructBldAddU8(pHlp, #a_Name, 0 /*fFlags*/, a_Var)
355
356#define TPM_DECODE_U16(a_Var, a_Name) \
357 uint16_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU16(pCtx, pHlp, #a_Name); \
358 if (pCtx->fError) break; \
359 pHlp->pfnStructBldAddU16(pHlp, #a_Name, 0 /*fFlags*/, a_Var)
360
361#define TPM_DECODE_U32(a_Var, a_Name) \
362 uint32_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU32(pCtx, pHlp, #a_Name); \
363 if (pCtx->fError) break; \
364 pHlp->pfnStructBldAddU32(pHlp, #a_Name, 0 /*fFlags*/, a_Var)
365
366#define TPM_DECODE_U64(a_Var, a_Name) \
367 uint64_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU64(pCtx, pHlp, #a_Name); \
368 if (pCtx->fError) break; \
369 pHlp->pfnStructBldAddU64(pHlp, #a_Name, 0 /*fFlags*/, a_Var)
370
371#define TPM_DECODE_I32(a_Var, a_Name) \
372 int32_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetI32(pCtx, pHlp, #a_Name); \
373 if (pCtx->fError) break; \
374 pHlp->pfnStructBldAddS32(pHlp, #a_Name, 0 /*fFlags*/, a_Var)
375
376#define TPM_DECODE_U8_HEX(a_Var, a_Name) \
377 uint8_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU8(pCtx, pHlp, #a_Name); \
378 if (pCtx->fError) break; \
379 pHlp->pfnStructBldAddU8(pHlp, #a_Name, RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX, a_Var)
380
381#define TPM_DECODE_U16_HEX(a_Var, a_Name) \
382 uint16_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU16(pCtx, pHlp, #a_Name); \
383 if (pCtx->fError) break; \
384 pHlp->pfnStructBldAddU16(pHlp, #a_Name, RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX, a_Var)
385
386#define TPM_DECODE_U32_HEX(a_Var, a_Name) \
387 uint32_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU32(pCtx, pHlp, #a_Name); \
388 if (pCtx->fError) break; \
389 pHlp->pfnStructBldAddU32(pHlp, #a_Name, RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX, a_Var)
390
391#define TPM_DECODE_U32_HEX_STR(a_Var, a_pszName) \
392 uint32_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU32(pCtx, pHlp, a_pszName); \
393 if (pCtx->fError) break; \
394 pHlp->pfnStructBldAddU32(pHlp, a_pszName, RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX, a_Var)
395
396#define TPM_DECODE_U64_HEX(a_Var, a_Name) \
397 uint64_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU64(pCtx, pHlp, #a_Name); \
398 if (pCtx->fError) break; \
399 pHlp->pfnStructBldAddU64(pHlp, #a_Name, RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX, a_Var)
400
401#define TPM_DECODE_I32_HEX(a_Var, a_Name) \
402 int32_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetI32(pCtx, pHlp, #a_Name); \
403 if (pCtx->fError) break; \
404 pHlp->pfnStructBldAddS32(pHlp, #a_Name, 0 /*fFlags*/, a_Var)
405
406#define TPM_DECODE_BUF_EX(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
410#define TPM_DECODE_BUF(a_Var, a_Name, a_cb) \
411 const uint8_t *a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetBuf(pCtx, pHlp, #a_Name, a_cb); \
412 if (pCtx->fError) break; \
413 if (a_Var) \
414 pHlp->pfnStructBldAddBuf(pHlp, #a_Name, 0 /*fFlags*/, a_Var, a_cb);
415
416#define TPM_DECODE_BUF_HEX_STRING(a_Var, a_Name, a_cb) \
417 const uint8_t *a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetBuf(pCtx, pHlp, #a_Name, a_cb); \
418 if (pCtx->fError) break; \
419 if (a_Var) \
420 pHlp->pfnStructBldAddBuf(pHlp, #a_Name, RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX_DUMP_STR, a_Var, a_cb);
421
422#define TPM_DECODE_U16_ENUM(a_Var, a_Name, a_aEnums) \
423 uint16_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU16(pCtx, pHlp, #a_Name); \
424 if (pCtx->fError) break; \
425 pHlp->pfnStructBldAddEnum(pHlp, #a_Name, RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX, 16, a_aEnums, a_Var)
426
427#define TPM_DECODE_U32_ENUM(a_Var, a_Name, a_aEnums) \
428 uint32_t a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetU32(pCtx, pHlp, #a_Name); \
429 if (pCtx->fError) break; \
430 pHlp->pfnStructBldAddEnum(pHlp, #a_Name, RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX, 32, a_aEnums, a_Var)
431
432#define TPM_DECODE_BUF_STR(a_Var, a_pszName, a_cb) \
433 const uint8_t *a_Var = vboxTraceLogDecodeEvtTpmDecodeCtxGetBuf(pCtx, pHlp, a_pszName, a_cb); \
434 if (pCtx->fError) break; \
435 if (a_Var) \
436 pHlp->pfnStructBldAddBuf(pHlp, a_pszName, RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX_DUMP_STR, a_Var, a_cb);
437
438#define TPM_DECODE_END_IF_ERROR() \
439 if (pCtx->fError) return
440
441static void vboxTraceLogDecodePcrSelection(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx)
442{
443 TPM_DECODE_INIT();
444 TPM_DECODE_U16_ENUM(u16AlgId, u16AlgId, g_aAlgId2Str );
445 TPM_DECODE_U8( cbPcrSelection, u8SizeOfSelect );
446 TPM_DECODE_BUF_EX( pb, PCRs, cbPcrSelection);
447
448 pHlp->pfnStructBldArrayBegin(pHlp, "PCRs");
449
450 for (uint8_t idxPcr = 0; idxPcr < cbPcrSelection * 8; idxPcr++)
451 if (RT_BOOL(*(pb + (idxPcr / 8)) & RT_BIT(idxPcr % 8)))
452 pHlp->pfnStructBldAddU8(pHlp, NULL, 0 /*fFlags*/, idxPcr);
453
454 pHlp->pfnStructBldArrayEnd(pHlp);
455
456 TPM_DECODE_END();
457}
458
459
460static void vboxTraceLogDecodePcrSelectionList(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx)
461{
462 TPM_DECODE_INIT();
463 TPM_DECODE_U32(u32Count, u32Count);
464
465 pHlp->pfnStructBldBegin(pHlp, "aPcrSelection");
466
467 /* Walk the list of PCR selection entries. */
468 for (uint32_t i = 0; i < u32Count; i++)
469 {
470 vboxTraceLogDecodePcrSelection(pHlp, pCtx);
471 TPM_DECODE_END_IF_ERROR();
472 }
473
474 pHlp->pfnStructBldEnd(pHlp);
475
476 TPM_DECODE_END();
477}
478
479
480static void vboxTraceLogDecodeEvtTpmDigestList(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx)
481{
482 TPM_DECODE_INIT();
483 TPM_DECODE_U32(u32DigestCount, u32DigestCount);
484
485 pHlp->pfnStructBldBegin(pHlp, "aDigests");
486
487 for (uint32_t i = 0; i < u32DigestCount; i++)
488 {
489 TPM_DECODE_U16(u16DigestSize, u16DigestSize);
490 TPM_DECODE_BUF_HEX_STRING(pbDigest, abDigest, u16DigestSize);
491 }
492
493 pHlp->pfnStructBldEnd(pHlp);
494
495 TPM_DECODE_END();
496}
497
498
499static void vboxTraceLogDecodeEvtTpmDigestValuesList(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx)
500{
501 TPM_DECODE_INIT();
502 TPM_DECODE_U32(u32DigestCount, u32DigestCount);
503
504 pHlp->pfnStructBldBegin(pHlp, "aDigests");
505
506 for (uint32_t i = 0; i < u32DigestCount; i++)
507 {
508 TPM_DECODE_U16_ENUM(u16HashAlg, u16HashAlg, g_aAlgId2Str);
509
510 size_t cbDigest = vboxTraceLogDecodeEvtTpmAlgId2DigestSize(u16HashAlg);
511 TPM_DECODE_BUF_HEX_STRING(pb, abDigest, cbDigest);
512 }
513
514 pHlp->pfnStructBldEnd(pHlp);
515
516 TPM_DECODE_END();
517}
518
519
520static void vboxTraceLogDecodeEvtTpmAuthSessionReq(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx)
521{
522 pHlp->pfnStructBldBegin(pHlp, "AuthArea");
523 TPM_DECODE_INIT();
524 TPM_DECODE_U32( u32Size, u32Size);
525 TPM_DECODE_U32_HEX(u32SessionHandle, u32SessionHandle);
526 TPM_DECODE_U16( u16NonceSize, u16NonceSize);
527 TPM_DECODE_BUF( pbNonce, abNonce, u16NonceSize);
528 TPM_DECODE_U8( u8Attr, u8Attr);
529 TPM_DECODE_U16( u16HmacSize, u16HmacSize);
530 TPM_DECODE_BUF( pbHmac, abHmac, u16HmacSize);
531 TPM_DECODE_END();
532 pHlp->pfnStructBldEnd(pHlp);
533}
534
535
536static void vboxTraceLogDecodeEvtTpmAuthSessionResp(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx)
537{
538 pHlp->pfnStructBldBegin(pHlp, "AuthArea");
539 TPM_DECODE_INIT();
540 TPM_DECODE_U16(u16NonceSize, u16NonceSize);
541 TPM_DECODE_BUF(pbNonce, abNonce, u16NonceSize);
542 TPM_DECODE_U8( u8Attr, u8Attr);
543 TPM_DECODE_U16(u16AckSize, u16AckSize);
544 TPM_DECODE_BUF(pbAck, abAck, u16AckSize);
545 TPM_DECODE_END();
546 pHlp->pfnStructBldEnd(pHlp);
547}
548
549
550static void vboxTraceLogDecodeSizedBufU16(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx, const char *pszName)
551{
552 pHlp->pfnStructBldBegin(pHlp, pszName);
553 TPM_DECODE_INIT();
554 TPM_DECODE_U16(u16Size, u16Size);
555 if (u16Size)
556 {
557 TPM_DECODE_BUF_STR(pb, pszName, u16Size);
558 }
559 TPM_DECODE_END();
560 pHlp->pfnStructBldEnd(pHlp);
561}
562
563
564static void vboxTraceLogDecodeSymEncDef(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx, const char *pszName)
565{
566 pHlp->pfnStructBldBegin(pHlp, pszName);
567 TPM_DECODE_INIT();
568 TPM_DECODE_U16_ENUM(u16HashAlg, u16HashAlg, g_aAlgId2Str);
569 if (u16HashAlg != TPM2_ALG_NULL)
570 {
571 TPM_DECODE_U16(u16KeyBits, u16KeyBits);
572 TPM_DECODE_U16_ENUM(u16SymMode, u16SymMode, g_aAlgId2Str);
573 /* Symmetric details are not required as of now. */
574 }
575 TPM_DECODE_END();
576 pHlp->pfnStructBldEnd(pHlp);
577}
578
579
580static void vboxTraceLogDecodeNvPublic(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx, const char *pszName)
581{
582 pHlp->pfnStructBldBegin(pHlp, pszName);
583 TPM_DECODE_INIT();
584 TPM_DECODE_U16(u16Size, u16Size);
585 if (u16Size)
586 {
587 TPM_DECODE_U32_HEX(hNvIndex, hNvIndex);
588 TPM_DECODE_U16(u16HashAlgName, u16HashAlgName);
589 TPM_DECODE_U32(u32Attr, fAttr);
590 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "AuthPolicy");
591 TPM_DECODE_U16(u16DataSize, u16DataSize);
592 }
593 TPM_DECODE_END();
594 pHlp->pfnStructBldEnd(pHlp);
595}
596
597
598static void vboxTraceLogDecodeTicket(PRTTRACELOGDECODERHLP pHlp, PTPMDECODECTX pCtx, const char *pszName)
599{
600 pHlp->pfnStructBldBegin(pHlp, pszName);
601 TPM_DECODE_INIT();
602 TPM_DECODE_U16_HEX(u16Tag, u16Tag);
603 TPM_DECODE_U32_HEX(hHierarchy, hHierarchy);
604 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Digest");
605 TPM_DECODE_END();
606 pHlp->pfnStructBldEnd(pHlp);
607}
608
609
610static RTTRACELOGDECODERSTRUCTBLDENUM g_aStartupShutdownParam[] =
611{
612 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_SU_CLEAR),
613 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_SU_STATE)
614};
615
616static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeStartupShutdownReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
617{
618 RT_NOREF(pThis);
619
620 TPM_DECODE_INIT();
621 TPM_DECODE_U16_ENUM(u16TpmSu, u16State, g_aStartupShutdownParam);
622 TPM_DECODE_END();
623}
624
625
626static RTTRACELOGDECODERSTRUCTBLDENUM g_aTpm2Caps[] =
627{
628 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_CAP_ALGS),
629 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_CAP_HANDLES),
630 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_CAP_COMMANDS),
631 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_CAP_PP_COMMANDS),
632 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_CAP_AUDIT_COMMANDS),
633 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_CAP_PCRS),
634 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_CAP_TPM_PROPERTIES),
635 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_CAP_PCR_PROPERTIES),
636 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_CAP_ECC_CURVES),
637 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_CAP_AUTH_POLICIES),
638 RT_TRACELOG_DECODER_STRUCT_BLD_ENUM_INIT(TPM2_CAP_ACT)
639};
640
641static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeGetCapabilityReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
642{
643 TPM_DECODE_INIT();
644 TPM_DECODE_U32_ENUM(u32Cap, u32Cap, g_aTpm2Caps);
645 TPM_DECODE_U32_HEX( u32Property, u32Property );
646 TPM_DECODE_U32( u32Count, u32Count );
647
648 pThis->u.GetCapability.u32Cap = u32Cap;
649 pThis->u.GetCapability.u32Property = u32Property;
650 pThis->u.GetCapability.u32Count = u32Count;
651 TPM_DECODE_END();
652}
653
654
655static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeGetCapabilityResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
656{
657 RT_NOREF(pThis);
658
659 TPM_DECODE_INIT();
660 TPM_DECODE_BOOL( fMoreData, fMoreData);
661 TPM_DECODE_U32_ENUM(u32Cap, u32Cap, g_aTpm2Caps);
662
663 switch (u32Cap)
664 {
665 case TPM2_CAP_PCRS:
666 {
667 vboxTraceLogDecodePcrSelectionList(pHlp, pCtx);
668 break;
669 }
670 default:
671 break;
672 }
673 TPM_DECODE_END();
674}
675
676
677static const char *g_apszHandlesReadPublicReq[] =
678{
679 "hObj",
680 NULL
681};
682
683
684static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeReadPublicResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
685{
686 RT_NOREF(pThis);
687
688 TPM_DECODE_INIT();
689 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "OutPublic");
690 TPM_DECODE_END_IF_ERROR();
691 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Name");
692 TPM_DECODE_END_IF_ERROR();
693 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "QualifiedName");
694 TPM_DECODE_END_IF_ERROR();
695 TPM_DECODE_END();
696}
697
698
699static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeGetRandomReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
700{
701 TPM_DECODE_INIT();
702 TPM_DECODE_U16(u16RandomBytes, u16RandomBytes);
703 pThis->u.GetRandom.cbRnd = u16RandomBytes;
704 TPM_DECODE_END();
705}
706
707
708static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeGetRandomResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
709{
710 TPM_DECODE_INIT();
711 TPM_DECODE_U16(cbBuf, u16Size);
712 if (pThis->u.GetRandom.cbRnd != cbBuf)
713 {
714 pHlp->pfnErrorMsg(pHlp, "Requested random data size doesn't match returned data size (requested %u, returned %u), using smaller value\n",
715 pThis->u.GetRandom.cbRnd, cbBuf);
716 cbBuf = RT_MIN(cbBuf, pThis->u.GetRandom.cbRnd);
717 }
718
719 TPM_DECODE_BUF(pb, RndBuf, cbBuf);
720 TPM_DECODE_END();
721}
722
723
724static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodePcrReadReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
725{
726 RT_NOREF(pThis);
727
728 TPM_DECODE_INIT();
729 vboxTraceLogDecodePcrSelectionList(pHlp, pCtx);
730 TPM_DECODE_END();
731}
732
733
734static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodePcrReadResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
735{
736 RT_NOREF(pThis);
737
738 TPM_DECODE_INIT();
739 TPM_DECODE_U32(u32PcrUpdateCounter, u32PcrUpdateCounter);
740 vboxTraceLogDecodePcrSelectionList(pHlp, pCtx);
741 TPM_DECODE_END_IF_ERROR();
742 vboxTraceLogDecodeEvtTpmDigestList(pHlp, pCtx);
743 TPM_DECODE_END();
744}
745
746
747static const char *g_apszHandlesPcrExtendReq[] =
748{
749 "hPcr",
750 NULL
751};
752
753
754static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodePcrExtendReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
755{
756 RT_NOREF(pThis);
757
758 TPM_DECODE_INIT();
759 vboxTraceLogDecodeEvtTpmDigestValuesList(pHlp, pCtx);
760 TPM_DECODE_END();
761}
762
763
764static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeReadClockResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
765{
766 RT_NOREF(pThis);
767
768 TPM_DECODE_INIT();
769 TPM_DECODE_U64(u64Time, u64Time);
770
771 /* Decode TPMS_CLOCK_INFO. */
772 TPM_DECODE_U64( u64Clock, u64Clock);
773 TPM_DECODE_U32( u32ResetCount, u32ResetCount);
774 TPM_DECODE_U32( u32RestartCount, u32RestartCount);
775 TPM_DECODE_BOOL(fSafe, fSafe);
776 TPM_DECODE_END();
777}
778
779
780static const char *g_apszHandlesNvReadPublicReq[] =
781{
782 "hNvIndex",
783 NULL
784};
785
786
787static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeNvReadPublicResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
788{
789 RT_NOREF(pThis);
790
791 TPM_DECODE_INIT();
792 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "NvPublic");
793 TPM_DECODE_END();
794}
795
796
797static const char *g_apszHandlesStartAuthSessionReq[] =
798{
799 "hTpmKey",
800 "hBind",
801 NULL
802};
803
804
805static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeStartAuthSessionReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
806{
807 RT_NOREF(pThis);
808
809 TPM_DECODE_INIT();
810 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "NonceCaller");
811 TPM_DECODE_END_IF_ERROR();
812 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "EncryptedSalt");
813 TPM_DECODE_END_IF_ERROR();
814
815 TPM_DECODE_U8_HEX(u8SessionType, u8SessionType);
816
817 vboxTraceLogDecodeSymEncDef(pHlp, pCtx, "Symmetric");
818 TPM_DECODE_END_IF_ERROR();
819
820 TPM_DECODE_U16_ENUM(u16HashAlg, u16HashAlg, g_aAlgId2Str);
821 TPM_DECODE_END();
822}
823
824
825static const char *g_apszHandlesStartAuthSessionResp[] =
826{
827 "hSession",
828 NULL
829};
830
831
832static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeStartAuthSessionResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
833{
834 RT_NOREF(pThis);
835
836 TPM_DECODE_INIT();
837 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "NonceTpm");
838 TPM_DECODE_END();
839}
840
841
842static const char *g_apszHandlesHierarchyChangeAuthReq[] =
843{
844 "hAuth",
845 NULL
846};
847
848static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeHierarchyChangeAuthReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
849{
850 RT_NOREF(pThis);
851
852 TPM_DECODE_INIT();
853 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "NewAuth");
854 TPM_DECODE_END();
855}
856
857
858static const char *g_apszHandlesNvDefineSpaceReq[] =
859{
860 "hAuth",
861 NULL
862};
863
864static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeNvDefineSpaceReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
865{
866 RT_NOREF(pThis);
867
868 TPM_DECODE_INIT();
869 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Auth");
870 TPM_DECODE_END_IF_ERROR();
871
872 vboxTraceLogDecodeNvPublic(pHlp, pCtx, "PublicInfo");
873 TPM_DECODE_END();
874}
875
876
877static const char *g_apszHandlesSetPrimaryPolicyReq[] =
878{
879 "hAuth",
880 NULL
881};
882
883static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeSetPrimaryPolicyReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
884{
885 RT_NOREF(pThis);
886
887 TPM_DECODE_INIT();
888 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "AuthPolicy");
889 TPM_DECODE_END_IF_ERROR();
890
891 TPM_DECODE_U16(u16HashAlg, u16HashAlg);
892 pHlp->pfnPrintf(pHlp, " u16HashAlg: %s\n", vboxTraceLogDecodeEvtTpmAlgId2Str(u16HashAlg));
893 TPM_DECODE_END();
894}
895
896
897static const char *g_apszHandlesCreatePrimaryReq[] =
898{
899 "hPrimary",
900 NULL
901};
902
903static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeCreatePrimaryReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
904{
905 RT_NOREF(pThis);
906
907 TPM_DECODE_INIT();
908 /** @todo Decode InSensitive. */
909 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "InSensitive");
910 TPM_DECODE_END_IF_ERROR();
911 /** @todo Decode InPublic. */
912 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "InPublic");
913 TPM_DECODE_END_IF_ERROR();
914
915 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "OutsideInfo");
916 TPM_DECODE_END_IF_ERROR();
917
918 vboxTraceLogDecodePcrSelectionList(pHlp, pCtx);
919
920 TPM_DECODE_END();
921}
922
923
924static const char *g_apszHandlesCreatePrimaryResp[] =
925{
926 "hObj",
927 NULL
928};
929
930
931static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeCreatePrimaryResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
932{
933 RT_NOREF(pThis);
934
935 TPM_DECODE_INIT();
936 /** @todo Decode OutPublic. */
937 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "OutPublic");
938 TPM_DECODE_END_IF_ERROR();
939 /** @todo Decode CreationData. */
940 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "CreationData");
941 TPM_DECODE_END_IF_ERROR();
942
943 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "CreationHash");
944 TPM_DECODE_END_IF_ERROR();
945
946 vboxTraceLogDecodeTicket(pHlp, pCtx, "Ticket");
947 TPM_DECODE_END_IF_ERROR();
948
949 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Name");
950 TPM_DECODE_END();
951}
952
953
954static const char *g_apszHandlesNvIncrementReq[] =
955{
956 "hAuth",
957 "hNvIndex",
958 NULL
959};
960
961
962static const char *g_apszHandlesNvSetBitsReq[] =
963{
964 "hAuth",
965 "hNvIndex",
966 NULL
967};
968
969static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeNvSetBitsReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
970{
971 RT_NOREF(pThis);
972
973 TPM_DECODE_INIT();
974 TPM_DECODE_U64_HEX(u64BitsOr, u64BitsOr);
975 TPM_DECODE_END();
976}
977
978
979static const char *g_apszHandlesNvWriteReq[] =
980{
981 "hAuth",
982 "hNvIndex",
983 NULL
984};
985
986static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeNvWriteReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
987{
988 RT_NOREF(pThis);
989
990 TPM_DECODE_INIT();
991 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Data");
992 TPM_DECODE_END_IF_ERROR();
993
994 TPM_DECODE_U16(u16Offset, u16Offset);
995 TPM_DECODE_END();
996}
997
998
999static const char *g_apszHandlesDictionaryAttackParametersReq[] =
1000{
1001 "hLock",
1002 NULL
1003};
1004
1005static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeDictionaryAttackParametersReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1006{
1007 RT_NOREF(pThis);
1008
1009 TPM_DECODE_INIT();
1010 TPM_DECODE_U32(u32NewMaxTries, u32NewMaxTries);
1011 TPM_DECODE_U32(u32NewRecoveryTime, u32NewRecoveryTime);
1012 TPM_DECODE_U32(u32LockoutRecovery, u32LockoutRecovery);
1013 TPM_DECODE_END();
1014}
1015
1016
1017static const char *g_apszHandlesCertifyCreationReq[] =
1018{
1019 "hSign",
1020 "hObj",
1021 NULL
1022};
1023
1024static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeCertifyCreationReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1025{
1026 RT_NOREF(pThis);
1027
1028 TPM_DECODE_INIT();
1029 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "QualifyingData");
1030 TPM_DECODE_END_IF_ERROR();
1031 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "CreationHash");
1032 TPM_DECODE_END_IF_ERROR();
1033
1034 TPM_DECODE_U16_ENUM(u16SigningScheme, u16SigningScheme, g_aAlgId2Str);
1035 vboxTraceLogDecodeTicket(pHlp, pCtx, "CreationTicket");
1036 TPM_DECODE_END();
1037}
1038
1039
1040static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeCertifyCreationResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1041{
1042 RT_NOREF(pThis);
1043
1044 TPM_DECODE_INIT();
1045 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "CertifyInfo");
1046
1047 /* Decode TPMT_SIGNATURE */
1048 TPM_DECODE_U16_ENUM(u16SigningAlg, u16SigningAlg, g_aAlgId2Str);
1049 TPM_DECODE_U16_ENUM(u16HashAlg, u16HashAlg, g_aAlgId2Str);
1050 TPM_DECODE_END();
1051}
1052
1053
1054static const char *g_apszHandlesNvReadReq[] =
1055{
1056 "hAuth",
1057 "hNvIndex",
1058 NULL
1059};
1060
1061static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeNvReadReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1062{
1063 RT_NOREF(pThis);
1064
1065 TPM_DECODE_INIT();
1066 TPM_DECODE_U16(u16Size, u16Size);
1067 TPM_DECODE_U16(u16Offset, u16Offset);
1068 TPM_DECODE_END();
1069}
1070
1071
1072static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeNvReadResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1073{
1074 RT_NOREF(pThis);
1075
1076 TPM_DECODE_INIT();
1077 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Data");
1078 TPM_DECODE_END();
1079}
1080
1081
1082static const char *g_apszHandlesPolicySecretReq[] =
1083{
1084 "hAuth",
1085 "hPolicySession",
1086 NULL
1087};
1088
1089static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodePolicySecretReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1090{
1091 RT_NOREF(pThis);
1092
1093 TPM_DECODE_INIT();
1094 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "NonceTpm");
1095 TPM_DECODE_END_IF_ERROR();
1096 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "CpHashA");
1097 TPM_DECODE_END_IF_ERROR();
1098 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "PolicyRef");
1099 TPM_DECODE_END_IF_ERROR();
1100
1101 TPM_DECODE_I32(i32Expiration, i32Expiration);
1102 TPM_DECODE_END();
1103}
1104
1105
1106static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodePolicySecretResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1107{
1108 RT_NOREF(pThis);
1109
1110 TPM_DECODE_INIT();
1111 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Timeout");
1112 TPM_DECODE_END_IF_ERROR();
1113
1114 vboxTraceLogDecodeTicket(pHlp, pCtx, "Ticket");
1115 TPM_DECODE_END();
1116}
1117
1118
1119static const char *g_apszHandlesCreateReq[] =
1120{
1121 "hParent",
1122 NULL
1123};
1124
1125static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeCreateReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1126{
1127 RT_NOREF(pThis);
1128
1129 TPM_DECODE_INIT();
1130 /** @todo Decode InSensitive. */
1131 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "InSensitive");
1132 TPM_DECODE_END_IF_ERROR();
1133 /** @todo Decode InPublic. */
1134 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "InPublic");
1135 TPM_DECODE_END_IF_ERROR();
1136
1137 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "OutsideInfo");
1138 TPM_DECODE_END_IF_ERROR();
1139
1140 vboxTraceLogDecodePcrSelectionList(pHlp, pCtx);
1141
1142 TPM_DECODE_END();
1143}
1144
1145
1146static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeCreateResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1147{
1148 RT_NOREF(pThis);
1149
1150 TPM_DECODE_INIT();
1151 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "OutPrivate");
1152 TPM_DECODE_END_IF_ERROR();
1153 /** @todo Decode OutPublic. */
1154 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "OutPublic");
1155 TPM_DECODE_END_IF_ERROR();
1156 /** @todo Decode CreationData. */
1157 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "CreationData");
1158 TPM_DECODE_END_IF_ERROR();
1159
1160 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "CreationHash");
1161 TPM_DECODE_END_IF_ERROR();
1162
1163 vboxTraceLogDecodeTicket(pHlp, pCtx, "Ticket");
1164 TPM_DECODE_END();
1165}
1166
1167
1168static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeEccParametersReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1169{
1170 RT_NOREF(pThis);
1171
1172 TPM_DECODE_INIT();
1173 TPM_DECODE_U16(u16CurveId, u16CurveId);
1174 TPM_DECODE_END();
1175}
1176
1177
1178static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeEccParametersResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1179{
1180 RT_NOREF(pThis);
1181
1182 TPM_DECODE_INIT();
1183 TPM_DECODE_U16_HEX( u16CurveId, u16CurveId);
1184 TPM_DECODE_U16( u16KeySize, u16KeySize);
1185 TPM_DECODE_U16_ENUM(u16KdfScheme, u16KdfScheme, g_aAlgId2Str);
1186 TPM_DECODE_U16_ENUM(u16KdfSchemeHash, u16KdfSchemeHash, g_aAlgId2Str);
1187 TPM_DECODE_U16_ENUM(u16EccScheme, u16EccScheme, g_aAlgId2Str);
1188 if (u16EccScheme != TPM2_ALG_NULL)
1189 {
1190 TPM_DECODE_U16_ENUM(u16EccSchemeHash, u16EccSchemeHash, g_aAlgId2Str);
1191 }
1192 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "p");
1193 TPM_DECODE_END_IF_ERROR();
1194 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "a");
1195 TPM_DECODE_END_IF_ERROR();
1196 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "b");
1197 TPM_DECODE_END_IF_ERROR();
1198 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "gX");
1199 TPM_DECODE_END_IF_ERROR();
1200 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "gY");
1201 TPM_DECODE_END_IF_ERROR();
1202 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "n");
1203 TPM_DECODE_END_IF_ERROR();
1204 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "h");
1205 TPM_DECODE_END_IF_ERROR();
1206 TPM_DECODE_END();
1207}
1208
1209
1210static const char *g_apszHandlesQuoteReq[] =
1211{
1212 "hSign",
1213 NULL
1214};
1215
1216
1217static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeQuoteReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1218{
1219 RT_NOREF(pThis);
1220
1221 TPM_DECODE_INIT();
1222 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "QualifyingData");
1223 TPM_DECODE_END_IF_ERROR();
1224
1225 TPM_DECODE_U16_ENUM(u16SigScheme, u16SigScheme, g_aAlgId2Str);
1226 if (u16SigScheme != TPM2_ALG_NULL)
1227 {
1228 TPM_DECODE_U16_ENUM(u16SigSchemeHash, u16SigSchemeHash, g_aAlgId2Str);
1229 }
1230
1231 vboxTraceLogDecodePcrSelectionList(pHlp, pCtx);
1232 TPM_DECODE_END();
1233}
1234
1235
1236static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeQuoteResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1237{
1238 RT_NOREF(pThis);
1239
1240 TPM_DECODE_INIT();
1241 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Quoted");
1242 TPM_DECODE_END_IF_ERROR();
1243
1244 TPM_DECODE_U16_ENUM(u16SigAlg, u16SigAlg, g_aAlgId2Str);
1245 if (u16SigAlg != TPM2_ALG_NULL)
1246 {
1247 TPM_DECODE_U16_ENUM(u16SigAlgHash, u16SigAlgHash, g_aAlgId2Str);
1248 }
1249 TPM_DECODE_END();
1250}
1251
1252
1253static const char *g_apszHandlesHmacMacReq[] =
1254{
1255 "hSymKey",
1256 NULL
1257};
1258
1259
1260static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeHmacMacReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1261{
1262 RT_NOREF(pThis);
1263
1264 TPM_DECODE_INIT();
1265 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Buffer");
1266 TPM_DECODE_END_IF_ERROR();
1267
1268 TPM_DECODE_U16_ENUM(u16HashAlg, u16HashAlg, g_aAlgId2Str);
1269 TPM_DECODE_END();
1270}
1271
1272
1273static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeHmacMacResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1274{
1275 RT_NOREF(pThis);
1276
1277 TPM_DECODE_INIT();
1278 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "OutHmacMac");
1279 TPM_DECODE_END();
1280}
1281
1282
1283static const char *g_apszHandlesFlushContextReq[] =
1284{
1285 "hFlush",
1286 NULL
1287};
1288
1289
1290static const char *g_apszHandlesLoadReq[] =
1291{
1292 "hParent",
1293 NULL
1294};
1295
1296
1297static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeLoadReq(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1298{
1299 RT_NOREF(pThis);
1300
1301 TPM_DECODE_INIT();
1302 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "InPrivate");
1303 TPM_DECODE_END_IF_ERROR();
1304 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "InPublic");
1305 TPM_DECODE_END_IF_ERROR();
1306 TPM_DECODE_END();
1307}
1308
1309
1310static const char *g_apszHandlesLoadResp[] =
1311{
1312 "hObj",
1313 NULL
1314};
1315
1316
1317static DECLCALLBACK(void) vboxTraceLogDecodeEvtTpmDecodeLoadResp(PRTTRACELOGDECODERHLP pHlp, PTPMSTATE pThis, PTPMDECODECTX pCtx)
1318{
1319 RT_NOREF(pThis);
1320
1321 TPM_DECODE_INIT();
1322 vboxTraceLogDecodeSizedBufU16(pHlp, pCtx, "Name");
1323 TPM_DECODE_END_IF_ERROR();
1324 TPM_DECODE_END();
1325}
1326
1327
1328static struct
1329{
1330 uint32_t u32CmdCode;
1331 const char *pszCmdCode;
1332 const char **papszHandlesReq;
1333 const char **papszHandlesResp;
1334 PFNFNDECODETPM2CCREQ pfnDecodeReq;
1335 PFNFNDECODETPM2CCRESP pfnDecodeResp;
1336} s_aTpmCmdCodes[] =
1337{
1338#define TPM_CMD_CODE_INIT_NOT_IMPL(a_CmdCode) { a_CmdCode, #a_CmdCode, NULL, NULL, NULL, NULL }
1339#define TPM_CMD_CODE_INIT(a_CmdCode, a_apszHandlesReq, a_apszHandlesResp, a_pfnReq, a_pfnResp) { a_CmdCode, #a_CmdCode, \
1340 a_apszHandlesReq, a_apszHandlesResp, \
1341 a_pfnReq, a_pfnResp }
1342 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_UNDEFINE_SPACE_SPECIAL),
1343 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_EVICT_CONTROL),
1344 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_HIERARCHY_CONTROL),
1345 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_UNDEFINE_SPACE),
1346 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CHANGE_EPS),
1347 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CHANGE_PPS),
1348 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CLEAR),
1349 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CLEAR_CONTROL),
1350 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CLOCK_SET),
1351 TPM_CMD_CODE_INIT( TPM2_CC_HIERARCHY_CHANGE_AUTH, g_apszHandlesHierarchyChangeAuthReq, NULL, vboxTraceLogDecodeEvtTpmDecodeHierarchyChangeAuthReq, NULL),
1352 TPM_CMD_CODE_INIT( TPM2_CC_NV_DEFINE_SPACE, g_apszHandlesNvDefineSpaceReq, NULL, vboxTraceLogDecodeEvtTpmDecodeNvDefineSpaceReq, NULL),
1353 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PCR_ALLOCATE),
1354 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PCR_SET_AUTH_POLICY),
1355 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PP_COMMANDS),
1356 TPM_CMD_CODE_INIT( TPM2_CC_SET_PRIMARY_POLICY, g_apszHandlesSetPrimaryPolicyReq, NULL, vboxTraceLogDecodeEvtTpmDecodeSetPrimaryPolicyReq, NULL),
1357 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_FIELD_UPGRADE_START),
1358 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CLOCK_RATE_ADJUST),
1359 TPM_CMD_CODE_INIT( TPM2_CC_CREATE_PRIMARY, g_apszHandlesCreatePrimaryReq, g_apszHandlesCreatePrimaryResp, vboxTraceLogDecodeEvtTpmDecodeCreatePrimaryReq, vboxTraceLogDecodeEvtTpmDecodeCreatePrimaryResp),
1360 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_GLOBAL_WRITE_LOCK),
1361 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_GET_COMMAND_AUDIT_DIGEST),
1362 TPM_CMD_CODE_INIT( TPM2_CC_NV_INCREMENT, g_apszHandlesNvIncrementReq, NULL, NULL, NULL),
1363 TPM_CMD_CODE_INIT( TPM2_CC_NV_SET_BITS, g_apszHandlesNvSetBitsReq, NULL, vboxTraceLogDecodeEvtTpmDecodeNvSetBitsReq, NULL),
1364 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_EXTEND),
1365 TPM_CMD_CODE_INIT( TPM2_CC_NV_WRITE, g_apszHandlesNvWriteReq, NULL, vboxTraceLogDecodeEvtTpmDecodeNvWriteReq, NULL),
1366 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_WRITE_LOCK),
1367 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_DICTIONARY_ATTACK_LOCK_RESET),
1368 TPM_CMD_CODE_INIT( TPM2_CC_DICTIONARY_ATTACK_PARAMETERS, g_apszHandlesDictionaryAttackParametersReq, NULL, vboxTraceLogDecodeEvtTpmDecodeDictionaryAttackParametersReq, NULL),
1369 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_CHANGE_AUTH),
1370 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PCR_EVENT),
1371 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PCR_RESET),
1372 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_SEQUENCE_COMPLETE),
1373 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_SET_ALGORITHM_SET),
1374 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_SET_COMMAND_CODE_AUDIT_STATUS),
1375 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_FIELD_UPGRADE_DATA),
1376 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_INCREMENTAL_SELF_TEST),
1377 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_SELF_TEST),
1378 TPM_CMD_CODE_INIT( TPM2_CC_STARTUP, NULL, NULL, vboxTraceLogDecodeEvtTpmDecodeStartupShutdownReq, NULL),
1379 TPM_CMD_CODE_INIT( TPM2_CC_SHUTDOWN, NULL, NULL, vboxTraceLogDecodeEvtTpmDecodeStartupShutdownReq, NULL),
1380 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_STIR_RANDOM),
1381 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ACTIVATE_CREDENTIAL),
1382 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CERTIFY),
1383 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_NV),
1384 TPM_CMD_CODE_INIT( TPM2_CC_CERTIFY_CREATION, g_apszHandlesCertifyCreationReq, NULL, vboxTraceLogDecodeEvtTpmDecodeCertifyCreationReq, vboxTraceLogDecodeEvtTpmDecodeCertifyCreationResp),
1385 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_DUPLICATE),
1386 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_GET_TIME),
1387 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_GET_SESSION_AUDIT_DIGEST),
1388 TPM_CMD_CODE_INIT( TPM2_CC_NV_READ, g_apszHandlesNvReadReq, NULL, vboxTraceLogDecodeEvtTpmDecodeNvReadReq, vboxTraceLogDecodeEvtTpmDecodeNvReadResp),
1389 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_READ_LOCK),
1390 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_OBJECT_CHANGE_AUTH),
1391 TPM_CMD_CODE_INIT( TPM2_CC_POLICY_SECRET, g_apszHandlesPolicySecretReq, NULL, vboxTraceLogDecodeEvtTpmDecodePolicySecretReq, vboxTraceLogDecodeEvtTpmDecodePolicySecretResp),
1392 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_REWRAP),
1393 TPM_CMD_CODE_INIT( TPM2_CC_CREATE, g_apszHandlesCreateReq, NULL, vboxTraceLogDecodeEvtTpmDecodeCreateReq, vboxTraceLogDecodeEvtTpmDecodeCreateResp),
1394 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ECDH_ZGEN),
1395 TPM_CMD_CODE_INIT( TPM2_CC_HMAC_MAC, g_apszHandlesHmacMacReq, NULL, vboxTraceLogDecodeEvtTpmDecodeHmacMacReq, vboxTraceLogDecodeEvtTpmDecodeHmacMacResp),
1396 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_IMPORT),
1397 TPM_CMD_CODE_INIT( TPM2_CC_LOAD, g_apszHandlesLoadReq, g_apszHandlesLoadResp, vboxTraceLogDecodeEvtTpmDecodeLoadReq, vboxTraceLogDecodeEvtTpmDecodeLoadResp),
1398 TPM_CMD_CODE_INIT( TPM2_CC_QUOTE, g_apszHandlesQuoteReq, NULL, vboxTraceLogDecodeEvtTpmDecodeQuoteReq, vboxTraceLogDecodeEvtTpmDecodeQuoteResp),
1399 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_RSA_DECRYPT),
1400 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_HMAC_MAC_START),
1401 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_SEQUENCE_UPDATE),
1402 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_SIGN),
1403 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_UNSEAL),
1404 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_SIGNED),
1405 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CONTEXT_LOAD),
1406 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CONTEXT_SAVE),
1407 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ECDH_KEY_GEN),
1408 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ENCRYPT_DECRYPT),
1409 TPM_CMD_CODE_INIT( TPM2_CC_FLUSH_CONTEXT, g_apszHandlesFlushContextReq, NULL, NULL, NULL),
1410 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_LOAD_EXTERNAL),
1411 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_MAKE_CREDENTIAL),
1412 TPM_CMD_CODE_INIT( TPM2_CC_NV_READ_PUBLIC, g_apszHandlesNvReadPublicReq, NULL, NULL, vboxTraceLogDecodeEvtTpmDecodeNvReadPublicResp),
1413 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_AUTHORIZE),
1414 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_AUTH_VALUE),
1415 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_COMMAND_CODE),
1416 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_COUNTER_TIMER),
1417 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_CP_HASH),
1418 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_LOCALITY),
1419 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_NAME_HASH),
1420 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_OR),
1421 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_TICKET),
1422 TPM_CMD_CODE_INIT( TPM2_CC_READ_PUBLIC, g_apszHandlesReadPublicReq, NULL, NULL, vboxTraceLogDecodeEvtTpmDecodeReadPublicResp),
1423 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_RSA_ENCRYPT),
1424 TPM_CMD_CODE_INIT( TPM2_CC_START_AUTH_SESSION, g_apszHandlesStartAuthSessionReq, g_apszHandlesStartAuthSessionResp, vboxTraceLogDecodeEvtTpmDecodeStartAuthSessionReq, vboxTraceLogDecodeEvtTpmDecodeStartAuthSessionResp),
1425 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_VERIFY_SIGNATURE),
1426 TPM_CMD_CODE_INIT( TPM2_CC_ECC_PARAMETERS, NULL, NULL, vboxTraceLogDecodeEvtTpmDecodeEccParametersReq, vboxTraceLogDecodeEvtTpmDecodeEccParametersResp),
1427 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_FIRMWARE_READ),
1428 TPM_CMD_CODE_INIT( TPM2_CC_GET_CAPABILITY, NULL, NULL, vboxTraceLogDecodeEvtTpmDecodeGetCapabilityReq, vboxTraceLogDecodeEvtTpmDecodeGetCapabilityResp),
1429 TPM_CMD_CODE_INIT( TPM2_CC_GET_RANDOM, NULL, NULL, vboxTraceLogDecodeEvtTpmDecodeGetRandomReq, vboxTraceLogDecodeEvtTpmDecodeGetRandomResp),
1430 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_GET_TEST_RESULT),
1431 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_GET_HASH),
1432 TPM_CMD_CODE_INIT( TPM2_CC_PCR_READ, NULL, NULL, vboxTraceLogDecodeEvtTpmDecodePcrReadReq, vboxTraceLogDecodeEvtTpmDecodePcrReadResp),
1433 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_PCR),
1434 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_RESTART),
1435 TPM_CMD_CODE_INIT( TPM2_CC_READ_CLOCK, NULL, NULL, NULL, vboxTraceLogDecodeEvtTpmDecodeReadClockResp),
1436 TPM_CMD_CODE_INIT( TPM2_CC_PCR_EXTEND, g_apszHandlesPcrExtendReq, NULL, vboxTraceLogDecodeEvtTpmDecodePcrExtendReq, NULL),
1437 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_PCR_SET_AUTH_VALUE),
1438 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_CERTIFY),
1439 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_EVENT_SEQUENCE_COMPLETE),
1440 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_HASH_SEQUENCE_START),
1441 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_PHYSICAL_PRESENCE),
1442 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_DUPLICATION_SELECT),
1443 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_GET_DIGEST),
1444 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_TEST_PARMS),
1445 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_COMMIT),
1446 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_PASSWORD),
1447 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ZGEN_2PHASE),
1448 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_EC_EPHEMERAL),
1449 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_NV_WRITTEN),
1450 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_TEMPLATE),
1451 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CREATE_LOADED),
1452 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_AUTHORIZE_NV),
1453 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ENCRYPT_DECRYPT_2),
1454 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_AC_GET_CAPABILITY),
1455 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_AC_SEND),
1456 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_AC_SEND_SELECT),
1457 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_CERTIFY_X509),
1458 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ACT_SET_TIMEOUT),
1459 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ECC_ENCRYPT),
1460 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_ECC_DECRYPT),
1461 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_CAPABILITY),
1462 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_POLICY_PARAMETERS),
1463 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_DEFINE_SPACE_2),
1464 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_NV_READ_PUBLIC_2),
1465 TPM_CMD_CODE_INIT_NOT_IMPL(TPM2_CC_SET_CAPABILITY)
1466#undef TPM_CMD_CODE_INIT
1467};
1468
1469static void vboxTraceLogDecodeEvtTpmDecodeCmdBuffer(PRTTRACELOGDECODERHLP pHlp, const uint8_t *pbCmd, size_t cbCmd)
1470{
1471 PCTPMREQHDR pHdr = (PCTPMREQHDR)pbCmd;
1472 if (cbCmd >= sizeof(*pHdr))
1473 {
1474 uint16_t u16Tag = RT_BE2H_U16(pHdr->u16Tag);
1475 uint32_t u32CmdCode = RT_BE2H_U32(pHdr->u32Ordinal);
1476 uint32_t cbReqPayload = RT_BE2H_U32(pHdr->cbReq) - sizeof(*pHdr);
1477 PTPMSTATE pTpmState = (PTPMSTATE)pHlp->pfnDecoderStateGet(pHlp);
1478
1479 if (!pTpmState)
1480 {
1481 int rc = pHlp->pfnDecoderStateCreate(pHlp, sizeof(*pTpmState), NULL, (void **)&pTpmState);
1482 if (RT_SUCCESS(rc))
1483 pTpmState->u32CmdCode = u32CmdCode;
1484 else
1485 pHlp->pfnErrorMsg(pHlp, "Failed to allocate TPM decoder state: %Rrc\n", rc);
1486 }
1487 else
1488 pTpmState->u32CmdCode = u32CmdCode;
1489
1490 for (uint32_t i = 0; i < RT_ELEMENTS(s_aTpmCmdCodes); i++)
1491 {
1492 if (s_aTpmCmdCodes[i].u32CmdCode == u32CmdCode)
1493 {
1494 pHlp->pfnStructBldBegin(pHlp, "Command");
1495 pHlp->pfnStructBldAddStr(pHlp, "CmdCode", 0 /*fFlags*/, s_aTpmCmdCodes[i].pszCmdCode);
1496 pHlp->pfnStructBldAddU32(pHlp, "PayloadSize", 0 /*fFlags*/, cbReqPayload);
1497 pHlp->pfnStructBldAddU16(pHlp, "u16Tag", RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX, u16Tag);
1498
1499 TPMDECODECTX Ctx;
1500 PTPMDECODECTX pCtx = &Ctx;
1501 vboxTraceLogDecodeEvtTpmDecodeCtxInit(&Ctx, (const uint8_t *)(pHdr + 1), cbReqPayload);
1502
1503 /* Decode the handle area. */
1504 if (s_aTpmCmdCodes[i].papszHandlesReq)
1505 {
1506 pHlp->pfnStructBldBegin(pHlp, "Handles");
1507
1508 const char **papszHnd = s_aTpmCmdCodes[i].papszHandlesReq;
1509 while (*papszHnd)
1510 {
1511 TPM_DECODE_U32_HEX_STR(u32Hnd, *papszHnd);
1512 papszHnd++;
1513 }
1514
1515 pHlp->pfnStructBldEnd(pHlp);
1516 }
1517
1518 /* Decode authorization area if available. */
1519 if (u16Tag == TPM2_ST_SESSIONS)
1520 vboxTraceLogDecodeEvtTpmAuthSessionReq(pHlp, pCtx);
1521
1522 /* Decode parameters. */
1523 if (s_aTpmCmdCodes[i].pfnDecodeReq)
1524 {
1525 pHlp->pfnStructBldBegin(pHlp, "Parameters");
1526 s_aTpmCmdCodes[i].pfnDecodeReq(pHlp, pTpmState, &Ctx);
1527 pHlp->pfnStructBldEnd(pHlp);
1528 }
1529
1530 if (pCtx->cbLeft)
1531 pHlp->pfnPrintf(pHlp, " Leftover undecoded data:\n"
1532 "%.*Rhxd\n", pCtx->cbLeft, pCtx->pbBuf);
1533
1534 pHlp->pfnStructBldEnd(pHlp);
1535 return;
1536 }
1537 }
1538 pHlp->pfnPrintf(pHlp, " <Unknown command code>: %#x\n", u32CmdCode);
1539
1540 if (cbReqPayload)
1541 pHlp->pfnPrintf(pHlp, "%.*Rhxd\n", cbReqPayload, pHdr + 1);
1542 }
1543 else
1544 pHlp->pfnErrorMsg(pHlp, "Command buffer is smaller than the request header (required %u, given %zu\n", sizeof(*pHdr), cbCmd);
1545}
1546
1547
1548static void vboxTraceLogDecodeEvtTpmDecodeRespBuffer(PRTTRACELOGDECODERHLP pHlp, const uint8_t *pbResp, size_t cbResp)
1549{
1550 RT_NOREF(pHlp);
1551
1552 PCTPMRESPHDR pHdr = (PCTPMRESPHDR)pbResp;
1553 if (cbResp >= sizeof(*pHdr))
1554 {
1555 uint32_t cbRespPayload = RT_BE2H_U32(pHdr->cbResp) - sizeof(*pHdr);
1556 uint32_t u32ErrCode = RT_BE2H_U32(pHdr->u32ErrCode);
1557 uint16_t u16Tag = RT_BE2H_U16(pHdr->u16Tag);
1558
1559 pHlp->pfnStructBldBegin(pHlp, "Response");
1560
1561 pHlp->pfnStructBldAddU16(pHlp, "u16Tag", RTTRACELOG_DECODER_HLP_STRUCT_BLD_F_HEX, u16Tag);
1562 pHlp->pfnStructBldAddU32(pHlp, "u32ErrCode", 0 /*fFlags*/, u32ErrCode);
1563 pHlp->pfnStructBldAddU32(pHlp, "cbResponse", 0 /*fFlags*/, cbRespPayload);
1564
1565 PTPMSTATE pTpmState = (PTPMSTATE)pHlp->pfnDecoderStateGet(pHlp);
1566
1567 /* Can only decode the response buffer if we know the command code. */
1568 if ( pTpmState
1569 && u32ErrCode == TPM_SUCCESS)
1570 {
1571 TPMDECODECTX Ctx;
1572 PTPMDECODECTX pCtx = &Ctx;
1573 vboxTraceLogDecodeEvtTpmDecodeCtxInit(&Ctx, (const uint8_t *)(pHdr + 1), cbRespPayload);
1574
1575 for (uint32_t i = 0; i < RT_ELEMENTS(s_aTpmCmdCodes); i++)
1576 {
1577 if (s_aTpmCmdCodes[i].u32CmdCode == pTpmState->u32CmdCode)
1578 {
1579 /* Decode the handle area. */
1580 if (s_aTpmCmdCodes[i].papszHandlesResp)
1581 {
1582 pHlp->pfnStructBldBegin(pHlp, "Handles");
1583
1584 const char **papszHnd = s_aTpmCmdCodes[i].papszHandlesResp;
1585 while (*papszHnd)
1586 {
1587 TPM_DECODE_U32_HEX_STR(u32Hnd, *papszHnd);
1588 papszHnd++;
1589 }
1590
1591 pHlp->pfnStructBldEnd(pHlp);
1592 }
1593
1594 if (u16Tag == TPM2_ST_SESSIONS)
1595 {
1596 TPM_DECODE_INIT();
1597 TPM_DECODE_U32(u32ParamSz, u32ParamSize);
1598 TPM_DECODE_END();
1599 }
1600
1601 /* Decode parameters. */
1602 if (s_aTpmCmdCodes[i].pfnDecodeResp)
1603 {
1604 pHlp->pfnStructBldBegin(pHlp, "Parameters");
1605 s_aTpmCmdCodes[i].pfnDecodeResp(pHlp, pTpmState, pCtx);
1606 pHlp->pfnStructBldEnd(pHlp);
1607 }
1608
1609 /* Decode authorization area if available. */
1610 if (u16Tag == TPM2_ST_SESSIONS)
1611 vboxTraceLogDecodeEvtTpmAuthSessionResp(pHlp, pCtx);
1612
1613 if (pCtx->cbLeft)
1614 pHlp->pfnStructBldAddBuf(pHlp, "Leftover undecoded data", 0 /*fFlags*/, pCtx->pbBuf, pCtx->cbLeft);
1615 pHlp->pfnStructBldEnd(pHlp);
1616 return;
1617 }
1618 }
1619 }
1620
1621 if (cbRespPayload)
1622 pHlp->pfnStructBldAddBuf(pHlp, "Data", 0 /*fFlags*/, (const uint8_t *)(pHdr + 1), cbRespPayload);
1623
1624 pHlp->pfnStructBldEnd(pHlp);
1625 }
1626 else
1627 pHlp->pfnErrorMsg(pHlp, "Response buffer is smaller than the request header (required %u, given %zu\n", sizeof(*pHdr), cbResp);
1628}
1629
1630
1631static DECLCALLBACK(int) vboxTraceLogDecodeEvtTpm(PRTTRACELOGDECODERHLP pHlp, uint32_t idDecodeEvt, RTTRACELOGRDREVT hTraceLogEvt,
1632 PCRTTRACELOGEVTDESC pEvtDesc, PRTTRACELOGEVTVAL paVals, uint32_t cVals)
1633{
1634 RT_NOREF(hTraceLogEvt, pEvtDesc);
1635 if (idDecodeEvt == 0)
1636 {
1637 for (uint32_t i = 0; i < cVals; i++)
1638 {
1639 /* Look for the pvCmd item which stores the command buffer. */
1640 if ( !strcmp(paVals[i].pItemDesc->pszName, "pvCmd")
1641 && paVals[i].pItemDesc->enmType == RTTRACELOGTYPE_RAWDATA)
1642 {
1643 vboxTraceLogDecodeEvtTpmDecodeCmdBuffer(pHlp, paVals[i].u.RawData.pb, paVals[i].u.RawData.cb);
1644 return VINF_SUCCESS;
1645 }
1646 }
1647
1648 pHlp->pfnErrorMsg(pHlp, "Failed to find the TPM command data buffer for the given event\n");
1649 }
1650 else if (idDecodeEvt == 1)
1651 {
1652 for (uint32_t i = 0; i < cVals; i++)
1653 {
1654 /* Look for the pvCmd item which stores the response buffer. */
1655 if ( !strcmp(paVals[i].pItemDesc->pszName, "pvResp")
1656 && paVals[i].pItemDesc->enmType == RTTRACELOGTYPE_RAWDATA)
1657 {
1658 vboxTraceLogDecodeEvtTpmDecodeRespBuffer(pHlp, paVals[i].u.RawData.pb, paVals[i].u.RawData.cb);
1659 return VINF_SUCCESS;
1660 }
1661 }
1662 pHlp->pfnErrorMsg(pHlp, "Failed to find the TPM command response buffer for the given event\n");
1663 }
1664
1665 pHlp->pfnErrorMsg(pHlp, "Decode event ID %u is not known to this decoder\n", idDecodeEvt);
1666 return VERR_NOT_FOUND;
1667}
1668
1669
1670/**
1671 * TPM decoder event IDs.
1672 */
1673static const RTTRACELOGDECODEEVT s_aDecodeEvtTpm[] =
1674{
1675 { "ITpmConnector.CmdExecReq", 0 },
1676 { "ITpmConnector.CmdExecResp", 1 },
1677 { NULL, UINT32_MAX }
1678};
1679
1680
1681/**
1682 * Decoder plugin interface.
1683 */
1684static const RTTRACELOGDECODERREG g_TraceLogDecoderTpm =
1685{
1686 /** pszName */
1687 "TPM",
1688 /** pszDesc */
1689 "Decodes events from the ITpmConnector interface generated with the IfTrace driver.",
1690 /** paEvtIds */
1691 s_aDecodeEvtTpm,
1692 /** pfnDecode */
1693 vboxTraceLogDecodeEvtTpm,
1694};
1695
1696
1697/**
1698 * Shared object initialization callback.
1699 */
1700extern "C" DECLCALLBACK(DECLEXPORT(int)) RTTraceLogDecoderLoad(void *pvUser, PRTTRACELOGDECODERREGISTER pRegisterCallbacks)
1701{
1702 AssertLogRelMsgReturn(pRegisterCallbacks->u32Version == RT_TRACELOG_DECODERREG_CB_VERSION,
1703 ("pRegisterCallbacks->u32Version=%#x RT_TRACELOG_DECODERREG_CB_VERSION=%#x\n",
1704 pRegisterCallbacks->u32Version, RT_TRACELOG_DECODERREG_CB_VERSION),
1705 VERR_VERSION_MISMATCH);
1706
1707 return pRegisterCallbacks->pfnRegisterDecoders(pvUser, &g_TraceLogDecoderTpm, 1);
1708}
1709
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