1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
|
// This file was extracted from the TCG Published
// Trusted Platform Module Library
// Part 4: Supporting Routines
// Family "2.0"
// Level 00 Revision 01.16
// October 30, 2014
#define TPM_FAIL_C
#include "InternalRoutines.h"
#include <assert.h>
//
// On MS C compiler, can save the alignment state and set the alignment to 1 for the duration of the
// TPM_Types.h include. This will avoid a lot of alignment warnings from the compiler for the unaligned
// structures. The alignment of the structures is not important as this function does not use any of the
// structures in TPM_Types.h and only include it for the #defines of the capabilities, properties, and
// command code values.
//
#pragma pack(push, 1)
#include "TPM_Types.h"
#pragma pack (pop)
#include "swap.h"
//
//
// Typedefs
//
// These defines are used primarily for sizing of the local response buffer.
//
#pragma pack(push,1)
typedef struct {
TPM_ST tag;
UINT32 size;
TPM_RC code;
} HEADER;
typedef struct {
UINT16 size;
struct {
UINT32 function;
UINT32 line;
UINT32 code;
} values;
TPM_RC returnCode;
} GET_TEST_RESULT_PARAMETERS;
typedef struct {
TPMI_YES_NO moreData;
TPM_CAP capability; // Always TPM_CAP_TPM_PROPERTIES
TPML_TAGGED_TPM_PROPERTY tpmProperty; // a single tagged property
} GET_CAPABILITY_PARAMETERS;
typedef struct {
HEADER header;
GET_TEST_RESULT_PARAMETERS getTestResult;
} TEST_RESPONSE;
typedef struct {
HEADER header;
GET_CAPABILITY_PARAMETERS getCap;
} CAPABILITY_RESPONSE;
typedef union {
TEST_RESPONSE test;
CAPABILITY_RESPONSE cap;
} RESPONSES;
#pragma pack(pop)
//
// Buffer to hold the responses. This may be a little larger than required due to padding that a compiler
// might add.
//
// NOTE: This is not in Global.c because of the specialized data definitions above. Since the data contained in this
// structure is not relevant outside of the execution of a single command (when the TPM is in failure mode. There
// is no compelling reason to move all the typedefs to Global.h and this structure to Global.c.
//
#ifndef __IGNORE_STATE__ // Don't define this value
static BYTE response[sizeof(RESPONSES)];
#endif
//
//
// Local Functions
//
// MarshalUint16()
//
// Function to marshal a 16 bit value to the output buffer.
//
static INT32
MarshalUint16(
UINT16 integer,
BYTE **buffer,
INT32 *size
)
{
return UINT16_Marshal(&integer, buffer, size);
}
//
//
// MarshalUint32()
//
// Function to marshal a 32 bit value to the output buffer.
static INT32
MarshalUint32(
UINT32 integer,
BYTE **buffer,
INT32 *size
)
{
return UINT32_Marshal(&integer, buffer, size);
}
//
//
// UnmarshalHeader()
//
// Funtion to unmarshal the 10-byte command header.
//
static BOOL
UnmarshalHeader(
HEADER *header,
BYTE **buffer,
INT32 *size
)
{
UINT32 usize;
TPM_RC ucode;
if( UINT16_Unmarshal(&header->tag, buffer, size) != TPM_RC_SUCCESS
|| UINT32_Unmarshal(&usize, buffer, size) != TPM_RC_SUCCESS
|| UINT32_Unmarshal(&ucode, buffer, size) != TPM_RC_SUCCESS
)
return FALSE;
header->size = usize;
header->code = ucode;
return TRUE;
}
//
//
// Public Functions
//
// SetForceFailureMode()
//
// This function is called by the simulator to enable failure mode testing.
//
LIB_EXPORT void
SetForceFailureMode(
void
)
{
g_forceFailureMode = TRUE;
return;
}
//
//
// TpmFail()
//
// This function is called by TPM.lib when a failure occurs. It will set up the failure values to be returned on
// TPM2_GetTestResult().
//
void
TpmFail(
const char *function,
int line, int code
)
{
// Save the values that indicate where the error occurred.
// On a 64-bit machine, this may truncate the address of the string
// of the function name where the error occurred.
memcpy(&s_failFunction, function, sizeof(s_failFunction));
s_failLine = line;
s_failCode = code;
// if asserts are enabled, then do an assert unless the failure mode code
// is being tested
assert(g_forceFailureMode);
// Clear this flag
g_forceFailureMode = FALSE;
// Jump to the failure mode code.
// Note: only get here if asserts are off or if we are testing failure mode
#ifndef EMBEDDED_MODE
longjmp(&g_jumpBuffer[0], 1);
#endif
}
//
//
// TpmFailureMode
//
// This function is called by the interface code when the platform is in failure mode.
//
void
TpmFailureMode (
unsigned int inRequestSize, // IN: command buffer size
unsigned char *inRequest, // IN: command buffer
unsigned int *outResponseSize, // OUT: response buffer size
unsigned char **outResponse // OUT: response buffer
)
{
BYTE *buffer;
INT32 bufferSize;
UINT32 marshalSize;
UINT32 capability;
HEADER header; // unmarshaled command header
UINT32 pt; // unmarshaled property type
UINT32 count; // unmarshaled property count
// If there is no command buffer, then just return TPM_RC_FAILURE
if(inRequestSize == 0 || inRequest == NULL)
goto FailureModeReturn;
// If the header is not correct for TPM2_GetCapability() or
// TPM2_GetTestResult() then just return the in failure mode response;
buffer = inRequest;
if(!UnmarshalHeader(&header, &inRequest, (INT32 *)&inRequestSize))
goto FailureModeReturn;
if( header.tag != TPM_ST_NO_SESSIONS
|| header.size < 10)
goto FailureModeReturn;
switch (header.code) {
case TPM_CC_GetTestResult:
// make sure that the command size is correct
if(header.size != 10)
goto FailureModeReturn;
buffer = &response[10];
bufferSize = MAX_RESPONSE_SIZE-10;
marshalSize = MarshalUint16(3 * sizeof(UINT32), &buffer, &bufferSize);
marshalSize += MarshalUint32(s_failFunction, &buffer, &bufferSize);
marshalSize += MarshalUint32(s_failLine, &buffer, &bufferSize);
marshalSize += MarshalUint32(s_failCode, &buffer, &bufferSize);
if(s_failCode == FATAL_ERROR_NV_UNRECOVERABLE)
marshalSize += MarshalUint32(TPM_RC_NV_UNINITIALIZED, &buffer, &bufferSize);
else
marshalSize += MarshalUint32(TPM_RC_FAILURE, &buffer, &bufferSize);
//
break;
case TPM_CC_GetCapability:
// make sure that the size of the command is exactly the size
// returned for the capability, property, and count
if( header.size!= (10 + (3 * sizeof(UINT32)))
// also verify that this is requesting TPM properties
|| (UINT32_Unmarshal(&capability, &inRequest,
(INT32 *)&inRequestSize)
!= TPM_RC_SUCCESS)
|| (capability != TPM_CAP_TPM_PROPERTIES)
|| (UINT32_Unmarshal(&pt, &inRequest, (INT32 *)&inRequestSize)
!= TPM_RC_SUCCESS)
|| (UINT32_Unmarshal(&count, &inRequest, (INT32 *)&inRequestSize)
!= TPM_RC_SUCCESS)
)
goto FailureModeReturn;
// If in failure mode because of an unrecoverable read error, and the
// property is 0 and the count is 0, then this is an indication to
// re-manufacture the TPM. Do the re-manufacture but stay in failure
// mode until the TPM is reset.
// Note: this behavior is not required by the specification and it is
// OK to leave the TPM permanently bricked due to an unrecoverable NV
// error.
if( count == 0 && pt == 0 && s_failCode == FATAL_ERROR_NV_UNRECOVERABLE)
{
g_manufactured = FALSE;
TPM_Manufacture(0);
}
if(count > 0)
count = 1;
else if(pt > TPM_PT_FIRMWARE_VERSION_2)
count = 0;
if(pt < TPM_PT_MANUFACTURER)
pt = TPM_PT_MANUFACTURER;
// set up for return
buffer = &response[10];
bufferSize = MAX_RESPONSE_SIZE-10;
// if the request was for a PT less than the last one
// then we indicate more, otherwise, not.
if(pt < TPM_PT_FIRMWARE_VERSION_2)
*buffer++ = YES;
else
*buffer++ = NO;
marshalSize = 1;
// indicate the capability type
marshalSize += MarshalUint32(capability, &buffer, &bufferSize);
// indicate the number of values that are being returned (0 or 1)
marshalSize += MarshalUint32(count, &buffer, &bufferSize);
// indicate the property
marshalSize += MarshalUint32(pt, &buffer, &bufferSize);
if(count > 0)
switch (pt) {
case TPM_PT_MANUFACTURER:
// the vendor ID unique to each TPM manufacturer
#ifdef MANUFACTURER
pt = *(UINT32*)MANUFACTURER;
#else
pt = 0;
#endif
break;
case TPM_PT_VENDOR_STRING_1:
// the first four characters of the vendor ID string
#ifdef VENDOR_STRING_1
pt = *(UINT32*)VENDOR_STRING_1;
#else
pt = 0;
#endif
break;
case TPM_PT_VENDOR_STRING_2:
// the second four characters of the vendor ID string
#ifdef VENDOR_STRING_2
pt = *(UINT32*)VENDOR_STRING_2;
#else
pt = 0;
#endif
break;
case TPM_PT_VENDOR_STRING_3:
// the third four characters of the vendor ID string
#ifdef VENDOR_STRING_3
pt = *(UINT32*)VENDOR_STRING_3;
#else
pt = 0;
#endif
break;
case TPM_PT_VENDOR_STRING_4:
// the fourth four characters of the vendor ID string
#ifdef VENDOR_STRING_4
pt = *(UINT32*)VENDOR_STRING_4;
#else
pt = 0;
#endif
break;
case TPM_PT_VENDOR_TPM_TYPE:
// vendor-defined value indicating the TPM model
// We just make up a number here
pt = 1;
break;
case TPM_PT_FIRMWARE_VERSION_1:
// the more significant 32-bits of a vendor-specific value
// indicating the version of the firmware
#ifdef FIRMWARE_V1
pt = FIRMWARE_V1;
#else
pt = 0;
#endif
break;
default: // TPM_PT_FIRMWARE_VERSION_2:
// the less significant 32-bits of a vendor-specific value
// indicating the version of the firmware
#ifdef FIRMWARE_V2
pt = FIRMWARE_V2;
#else
pt = 0;
#endif
break;
}
marshalSize += MarshalUint32(pt, &buffer, &bufferSize);
break;
default: // default for switch (cc)
goto FailureModeReturn;
}
// Now do the header
buffer = response;
bufferSize = 10;
marshalSize = marshalSize + 10; // Add the header size to the
// stuff already marshaled
MarshalUint16(TPM_ST_NO_SESSIONS, &buffer, &bufferSize); // structure tag
MarshalUint32(marshalSize, &buffer, &bufferSize); // responseSize
MarshalUint32(TPM_RC_SUCCESS, &buffer, &bufferSize); // response code
*outResponseSize = marshalSize;
*outResponse = (unsigned char *)&response;
return;
FailureModeReturn:
buffer = response;
bufferSize = 10;
marshalSize = MarshalUint16(TPM_ST_NO_SESSIONS, &buffer, &bufferSize);
marshalSize += MarshalUint32(10, &buffer, &bufferSize);
marshalSize += MarshalUint32(TPM_RC_FAILURE, &buffer, &bufferSize);
*outResponseSize = marshalSize;
*outResponse = (unsigned char *)response;
return;
}
|