1 /* Software-based Trusted Platform Module (TPM) Emulator
2 * Copyright (C) 2004-2010 Mario Strasser <mast@gmx.net>
3 * 2005-2008 Heiko Stamer <stamer@gaos.org>
4 *
5 * This module is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published
7 * by the Free Software Foundation; either version 2 of the License,
8 * or (at your option) any later version.
9 *
10 * This module is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * $Id: tpm_marshalling.c 372 2010-02-15 12:52:00Z mast $
16 */
17
18 #include "tpm_marshalling.h"
19 #include "tpm_handles.h"
20 #include "crypto/rsa.h"
21
tpm_marshal_UINT32_ARRAY(BYTE ** ptr,UINT32 * length,UINT32 * v,UINT32 n)22 int tpm_marshal_UINT32_ARRAY(BYTE **ptr, UINT32 *length,
23 UINT32 *v, UINT32 n)
24 {
25 UINT32 i;
26 for (i = 0; i < n; i++) {
27 if (tpm_marshal_UINT32(ptr, length, v[i])) return -1;
28 }
29 return 0;
30 }
31
tpm_unmarshal_UINT32_ARRAY(BYTE ** ptr,UINT32 * length,UINT32 * v,UINT32 n)32 int tpm_unmarshal_UINT32_ARRAY(BYTE **ptr, UINT32 *length,
33 UINT32 *v, UINT32 n)
34 {
35 UINT32 i;
36 for (i = 0; i < n; i++) {
37 if (tpm_unmarshal_UINT32(ptr, length, &v[i])) return -1;
38 }
39 return 0;
40 }
41
tpm_marshal_TPM_STRUCT_VER(BYTE ** ptr,UINT32 * length,TPM_STRUCT_VER * v)42 int tpm_marshal_TPM_STRUCT_VER(BYTE **ptr, UINT32 *length, TPM_STRUCT_VER *v)
43 {
44 if (tpm_marshal_BYTE(ptr, length, v->major)
45 || tpm_marshal_BYTE(ptr, length, v->minor)
46 || tpm_marshal_BYTE(ptr, length, v->revMajor)
47 || tpm_marshal_BYTE(ptr, length, v->revMinor)) return -1;
48 return 0;
49 }
50
tpm_unmarshal_TPM_STRUCT_VER(BYTE ** ptr,UINT32 * length,TPM_STRUCT_VER * v)51 int tpm_unmarshal_TPM_STRUCT_VER(BYTE **ptr, UINT32 *length, TPM_STRUCT_VER *v)
52 {
53 if (tpm_unmarshal_BYTE(ptr, length, &v->major)
54 || tpm_unmarshal_BYTE(ptr, length, &v->minor)
55 || tpm_unmarshal_BYTE(ptr, length, &v->revMajor)
56 || tpm_unmarshal_BYTE(ptr, length, &v->revMinor)) return -1;
57 return 0;
58 }
59
tpm_marshal_TPM_VERSION(BYTE ** ptr,UINT32 * length,TPM_VERSION * v)60 int tpm_marshal_TPM_VERSION(BYTE **ptr, UINT32 *length, TPM_VERSION *v)
61 {
62 if (tpm_marshal_BYTE(ptr, length, v->major)
63 || tpm_marshal_BYTE(ptr, length, v->minor)
64 || tpm_marshal_BYTE(ptr, length, v->revMajor)
65 || tpm_marshal_BYTE(ptr, length, v->revMinor)) return -1;
66 return 0;
67 }
68
tpm_unmarshal_TPM_VERSION(BYTE ** ptr,UINT32 * length,TPM_VERSION * v)69 int tpm_unmarshal_TPM_VERSION(BYTE **ptr, UINT32 *length, TPM_VERSION *v)
70 {
71 if (tpm_unmarshal_BYTE(ptr, length, &v->major)
72 || tpm_unmarshal_BYTE(ptr, length, &v->minor)
73 || tpm_unmarshal_BYTE(ptr, length, &v->revMajor)
74 || tpm_unmarshal_BYTE(ptr, length, &v->revMinor)) return -1;
75 return 0;
76 }
77
tpm_marshal_TPM_DIGEST(BYTE ** ptr,UINT32 * length,TPM_DIGEST * v)78 int tpm_marshal_TPM_DIGEST(BYTE **ptr, UINT32 *length, TPM_DIGEST *v)
79 {
80 if (tpm_marshal_BYTE_ARRAY(ptr, length, v->digest, sizeof(v->digest))) return -1;
81 return 0;
82 }
83
tpm_unmarshal_TPM_DIGEST(BYTE ** ptr,UINT32 * length,TPM_DIGEST * v)84 int tpm_unmarshal_TPM_DIGEST(BYTE **ptr, UINT32 *length, TPM_DIGEST *v)
85 {
86 if (tpm_unmarshal_BYTE_ARRAY(ptr, length, v->digest, sizeof(v->digest))) return -1;
87 return 0;
88 }
89
tpm_marshal_TPM_PCRVALUE_ARRAY(BYTE ** ptr,UINT32 * length,TPM_PCRVALUE * v,UINT32 n)90 int tpm_marshal_TPM_PCRVALUE_ARRAY(BYTE **ptr, UINT32 *length,
91 TPM_PCRVALUE *v, UINT32 n)
92 {
93 UINT32 i;
94 for (i = 0; i < n; i++) {
95 if (tpm_marshal_TPM_PCRVALUE(ptr, length, &v[i])) return -1;
96 }
97 return 0;
98 }
99
tpm_unmarshal_TPM_PCRVALUE_ARRAY(BYTE ** ptr,UINT32 * length,TPM_PCRVALUE * v,UINT32 n)100 int tpm_unmarshal_TPM_PCRVALUE_ARRAY(BYTE **ptr, UINT32 *length,
101 TPM_PCRVALUE *v, UINT32 n)
102 {
103 UINT32 i;
104 for (i = 0; i < n; i++) {
105 if (tpm_unmarshal_TPM_PCRVALUE(ptr, length, &v[i])) return -1;
106 }
107 return 0;
108 }
109
tpm_marshal_TPM_NONCE(BYTE ** ptr,UINT32 * length,TPM_NONCE * v)110 int tpm_marshal_TPM_NONCE(BYTE **ptr, UINT32 *length, TPM_NONCE *v)
111 {
112 if (tpm_marshal_BYTE_ARRAY(ptr, length, v->nonce, sizeof(v->nonce))) return -1;
113 return 0;
114 }
115
tpm_unmarshal_TPM_NONCE(BYTE ** ptr,UINT32 * length,TPM_NONCE * v)116 int tpm_unmarshal_TPM_NONCE(BYTE **ptr, UINT32 *length, TPM_NONCE *v)
117 {
118 if (tpm_unmarshal_BYTE_ARRAY(ptr, length, v->nonce, sizeof(v->nonce))) return -1;
119 return 0;
120 }
121
tpm_marshal_TPM_AUTHDATA(BYTE ** ptr,UINT32 * length,TPM_AUTHDATA * v)122 int tpm_marshal_TPM_AUTHDATA(BYTE **ptr, UINT32 *length, TPM_AUTHDATA *v)
123 {
124 if (*length < sizeof(TPM_AUTHDATA)) return -1;
125 memcpy(*ptr, v, sizeof(TPM_AUTHDATA));
126 *ptr += sizeof(TPM_AUTHDATA); *length -= sizeof(TPM_AUTHDATA);
127 return 0;
128 }
129
tpm_unmarshal_TPM_AUTHDATA(BYTE ** ptr,UINT32 * length,TPM_AUTHDATA * v)130 int tpm_unmarshal_TPM_AUTHDATA(BYTE **ptr, UINT32 *length, TPM_AUTHDATA *v)
131 {
132 if (*length < sizeof(TPM_AUTHDATA)) return -1;
133 memcpy(v, *ptr, sizeof(TPM_AUTHDATA));
134 *ptr += sizeof(TPM_AUTHDATA); *length -= sizeof(TPM_AUTHDATA);
135 return 0;
136 }
137
tpm_marshal_TPM_AUTH(BYTE ** ptr,UINT32 * length,TPM_AUTH * v)138 int tpm_marshal_TPM_AUTH(BYTE **ptr, UINT32 *length, TPM_AUTH *v)
139 {
140 if (tpm_marshal_TPM_NONCE(ptr, length, &v->nonceEven)
141 || tpm_marshal_BOOL(ptr, length, v->continueAuthSession)
142 || tpm_marshal_TPM_AUTHDATA(ptr, length, &v->auth)) return -1;
143 return 0;
144 }
145
tpm_unmarshal_TPM_AUTH(BYTE ** ptr,UINT32 * length,TPM_AUTH * v)146 int tpm_unmarshal_TPM_AUTH(BYTE **ptr, UINT32 *length, TPM_AUTH *v)
147 {
148 if (tpm_unmarshal_TPM_AUTHHANDLE(ptr, length, &v->authHandle)
149 || tpm_unmarshal_TPM_NONCE(ptr, length, &v->nonceOdd)
150 || tpm_unmarshal_BOOL(ptr, length, &v->continueAuthSession)
151 || tpm_unmarshal_TPM_AUTHDATA(ptr, length, &v->auth)) return -1;
152 return 0;
153 }
154
tpm_marshal_TPM_KEY_HANDLE_LIST(BYTE ** ptr,UINT32 * length,TPM_KEY_HANDLE_LIST * v)155 int tpm_marshal_TPM_KEY_HANDLE_LIST(BYTE **ptr, UINT32 *length, TPM_KEY_HANDLE_LIST *v)
156 {
157 if (tpm_marshal_UINT16(ptr, length, v->loaded)
158 || tpm_marshal_UINT32_ARRAY(ptr, length, v->handle, v->loaded)) return -1;
159 return 0;
160 }
161
tpm_marshal_TPM_CHANGEAUTH_VALIDATE(BYTE ** ptr,UINT32 * length,TPM_CHANGEAUTH_VALIDATE * v)162 int tpm_marshal_TPM_CHANGEAUTH_VALIDATE(BYTE **ptr, UINT32 *length, TPM_CHANGEAUTH_VALIDATE *v)
163 {
164 if (tpm_marshal_TPM_SECRET(ptr, length, &v->newAuthSecret)
165 || tpm_marshal_TPM_NONCE(ptr, length, &v->n1)) return -1;
166 return 0;
167 }
168
tpm_unmarshal_TPM_CHANGEAUTH_VALIDATE(BYTE ** ptr,UINT32 * length,TPM_CHANGEAUTH_VALIDATE * v)169 int tpm_unmarshal_TPM_CHANGEAUTH_VALIDATE(BYTE **ptr, UINT32 *length, TPM_CHANGEAUTH_VALIDATE *v)
170 {
171 if (tpm_unmarshal_TPM_SECRET(ptr, length, &v->newAuthSecret)
172 || tpm_unmarshal_TPM_NONCE(ptr, length, &v->n1)) return -1;
173 return 0;
174 }
175
tpm_marshal_TPM_COUNTER_VALUE(BYTE ** ptr,UINT32 * length,TPM_COUNTER_VALUE * v)176 int tpm_marshal_TPM_COUNTER_VALUE(BYTE **ptr, UINT32 *length, TPM_COUNTER_VALUE *v)
177 {
178 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
179 || tpm_marshal_BYTE_ARRAY(ptr, length, v->label, sizeof(v->label))
180 || tpm_marshal_TPM_ACTUAL_COUNT(ptr, length, v->counter)) return -1;
181 return 0;
182 }
183
tpm_unmarshal_TPM_COUNTER_VALUE(BYTE ** ptr,UINT32 * length,TPM_COUNTER_VALUE * v)184 int tpm_unmarshal_TPM_COUNTER_VALUE(BYTE **ptr, UINT32 *length, TPM_COUNTER_VALUE *v)
185 {
186 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
187 || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->label, sizeof(v->label))
188 || tpm_unmarshal_TPM_ACTUAL_COUNT(ptr, length, &v->counter)) return -1;
189 return 0;
190 }
191
tpm_marshal_TPM_PCR_SELECTION(BYTE ** ptr,UINT32 * length,TPM_PCR_SELECTION * v)192 int tpm_marshal_TPM_PCR_SELECTION(BYTE **ptr, UINT32 *length, TPM_PCR_SELECTION *v)
193 {
194 if (tpm_marshal_UINT16(ptr, length, v->sizeOfSelect)
195 || v->sizeOfSelect > sizeof(v->pcrSelect)
196 || tpm_marshal_BYTE_ARRAY(ptr, length, v->pcrSelect, v->sizeOfSelect)) return -1;
197 return 0;
198 }
199
tpm_unmarshal_TPM_PCR_SELECTION(BYTE ** ptr,UINT32 * length,TPM_PCR_SELECTION * v)200 int tpm_unmarshal_TPM_PCR_SELECTION(BYTE **ptr, UINT32 *length, TPM_PCR_SELECTION *v)
201 {
202 if (tpm_unmarshal_UINT16(ptr, length, &v->sizeOfSelect)
203 || v->sizeOfSelect > sizeof(v->pcrSelect)
204 || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->pcrSelect, v->sizeOfSelect)) return -1;
205 return 0;
206 }
207
tpm_marshal_TPM_PCR_COMPOSITE(BYTE ** ptr,UINT32 * length,TPM_PCR_COMPOSITE * v)208 int tpm_marshal_TPM_PCR_COMPOSITE(BYTE **ptr, UINT32 *length, TPM_PCR_COMPOSITE *v)
209 {
210 if (tpm_marshal_TPM_PCR_SELECTION(ptr, length, &v->select)
211 || tpm_marshal_UINT32(ptr, length, v->valueSize)
212 || v->valueSize > sizeof(v->pcrValue)
213 || tpm_marshal_TPM_PCRVALUE_ARRAY(ptr, length, v->pcrValue,
214 v->valueSize / sizeof(TPM_PCRVALUE))) return -1;
215 return 0;
216 }
217
tpm_unmarshal_TPM_PCR_COMPOSITE(BYTE ** ptr,UINT32 * length,TPM_PCR_COMPOSITE * v)218 int tpm_unmarshal_TPM_PCR_COMPOSITE(BYTE **ptr, UINT32 *length, TPM_PCR_COMPOSITE *v)
219 {
220 if (tpm_unmarshal_TPM_PCR_SELECTION(ptr, length, &v->select)
221 || tpm_unmarshal_UINT32(ptr, length, &v->valueSize)
222 || v->valueSize > sizeof(v->pcrValue)
223 || tpm_unmarshal_TPM_PCRVALUE_ARRAY(ptr, length, v->pcrValue,
224 v->valueSize / sizeof(TPM_PCRVALUE))) return -1;
225 return 0;
226 }
227
tpm_marshal_TPM_PCR_INFO(BYTE ** ptr,UINT32 * length,TPM_PCR_INFO * v)228 int tpm_marshal_TPM_PCR_INFO(BYTE **ptr, UINT32 *length, TPM_PCR_INFO *v)
229 {
230 if (v->tag == TPM_TAG_PCR_INFO_LONG) {
231 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
232 || tpm_marshal_TPM_LOCALITY_SELECTION(ptr, length, v->localityAtCreation)
233 || tpm_marshal_TPM_LOCALITY_SELECTION(ptr, length, v->localityAtRelease)
234 || tpm_marshal_TPM_PCR_SELECTION(ptr, length, &v->creationPCRSelection)
235 || tpm_marshal_TPM_PCR_SELECTION(ptr, length, &v->releasePCRSelection)
236 || tpm_marshal_TPM_COMPOSITE_HASH(ptr, length, &v->digestAtCreation)
237 || tpm_marshal_TPM_COMPOSITE_HASH(ptr, length, &v->digestAtRelease)) return -1;
238 } else {
239 if (tpm_marshal_TPM_PCR_SELECTION(ptr, length, &v->creationPCRSelection)
240 || tpm_marshal_TPM_COMPOSITE_HASH(ptr, length, &v->digestAtRelease)
241 || tpm_marshal_TPM_COMPOSITE_HASH(ptr, length, &v->digestAtCreation)) return -1;
242 }
243 return 0;
244 }
245
tpm_unmarshal_TPM_PCR_INFO(BYTE ** ptr,UINT32 * length,TPM_PCR_INFO * v)246 int tpm_unmarshal_TPM_PCR_INFO(BYTE **ptr, UINT32 *length, TPM_PCR_INFO *v)
247 {
248 if ((((UINT16)(*ptr)[0] << 8) | (*ptr)[1]) == TPM_TAG_PCR_INFO_LONG) {
249 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
250 || tpm_unmarshal_TPM_LOCALITY_SELECTION(ptr, length, &v->localityAtCreation)
251 || tpm_unmarshal_TPM_LOCALITY_SELECTION(ptr, length, &v->localityAtRelease)
252 || tpm_unmarshal_TPM_PCR_SELECTION(ptr, length, &v->creationPCRSelection)
253 || tpm_unmarshal_TPM_PCR_SELECTION(ptr, length, &v->releasePCRSelection)
254 || tpm_unmarshal_TPM_COMPOSITE_HASH(ptr, length, &v->digestAtCreation)
255 || tpm_unmarshal_TPM_COMPOSITE_HASH(ptr, length, &v->digestAtRelease)) return -1;
256 } else {
257 if (tpm_unmarshal_TPM_PCR_SELECTION(ptr, length, &v->creationPCRSelection)
258 || tpm_unmarshal_TPM_COMPOSITE_HASH(ptr, length, &v->digestAtRelease)
259 || tpm_unmarshal_TPM_COMPOSITE_HASH(ptr, length, &v->digestAtCreation)) return -1;
260 memcpy(&v->releasePCRSelection, &v->creationPCRSelection, sizeof(TPM_PCR_SELECTION));
261 v->tag = 0x0000;
262 v->localityAtCreation = 0;
263 v->localityAtRelease = 0;
264 }
265 return 0;
266 }
267
tpm_marshal_TPM_PCR_INFO_SHORT(BYTE ** ptr,UINT32 * length,TPM_PCR_INFO_SHORT * v)268 int tpm_marshal_TPM_PCR_INFO_SHORT(BYTE **ptr, UINT32 *length, TPM_PCR_INFO_SHORT *v)
269 {
270 if (tpm_marshal_TPM_PCR_SELECTION(ptr, length, &v->pcrSelection)
271 || tpm_marshal_TPM_LOCALITY_SELECTION(ptr, length, v->localityAtRelease)
272 || tpm_marshal_TPM_COMPOSITE_HASH(ptr, length, &v->digestAtRelease)) return -1;
273 return 0;
274 }
275
tpm_unmarshal_TPM_PCR_INFO_SHORT(BYTE ** ptr,UINT32 * length,TPM_PCR_INFO_SHORT * v)276 int tpm_unmarshal_TPM_PCR_INFO_SHORT(BYTE **ptr, UINT32 *length, TPM_PCR_INFO_SHORT *v)
277 {
278 if (tpm_unmarshal_TPM_PCR_SELECTION(ptr, length, &v->pcrSelection)
279 || tpm_unmarshal_TPM_LOCALITY_SELECTION(ptr, length, &v->localityAtRelease)
280 || tpm_unmarshal_TPM_COMPOSITE_HASH(ptr, length, &v->digestAtRelease)) return -1;
281 return 0;
282 }
283
tpm_marshal_TPM_PCR_ATTRIBUTES(BYTE ** ptr,UINT32 * length,TPM_PCR_ATTRIBUTES * v)284 int tpm_marshal_TPM_PCR_ATTRIBUTES(BYTE **ptr, UINT32 *length, TPM_PCR_ATTRIBUTES *v)
285 {
286 if (tpm_marshal_BOOL(ptr, length, v->pcrReset)
287 || tpm_marshal_TPM_LOCALITY_SELECTION(ptr, length, v->pcrResetLocal)
288 || tpm_marshal_TPM_LOCALITY_SELECTION(ptr, length, v->pcrExtendLocal)) return -1;
289 return 0;
290 }
291
tpm_unmarshal_TPM_PCR_ATTRIBUTES(BYTE ** ptr,UINT32 * length,TPM_PCR_ATTRIBUTES * v)292 int tpm_unmarshal_TPM_PCR_ATTRIBUTES(BYTE **ptr, UINT32 *length, TPM_PCR_ATTRIBUTES *v)
293 {
294 if (tpm_unmarshal_BOOL(ptr, length, &v->pcrReset)
295 || tpm_unmarshal_TPM_LOCALITY_SELECTION(ptr, length, &v->pcrResetLocal)
296 || tpm_unmarshal_TPM_LOCALITY_SELECTION(ptr, length, &v->pcrExtendLocal)) return -1;
297 return 0;
298 }
299
tpm_marshal_TPM_STORED_DATA(BYTE ** ptr,UINT32 * length,TPM_STORED_DATA * v)300 int tpm_marshal_TPM_STORED_DATA(BYTE **ptr, UINT32 *length, TPM_STORED_DATA *v)
301 {
302 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
303 || tpm_marshal_TPM_ENTITY_TYPE(ptr, length, v->et)
304 || tpm_marshal_UINT32(ptr, length, v->sealInfoSize)
305 || (v->sealInfoSize > 0
306 && tpm_marshal_TPM_PCR_INFO(ptr, length, &v->sealInfo))
307 || tpm_marshal_UINT32(ptr, length, v->encDataSize)
308 || tpm_marshal_BLOB(ptr, length, v->encData, v->encDataSize)) return -1;
309 return 0;
310 }
311
tpm_unmarshal_TPM_STORED_DATA(BYTE ** ptr,UINT32 * length,TPM_STORED_DATA * v)312 int tpm_unmarshal_TPM_STORED_DATA(BYTE **ptr, UINT32 *length, TPM_STORED_DATA *v)
313 {
314 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
315 || tpm_unmarshal_TPM_ENTITY_TYPE(ptr, length, &v->et)
316 || tpm_unmarshal_UINT32(ptr, length, &v->sealInfoSize)
317 || (v->sealInfoSize > 0
318 && tpm_unmarshal_TPM_PCR_INFO(ptr, length, &v->sealInfo))
319 || tpm_unmarshal_UINT32(ptr, length, &v->encDataSize)
320 || tpm_unmarshal_BLOB(ptr, length, &v->encData, v->encDataSize)) return -1;
321 return 0;
322 }
323
tpm_marshal_TPM_SEALED_DATA(BYTE ** ptr,UINT32 * length,TPM_SEALED_DATA * v)324 int tpm_marshal_TPM_SEALED_DATA(BYTE **ptr, UINT32 *length, TPM_SEALED_DATA *v)
325 {
326 if (tpm_marshal_TPM_PAYLOAD_TYPE(ptr, length, v->payload)
327 || tpm_marshal_TPM_SECRET(ptr, length, &v->authData)
328 || tpm_marshal_TPM_NONCE(ptr, length, &v->tpmProof)
329 || tpm_marshal_TPM_DIGEST(ptr, length, &v->storedDigest)
330 || tpm_marshal_UINT32(ptr, length, v->dataSize)
331 || tpm_marshal_BLOB(ptr, length, v->data, v->dataSize)) return -1;
332 return 0;
333 }
334
tpm_unmarshal_TPM_SEALED_DATA(BYTE ** ptr,UINT32 * length,TPM_SEALED_DATA * v)335 int tpm_unmarshal_TPM_SEALED_DATA(BYTE **ptr, UINT32 *length, TPM_SEALED_DATA *v)
336 {
337 if (tpm_unmarshal_TPM_PAYLOAD_TYPE(ptr, length, &v->payload)
338 || tpm_unmarshal_TPM_SECRET(ptr, length, &v->authData)
339 || tpm_unmarshal_TPM_NONCE(ptr, length, &v->tpmProof)
340 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->storedDigest)
341 || tpm_unmarshal_UINT32(ptr, length, &v->dataSize)
342 || tpm_unmarshal_BLOB(ptr, length, &v->data, v->dataSize)) return -1;
343 return 0;
344 }
345
tpm_marshal_TPM_SYMMETRIC_KEY(BYTE ** ptr,UINT32 * length,TPM_SYMMETRIC_KEY * v)346 int tpm_marshal_TPM_SYMMETRIC_KEY(BYTE **ptr, UINT32 *length, TPM_SYMMETRIC_KEY *v)
347 {
348 if (tpm_marshal_TPM_ALGORITHM_ID(ptr, length, v->algId)
349 || tpm_marshal_TPM_ENC_SCHEME(ptr, length, v->encScheme)
350 || tpm_marshal_UINT16(ptr, length, v->size)
351 || tpm_marshal_BLOB(ptr, length, v->data, v->size)) return -1;
352 return 0;
353 }
354
tpm_unmarshal_TPM_SYMMETRIC_KEY(BYTE ** ptr,UINT32 * length,TPM_SYMMETRIC_KEY * v)355 int tpm_unmarshal_TPM_SYMMETRIC_KEY(BYTE **ptr, UINT32 *length, TPM_SYMMETRIC_KEY *v)
356 {
357 if (tpm_unmarshal_TPM_ALGORITHM_ID(ptr, length, &v->algId)
358 || tpm_unmarshal_TPM_ENC_SCHEME(ptr, length, &v->encScheme)
359 || tpm_unmarshal_UINT16(ptr, length, &v->size)
360 || tpm_unmarshal_BLOB(ptr, length, &v->data, v->size)) return -1;
361 return 0;
362 }
363
tpm_marshal_TPM_SYMMETRIC_KEY_PARMS(BYTE ** ptr,UINT32 * length,TPM_SYMMETRIC_KEY_PARMS * v)364 int tpm_marshal_TPM_SYMMETRIC_KEY_PARMS(BYTE **ptr, UINT32 *length, TPM_SYMMETRIC_KEY_PARMS *v)
365 {
366 if (tpm_marshal_UINT32(ptr, length, v->keyLength)
367 || tpm_marshal_UINT32(ptr, length, v->blockSize)
368 || tpm_marshal_UINT32(ptr, length, v->ivSize)
369 || tpm_marshal_BLOB(ptr, length, v->IV, v->ivSize)) return -1;
370 return 0;
371 }
372
tpm_unmarshal_TPM_SYMMETRIC_KEY_PARMS(BYTE ** ptr,UINT32 * length,TPM_SYMMETRIC_KEY_PARMS * v)373 int tpm_unmarshal_TPM_SYMMETRIC_KEY_PARMS(BYTE **ptr, UINT32 *length, TPM_SYMMETRIC_KEY_PARMS *v)
374 {
375 if (tpm_unmarshal_UINT32(ptr, length, &v->keyLength)
376 || tpm_unmarshal_UINT32(ptr, length, &v->blockSize)
377 || tpm_unmarshal_UINT32(ptr, length, &v->ivSize)
378 || tpm_unmarshal_BLOB(ptr, length, &v->IV, v->ivSize)) return -1;
379 return 0;
380 }
381
tpm_marshal_TPM_RSA_KEY_PARMS(BYTE ** ptr,UINT32 * length,TPM_RSA_KEY_PARMS * v)382 int tpm_marshal_TPM_RSA_KEY_PARMS(BYTE **ptr, UINT32 *length, TPM_RSA_KEY_PARMS *v)
383 {
384 if (tpm_marshal_UINT32(ptr, length, v->keyLength)
385 || tpm_marshal_UINT32(ptr, length, v->numPrimes)
386 || tpm_marshal_UINT32(ptr, length, v->exponentSize)
387 || tpm_marshal_BLOB(ptr, length, v->exponent, v->exponentSize)) return -1;
388 return 0;
389 }
390
tpm_unmarshal_TPM_RSA_KEY_PARMS(BYTE ** ptr,UINT32 * length,TPM_RSA_KEY_PARMS * v)391 int tpm_unmarshal_TPM_RSA_KEY_PARMS(BYTE **ptr, UINT32 *length, TPM_RSA_KEY_PARMS *v)
392 {
393 if (tpm_unmarshal_UINT32(ptr, length, &v->keyLength)
394 || tpm_unmarshal_UINT32(ptr, length, &v->numPrimes)
395 || tpm_unmarshal_UINT32(ptr, length, &v->exponentSize)
396 || tpm_unmarshal_BLOB(ptr, length, &v->exponent, v->exponentSize)) return -1;
397 return 0;
398 }
399
tpm_marshal_TPM_KEY_PARMS(BYTE ** ptr,UINT32 * length,TPM_KEY_PARMS * v)400 int tpm_marshal_TPM_KEY_PARMS(BYTE **ptr, UINT32 *length, TPM_KEY_PARMS *v)
401 {
402 if (tpm_marshal_TPM_ALGORITHM_ID(ptr, length, v->algorithmID)
403 || tpm_marshal_TPM_ENC_SCHEME(ptr, length, v->encScheme)
404 || tpm_marshal_TPM_SIG_SCHEME(ptr, length, v->sigScheme)
405 || tpm_marshal_UINT32(ptr, length, v->parmSize)) return -1;
406 switch (v->algorithmID) {
407 case TPM_ALG_RSA:
408 if (tpm_marshal_TPM_RSA_KEY_PARMS(ptr, length, &v->parms.rsa)) return -1;
409 break;
410 case TPM_ALG_DES: case TPM_ALG_3DES: case TPM_ALG_AES192: case TPM_ALG_AES256:
411 if (tpm_marshal_TPM_SYMMETRIC_KEY_PARMS(ptr, length, &v->parms.skp)) return -1;
412 break;
413 default:
414 if (tpm_marshal_BLOB(ptr, length, v->parms.raw, v->parmSize)) return -1;
415 }
416 return 0;
417 }
418
tpm_unmarshal_TPM_KEY_PARMS(BYTE ** ptr,UINT32 * length,TPM_KEY_PARMS * v)419 int tpm_unmarshal_TPM_KEY_PARMS(BYTE **ptr, UINT32 *length, TPM_KEY_PARMS *v)
420 {
421 if (tpm_unmarshal_TPM_ALGORITHM_ID(ptr, length, &v->algorithmID)
422 || tpm_unmarshal_TPM_ENC_SCHEME(ptr, length, &v->encScheme)
423 || tpm_unmarshal_TPM_SIG_SCHEME(ptr, length, &v->sigScheme)
424 || tpm_unmarshal_UINT32(ptr, length, &v->parmSize)) return -1;
425 switch (v->algorithmID) {
426 case TPM_ALG_RSA:
427 if (tpm_unmarshal_TPM_RSA_KEY_PARMS(ptr, length, &v->parms.rsa)) return -1;
428 break;
429 case TPM_ALG_DES: case TPM_ALG_3DES: case TPM_ALG_AES192: case TPM_ALG_AES256:
430 if (tpm_unmarshal_TPM_SYMMETRIC_KEY_PARMS(ptr, length, &v->parms.skp)) return -1;
431 break;
432 default:
433 if (tpm_unmarshal_BLOB(ptr, length, &v->parms.raw, v->parmSize)) return -1;
434 }
435 return 0;
436 }
437
tpm_marshal_TPM_STORE_PUBKEY(BYTE ** ptr,UINT32 * length,TPM_STORE_PUBKEY * v)438 int tpm_marshal_TPM_STORE_PUBKEY(BYTE **ptr, UINT32 *length, TPM_STORE_PUBKEY *v)
439 {
440 if (tpm_marshal_UINT32(ptr, length, v->keyLength)
441 || tpm_marshal_BLOB(ptr, length, v->key, v->keyLength)) return -1;
442 return 0;
443 }
444
tpm_unmarshal_TPM_STORE_PUBKEY(BYTE ** ptr,UINT32 * length,TPM_STORE_PUBKEY * v)445 int tpm_unmarshal_TPM_STORE_PUBKEY(BYTE **ptr, UINT32 *length, TPM_STORE_PUBKEY *v)
446 {
447 if (tpm_unmarshal_UINT32(ptr, length, &v->keyLength)
448 || tpm_unmarshal_BLOB(ptr, length, &v->key, v->keyLength)) return -1;
449 return 0;
450 }
451
tpm_marshal_TPM_KEY(BYTE ** ptr,UINT32 * length,TPM_KEY * v)452 int tpm_marshal_TPM_KEY(BYTE **ptr, UINT32 *length, TPM_KEY *v)
453 {
454 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
455 || tpm_marshal_UINT16(ptr, length, v->fill)
456 || tpm_marshal_TPM_KEY_USAGE(ptr, length, v->keyUsage)
457 || tpm_marshal_TPM_KEY_FLAGS(ptr, length, v->keyFlags)
458 || tpm_marshal_TPM_AUTH_DATA_USAGE(ptr, length, v->authDataUsage)
459 || tpm_marshal_TPM_KEY_PARMS(ptr, length, &v->algorithmParms)
460 || tpm_marshal_UINT32(ptr, length, v->PCRInfoSize)
461 || (v->PCRInfoSize > 0
462 && tpm_marshal_TPM_PCR_INFO(ptr, length, &v->PCRInfo))
463 || tpm_marshal_TPM_STORE_PUBKEY(ptr, length, &v->pubKey)
464 || tpm_marshal_UINT32(ptr, length, v->encDataSize)
465 || tpm_marshal_BLOB(ptr, length, v->encData, v->encDataSize)) return -1;
466 return 0;
467 }
468
tpm_unmarshal_TPM_KEY(BYTE ** ptr,UINT32 * length,TPM_KEY * v)469 int tpm_unmarshal_TPM_KEY(BYTE **ptr, UINT32 *length, TPM_KEY *v)
470 {
471 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
472 || tpm_unmarshal_UINT16(ptr, length, &v->fill)
473 || tpm_unmarshal_TPM_KEY_USAGE(ptr, length, &v->keyUsage)
474 || tpm_unmarshal_TPM_KEY_FLAGS(ptr, length, &v->keyFlags)
475 || tpm_unmarshal_TPM_AUTH_DATA_USAGE(ptr, length, &v->authDataUsage)
476 || tpm_unmarshal_TPM_KEY_PARMS(ptr, length, &v->algorithmParms)
477 || tpm_unmarshal_UINT32(ptr, length, &v->PCRInfoSize)
478 || (v->PCRInfoSize > 0
479 && tpm_unmarshal_TPM_PCR_INFO(ptr, length, &v->PCRInfo))
480 || tpm_unmarshal_TPM_STORE_PUBKEY(ptr, length, &v->pubKey)
481 || tpm_unmarshal_UINT32(ptr, length, &v->encDataSize)
482 || tpm_unmarshal_BLOB(ptr, length, &v->encData, v->encDataSize)) return -1;
483 return 0;
484 }
485
tpm_marshal_TPM_PUBKEY(BYTE ** ptr,UINT32 * length,TPM_PUBKEY * v)486 int tpm_marshal_TPM_PUBKEY(BYTE **ptr, UINT32 *length, TPM_PUBKEY *v)
487 {
488 if (tpm_marshal_TPM_KEY_PARMS(ptr, length, &v->algorithmParms)
489 || tpm_marshal_TPM_STORE_PUBKEY(ptr, length, &v->pubKey)) return -1;
490 return 0;
491 }
492
tpm_unmarshal_TPM_PUBKEY(BYTE ** ptr,UINT32 * length,TPM_PUBKEY * v)493 int tpm_unmarshal_TPM_PUBKEY(BYTE **ptr, UINT32 *length, TPM_PUBKEY *v)
494 {
495 if (tpm_unmarshal_TPM_KEY_PARMS(ptr, length, &v->algorithmParms)
496 || tpm_unmarshal_TPM_STORE_PUBKEY(ptr, length, &v->pubKey)) return -1;
497 return 0;
498 }
499
tpm_marshal_TPM_STORE_PRIVKEY(BYTE ** ptr,UINT32 * length,TPM_STORE_PRIVKEY * v)500 int tpm_marshal_TPM_STORE_PRIVKEY(BYTE **ptr, UINT32 *length, TPM_STORE_PRIVKEY *v)
501 {
502 if (tpm_marshal_UINT32(ptr, length, v->keyLength)
503 || tpm_marshal_BLOB(ptr, length, v->key, v->keyLength)) return -1;
504 return 0;
505 }
506
tpm_unmarshal_TPM_STORE_PRIVKEY(BYTE ** ptr,UINT32 * length,TPM_STORE_PRIVKEY * v)507 int tpm_unmarshal_TPM_STORE_PRIVKEY(BYTE **ptr, UINT32 *length, TPM_STORE_PRIVKEY *v)
508 {
509 if (tpm_unmarshal_UINT32(ptr, length, &v->keyLength)
510 || tpm_unmarshal_BLOB(ptr, length, &v->key, v->keyLength)) return -1;
511 return 0;
512 }
513
tpm_marshal_TPM_STORE_ASYMKEY(BYTE ** ptr,UINT32 * length,TPM_STORE_ASYMKEY * v)514 int tpm_marshal_TPM_STORE_ASYMKEY(BYTE **ptr, UINT32 *length, TPM_STORE_ASYMKEY *v)
515 {
516 if (tpm_marshal_TPM_PAYLOAD_TYPE(ptr, length, v->payload)
517 || tpm_marshal_TPM_SECRET(ptr, length, &v->usageAuth)
518 || tpm_marshal_TPM_SECRET(ptr, length, &v->migrationAuth)
519 || tpm_marshal_TPM_DIGEST(ptr, length, &v->pubDataDigest)
520 || tpm_marshal_TPM_STORE_PRIVKEY(ptr, length, &v->privKey)) return -1;
521 return 0;
522 }
523
tpm_unmarshal_TPM_STORE_ASYMKEY(BYTE ** ptr,UINT32 * length,TPM_STORE_ASYMKEY * v)524 int tpm_unmarshal_TPM_STORE_ASYMKEY(BYTE **ptr, UINT32 *length, TPM_STORE_ASYMKEY *v)
525 {
526 if (tpm_unmarshal_TPM_PAYLOAD_TYPE(ptr, length, &v->payload)
527 || tpm_unmarshal_TPM_SECRET(ptr, length, &v->usageAuth)
528 || tpm_unmarshal_TPM_SECRET(ptr, length, &v->migrationAuth)
529 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->pubDataDigest)
530 || tpm_unmarshal_TPM_STORE_PRIVKEY(ptr, length, &v->privKey)) return -1;
531 return 0;
532 }
533
tpm_marshal_TPM_MIGRATIONKEYAUTH(BYTE ** ptr,UINT32 * length,TPM_MIGRATIONKEYAUTH * v)534 int tpm_marshal_TPM_MIGRATIONKEYAUTH(BYTE **ptr, UINT32 *length, TPM_MIGRATIONKEYAUTH *v)
535 {
536 if (tpm_marshal_TPM_PUBKEY(ptr, length, &v->migrationKey)
537 || tpm_marshal_TPM_MIGRATE_SCHEME(ptr, length, v->migrationScheme)
538 || tpm_marshal_TPM_DIGEST(ptr, length, &v->digest)) return -1;
539 return 0;
540 }
541
tpm_unmarshal_TPM_MIGRATIONKEYAUTH(BYTE ** ptr,UINT32 * length,TPM_MIGRATIONKEYAUTH * v)542 int tpm_unmarshal_TPM_MIGRATIONKEYAUTH(BYTE **ptr, UINT32 *length, TPM_MIGRATIONKEYAUTH *v)
543 {
544 if (tpm_unmarshal_TPM_PUBKEY(ptr, length, &v->migrationKey)
545 || tpm_unmarshal_TPM_MIGRATE_SCHEME(ptr, length, &v->migrationScheme)
546 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->digest)) return -1;
547 return 0;
548 }
549
tpm_marshal_TPM_CERTIFY_INFO(BYTE ** ptr,UINT32 * length,TPM_CERTIFY_INFO * v)550 int tpm_marshal_TPM_CERTIFY_INFO(BYTE **ptr, UINT32 *length, TPM_CERTIFY_INFO *v)
551 {
552 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
553 || tpm_marshal_BYTE(ptr, length, v->fill)
554 || tpm_marshal_TPM_PAYLOAD_TYPE(ptr, length, v->payloadType)
555 || tpm_marshal_TPM_KEY_USAGE(ptr, length, v->keyUsage)
556 || tpm_marshal_TPM_KEY_FLAGS(ptr, length, v->keyFlags)
557 || tpm_marshal_TPM_AUTH_DATA_USAGE(ptr, length, v->authDataUsage)
558 || tpm_marshal_TPM_KEY_PARMS(ptr, length, &v->algorithmParms)
559 || tpm_marshal_TPM_DIGEST(ptr, length, &v->pubkeyDigest)
560 || tpm_marshal_TPM_NONCE(ptr, length, &v->data)
561 || tpm_marshal_BOOL(ptr, length, v->parentPCRStatus)
562 || tpm_marshal_UINT32(ptr, length, v->PCRInfoSize)
563 || (v->PCRInfoSize > 0
564 && tpm_marshal_TPM_PCR_INFO(ptr, length, &v->PCRInfo))
565 || (v->tag == TPM_TAG_CERTIFY_INFO2
566 && tpm_marshal_UINT32(ptr, length, v->migrationAuthoritySize))
567 || (v->tag == TPM_TAG_CERTIFY_INFO2 && v->migrationAuthoritySize > 0
568 && tpm_marshal_BLOB(ptr, length, v->migrationAuthority,
569 v->migrationAuthoritySize))) return -1;
570 return 0;
571 }
572
tpm_unmarshal_TPM_CERTIFY_INFO(BYTE ** ptr,UINT32 * length,TPM_CERTIFY_INFO * v)573 int tpm_unmarshal_TPM_CERTIFY_INFO(BYTE **ptr, UINT32 *length, TPM_CERTIFY_INFO *v)
574 {
575 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
576 || tpm_unmarshal_BYTE(ptr, length, &v->fill)
577 || tpm_unmarshal_TPM_PAYLOAD_TYPE(ptr, length, &v->payloadType)
578 || tpm_unmarshal_TPM_KEY_USAGE(ptr, length, &v->keyUsage)
579 || tpm_unmarshal_TPM_KEY_FLAGS(ptr, length, &v->keyFlags)
580 || tpm_unmarshal_TPM_AUTH_DATA_USAGE(ptr, length, &v->authDataUsage)
581 || tpm_unmarshal_TPM_KEY_PARMS(ptr, length, &v->algorithmParms)
582 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->pubkeyDigest)
583 || tpm_unmarshal_TPM_NONCE(ptr, length, &v->data)
584 || tpm_unmarshal_BOOL(ptr, length, &v->parentPCRStatus)
585 || tpm_unmarshal_UINT32(ptr, length, &v->PCRInfoSize)
586 || (v->PCRInfoSize > 0
587 && tpm_unmarshal_TPM_PCR_INFO(ptr, length, &v->PCRInfo))
588 || (!(v->migrationAuthoritySize = 0) && v->tag == TPM_TAG_CERTIFY_INFO2
589 && tpm_unmarshal_UINT32(ptr, length, &v->migrationAuthoritySize))
590 || (v->tag == TPM_TAG_CERTIFY_INFO2 && v->migrationAuthoritySize > 0
591 && tpm_unmarshal_BLOB(ptr, length, &v->migrationAuthority,
592 v->migrationAuthoritySize))) return -1;
593 return 0;
594 }
595
tpm_marshal_TPM_IDENTITY_CONTENTS(BYTE ** ptr,UINT32 * length,TPM_IDENTITY_CONTENTS * v)596 int tpm_marshal_TPM_IDENTITY_CONTENTS(BYTE **ptr, UINT32 *length, TPM_IDENTITY_CONTENTS *v)
597 {
598 if (tpm_marshal_TPM_STRUCT_VER(ptr, length, &v->ver)
599 || tpm_marshal_UINT32(ptr, length, v->ordinal)
600 || tpm_marshal_TPM_CHOSENID_HASH(ptr, length, &v->labelPrivCADigest)
601 || tpm_marshal_TPM_PUBKEY(ptr, length, &v->identityPubKey)) return -1;
602 return 0;
603 }
604
tpm_unmarshal_TPM_IDENTITY_CONTENTS(BYTE ** ptr,UINT32 * length,TPM_IDENTITY_CONTENTS * v)605 int tpm_unmarshal_TPM_IDENTITY_CONTENTS(BYTE **ptr, UINT32 *length, TPM_IDENTITY_CONTENTS *v)
606 {
607 if (tpm_unmarshal_TPM_STRUCT_VER(ptr, length, &v->ver)
608 || tpm_unmarshal_UINT32(ptr, length, &v->ordinal)
609 || tpm_unmarshal_TPM_CHOSENID_HASH(ptr, length, &v->labelPrivCADigest)
610 || tpm_unmarshal_TPM_PUBKEY(ptr, length, &v->identityPubKey)) return -1;
611 return 0;
612 }
613
tpm_marshal_TPM_CURRENT_TICKS(BYTE ** ptr,UINT32 * length,TPM_CURRENT_TICKS * v)614 int tpm_marshal_TPM_CURRENT_TICKS(BYTE **ptr, UINT32 *length, TPM_CURRENT_TICKS *v)
615 {
616 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
617 || tpm_marshal_UINT64(ptr, length, v->currentTicks)
618 || tpm_marshal_UINT16(ptr, length, v->tickRate)
619 || tpm_marshal_TPM_NONCE(ptr, length, &v->tickNonce)) return -1;
620 return 0;
621 }
622
tpm_unmarshal_TPM_CURRENT_TICKS(BYTE ** ptr,UINT32 * length,TPM_CURRENT_TICKS * v)623 int tpm_unmarshal_TPM_CURRENT_TICKS(BYTE **ptr, UINT32 *length, TPM_CURRENT_TICKS *v)
624 {
625 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
626 || tpm_unmarshal_UINT64(ptr, length, &v->currentTicks)
627 || tpm_unmarshal_UINT16(ptr, length, &v->tickRate)
628 || tpm_unmarshal_TPM_NONCE(ptr, length, &v->tickNonce)) return -1;
629 return 0;
630 }
631
tpm_marshal_TPM_TRANSPORT_PUBLIC(BYTE ** ptr,UINT32 * length,TPM_TRANSPORT_PUBLIC * v)632 int tpm_marshal_TPM_TRANSPORT_PUBLIC(BYTE **ptr, UINT32 *length, TPM_TRANSPORT_PUBLIC *v)
633 {
634 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
635 || tpm_marshal_TPM_TRANSPORT_ATTRIBUTES(ptr, length, v->transAttributes)
636 || tpm_marshal_TPM_ALGORITHM_ID(ptr, length, v->algID)
637 || tpm_marshal_TPM_ENC_SCHEME(ptr, length, v->encScheme)) return -1;
638 return 0;
639 }
640
tpm_unmarshal_TPM_TRANSPORT_PUBLIC(BYTE ** ptr,UINT32 * length,TPM_TRANSPORT_PUBLIC * v)641 int tpm_unmarshal_TPM_TRANSPORT_PUBLIC(BYTE **ptr, UINT32 *length, TPM_TRANSPORT_PUBLIC *v)
642 {
643 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
644 || tpm_unmarshal_TPM_TRANSPORT_ATTRIBUTES(ptr, length, &v->transAttributes)
645 || tpm_unmarshal_TPM_ALGORITHM_ID(ptr, length, &v->algID)
646 || tpm_unmarshal_TPM_ENC_SCHEME(ptr, length, &v->encScheme)) return -1;
647 return 0;
648 }
649
tpm_marshal_TPM_TRANSPORT_INTERNAL(BYTE ** ptr,UINT32 * length,TPM_TRANSPORT_INTERNAL * v)650 int tpm_marshal_TPM_TRANSPORT_INTERNAL(BYTE **ptr, UINT32 *length, TPM_TRANSPORT_INTERNAL *v)
651 {
652 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
653 || tpm_marshal_TPM_AUTHDATA(ptr, length, &v->authData)
654 || tpm_marshal_TPM_TRANSPORT_PUBLIC(ptr, length, &v->transPublic)
655 || tpm_marshal_TPM_TRANSHANDLE(ptr, length, v->transHandle)
656 || tpm_marshal_TPM_NONCE(ptr, length, &v->transNonceEven)
657 || tpm_marshal_TPM_DIGEST(ptr, length, &v->transDigest)) return -1;
658 return 0;
659 }
660
tpm_unmarshal_TPM_TRANSPORT_INTERNAL(BYTE ** ptr,UINT32 * length,TPM_TRANSPORT_INTERNAL * v)661 int tpm_unmarshal_TPM_TRANSPORT_INTERNAL(BYTE **ptr, UINT32 *length, TPM_TRANSPORT_INTERNAL *v)
662 {
663 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
664 || tpm_unmarshal_TPM_AUTHDATA(ptr, length, &v->authData)
665 || tpm_unmarshal_TPM_TRANSPORT_PUBLIC(ptr, length, &v->transPublic)
666 || tpm_unmarshal_TPM_TRANSHANDLE(ptr, length, &v->transHandle)
667 || tpm_unmarshal_TPM_NONCE(ptr, length, &v->transNonceEven)
668 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->transDigest)) return -1;
669 return 0;
670 }
671
tpm_marshal_TPM_CONTEXT_BLOB(BYTE ** ptr,UINT32 * length,TPM_CONTEXT_BLOB * v)672 int tpm_marshal_TPM_CONTEXT_BLOB(BYTE **ptr, UINT32 *length, TPM_CONTEXT_BLOB *v)
673 {
674 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
675 || tpm_marshal_TPM_RESOURCE_TYPE(ptr, length, v->resourceType)
676 || tpm_marshal_TPM_HANDLE(ptr, length, v->handle)
677 || tpm_marshal_BYTE_ARRAY(ptr, length, v->label, sizeof(v->label))
678 || tpm_marshal_UINT32(ptr, length, v->contextCount)
679 || tpm_marshal_TPM_DIGEST(ptr, length, &v->integrityDigest)
680 || tpm_marshal_UINT32(ptr, length, v->additionalSize)
681 || tpm_marshal_BLOB(ptr, length, v->additionalData, v->additionalSize)
682 || tpm_marshal_UINT32(ptr, length, v->sensitiveSize)
683 || tpm_marshal_BLOB(ptr, length, v->sensitiveData, v->sensitiveSize)) return -1;
684 return 0;
685 }
686
tpm_unmarshal_TPM_CONTEXT_BLOB(BYTE ** ptr,UINT32 * length,TPM_CONTEXT_BLOB * v)687 int tpm_unmarshal_TPM_CONTEXT_BLOB(BYTE **ptr, UINT32 *length, TPM_CONTEXT_BLOB *v)
688 {
689 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
690 || tpm_unmarshal_TPM_RESOURCE_TYPE(ptr, length, &v->resourceType)
691 || tpm_unmarshal_TPM_HANDLE(ptr, length, &v->handle)
692 || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->label, sizeof(v->label))
693 || tpm_unmarshal_UINT32(ptr, length, &v->contextCount)
694 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->integrityDigest)
695 || tpm_unmarshal_UINT32(ptr, length, &v->additionalSize)
696 || tpm_unmarshal_BLOB(ptr, length, &v->additionalData, v->additionalSize)
697 || tpm_unmarshal_UINT32(ptr, length, &v->sensitiveSize)
698 || tpm_unmarshal_BLOB(ptr, length, &v->sensitiveData, v->sensitiveSize)) return -1;
699 return 0;
700 }
701
tpm_marshal_TPM_CONTEXT_SENSITIVE(BYTE ** ptr,UINT32 * length,TPM_CONTEXT_SENSITIVE * v)702 int tpm_marshal_TPM_CONTEXT_SENSITIVE(BYTE **ptr, UINT32 *length, TPM_CONTEXT_SENSITIVE *v)
703 {
704 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
705 || tpm_marshal_TPM_NONCE(ptr, length, &v->contextNonce)
706 || tpm_marshal_UINT32(ptr, length, v->internalSize)
707 || tpm_marshal_TPM_RESOURCE_TYPE(ptr, length, v->resourceType))
708 return -1;
709 switch (v->resourceType) {
710 case TPM_RT_KEY:
711 if (tpm_marshal_TPM_KEY_DATA(ptr, length, &v->internalData.key))
712 return -1;
713 break;
714 case TPM_RT_AUTH:
715 case TPM_RT_TRANS:
716 if (tpm_marshal_TPM_SESSION_DATA(ptr, length, &v->internalData.session))
717 return -1;
718 break;
719 case TPM_RT_DAA_TPM:
720 if (tpm_marshal_TPM_DAA_SESSION_DATA(ptr, length, &v->internalData.sessionDAA))
721 return -1;
722 break;
723 default:
724 return -1;
725 }
726 return 0;
727 }
728
tpm_unmarshal_TPM_CONTEXT_SENSITIVE(BYTE ** ptr,UINT32 * length,TPM_CONTEXT_SENSITIVE * v)729 int tpm_unmarshal_TPM_CONTEXT_SENSITIVE(BYTE **ptr, UINT32 *length, TPM_CONTEXT_SENSITIVE *v)
730 {
731 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
732 || tpm_unmarshal_TPM_NONCE(ptr, length, &v->contextNonce)
733 || tpm_unmarshal_UINT32(ptr, length, &v->internalSize)
734 || tpm_unmarshal_TPM_RESOURCE_TYPE(ptr, length, &v->resourceType))
735 return -1;
736 switch (v->resourceType) {
737 case TPM_RT_KEY:
738 if (tpm_unmarshal_TPM_KEY_DATA(ptr, length, &v->internalData.key))
739 return -1;
740 break;
741 case TPM_RT_AUTH:
742 case TPM_RT_TRANS:
743 if (tpm_unmarshal_TPM_SESSION_DATA(ptr, length, &v->internalData.session))
744 return -1;
745 break;
746 case TPM_RT_DAA_TPM:
747 if (tpm_unmarshal_TPM_DAA_SESSION_DATA(ptr, length, &v->internalData.sessionDAA))
748 return -1;
749 break;
750 default:
751 return -1;
752 }
753 return 0;
754 }
755
tpm_marshal_TPM_DAA_BLOB(BYTE ** ptr,UINT32 * length,TPM_DAA_BLOB * v)756 int tpm_marshal_TPM_DAA_BLOB(BYTE **ptr, UINT32 *length, TPM_DAA_BLOB *v)
757 {
758 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
759 || tpm_marshal_TPM_RESOURCE_TYPE(ptr, length, v->resourceType)
760 || tpm_marshal_BYTE_ARRAY(ptr, length, v->label, sizeof(v->label))
761 || tpm_marshal_TPM_DIGEST(ptr, length, &v->blobIntegrity)
762 || tpm_marshal_UINT32(ptr, length, v->additionalSize)
763 || tpm_marshal_BLOB(ptr, length, v->additionalData, v->additionalSize)
764 || tpm_marshal_UINT32(ptr, length, v->sensitiveSize)
765 || tpm_marshal_BLOB(ptr, length, v->sensitiveData, v->sensitiveSize))
766 return -1;
767 return 0;
768 }
769
tpm_unmarshal_TPM_DAA_BLOB(BYTE ** ptr,UINT32 * length,TPM_DAA_BLOB * v)770 int tpm_unmarshal_TPM_DAA_BLOB(BYTE **ptr, UINT32 *length, TPM_DAA_BLOB *v)
771 {
772 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
773 || tpm_unmarshal_TPM_RESOURCE_TYPE(ptr, length, &v->resourceType)
774 || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->label, sizeof(v->label))
775 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->blobIntegrity)
776 || tpm_unmarshal_UINT32(ptr, length, &v->additionalSize)
777 || tpm_unmarshal_BLOB(ptr, length, &v->additionalData, v->additionalSize)
778 || tpm_unmarshal_UINT32(ptr, length, &v->sensitiveSize)
779 || tpm_unmarshal_BLOB(ptr, length, &v->sensitiveData, v->sensitiveSize))
780 return -1;
781 return 0;
782 }
783
tpm_marshal_TPM_DAA_SENSITIVE(BYTE ** ptr,UINT32 * length,TPM_DAA_SENSITIVE * v)784 int tpm_marshal_TPM_DAA_SENSITIVE(BYTE **ptr, UINT32 *length, TPM_DAA_SENSITIVE *v)
785 {
786 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
787 || tpm_marshal_UINT32(ptr, length, v->internalSize)
788 || tpm_marshal_BYTE_ARRAY(ptr, length, v->internalData, v->internalSize))
789 return -1;
790 return 0;
791 }
792
tpm_unmarshal_TPM_DAA_SENSITIVE(BYTE ** ptr,UINT32 * length,TPM_DAA_SENSITIVE * v)793 int tpm_unmarshal_TPM_DAA_SENSITIVE(BYTE **ptr, UINT32 *length, TPM_DAA_SENSITIVE *v)
794 {
795 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
796 || tpm_unmarshal_UINT32(ptr, length, &v->internalSize)
797 || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->internalData, v->internalSize))
798 return -1;
799 return 0;
800 }
801
tpm_marshal_TPM_DAA_ISSUER(BYTE ** ptr,UINT32 * length,TPM_DAA_ISSUER * v)802 int tpm_marshal_TPM_DAA_ISSUER(BYTE **ptr, UINT32 *length, TPM_DAA_ISSUER *v)
803 {
804 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
805 || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_digest_R0)
806 || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_digest_R1)
807 || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_digest_S0)
808 || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_digest_S1)
809 || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_digest_n)
810 || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_digest_gamma)
811 || tpm_marshal_BYTE_ARRAY(ptr, length, v->DAA_generic_q, sizeof(v->DAA_generic_q)))
812 return -1;
813 return 0;
814 }
815
tpm_unmarshal_TPM_DAA_ISSUER(BYTE ** ptr,UINT32 * length,TPM_DAA_ISSUER * v)816 int tpm_unmarshal_TPM_DAA_ISSUER(BYTE **ptr, UINT32 *length, TPM_DAA_ISSUER *v)
817 {
818 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
819 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_digest_R0)
820 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_digest_R1)
821 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_digest_S0)
822 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_digest_S1)
823 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_digest_n)
824 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_digest_gamma)
825 || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->DAA_generic_q, sizeof(v->DAA_generic_q)))
826 return -1;
827 return 0;
828 }
829
tpm_marshal_TPM_DAA_TPM(BYTE ** ptr,UINT32 * length,TPM_DAA_TPM * v)830 int tpm_marshal_TPM_DAA_TPM(BYTE **ptr, UINT32 *length, TPM_DAA_TPM *v)
831 {
832 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
833 || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_digestIssuer)
834 || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_digest_v0)
835 || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_digest_v1)
836 || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_rekey)
837 || tpm_marshal_UINT32(ptr, length, v->DAA_count))
838 return -1;
839 return 0;
840 }
841
tpm_unmarshal_TPM_DAA_TPM(BYTE ** ptr,UINT32 * length,TPM_DAA_TPM * v)842 int tpm_unmarshal_TPM_DAA_TPM(BYTE **ptr, UINT32 *length, TPM_DAA_TPM *v)
843 {
844 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
845 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_digestIssuer)
846 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_digest_v0)
847 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_digest_v1)
848 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_rekey)
849 || tpm_unmarshal_UINT32(ptr, length, &v->DAA_count))
850 return -1;
851 return 0;
852 }
853
tpm_marshal_TPM_DAA_CONTEXT(BYTE ** ptr,UINT32 * length,TPM_DAA_CONTEXT * v)854 int tpm_marshal_TPM_DAA_CONTEXT(BYTE **ptr, UINT32 *length, TPM_DAA_CONTEXT *v)
855 {
856 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
857 || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_digestContext)
858 || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_digest)
859 || tpm_marshal_TPM_NONCE(ptr, length, &v->DAA_contextSeed)
860 || tpm_marshal_BYTE_ARRAY(ptr, length, v->DAA_scratch, sizeof(v->DAA_scratch))
861 || tpm_marshal_BYTE(ptr, length, v->DAA_stage))
862 return -1;
863 return 0;
864 }
865
tpm_unmarshal_TPM_DAA_CONTEXT(BYTE ** ptr,UINT32 * length,TPM_DAA_CONTEXT * v)866 int tpm_unmarshal_TPM_DAA_CONTEXT(BYTE **ptr, UINT32 *length, TPM_DAA_CONTEXT *v)
867 {
868 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
869 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_digestContext)
870 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_digest)
871 || tpm_unmarshal_TPM_NONCE(ptr, length, &v->DAA_contextSeed)
872 || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->DAA_scratch, sizeof(v->DAA_scratch))
873 || tpm_unmarshal_BYTE(ptr, length, &v->DAA_stage))
874 return -1;
875 return 0;
876 }
877
tpm_marshal_TPM_DAA_JOINDATA(BYTE ** ptr,UINT32 * length,TPM_DAA_JOINDATA * v)878 int tpm_marshal_TPM_DAA_JOINDATA(BYTE **ptr, UINT32 *length, TPM_DAA_JOINDATA *v)
879 {
880 if (tpm_marshal_BYTE_ARRAY(ptr, length, v->DAA_join_u0, sizeof(v->DAA_join_u0))
881 || tpm_marshal_BYTE_ARRAY(ptr, length, v->DAA_join_u1, sizeof(v->DAA_join_u1))
882 || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_digest_n0))
883 return -1;
884 return 0;
885 }
886
tpm_unmarshal_TPM_DAA_JOINDATA(BYTE ** ptr,UINT32 * length,TPM_DAA_JOINDATA * v)887 int tpm_unmarshal_TPM_DAA_JOINDATA(BYTE **ptr, UINT32 *length, TPM_DAA_JOINDATA *v)
888 {
889 if (tpm_unmarshal_BYTE_ARRAY(ptr, length, v->DAA_join_u0, sizeof(v->DAA_join_u0))
890 || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->DAA_join_u1, sizeof(v->DAA_join_u1))
891 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_digest_n0))
892 return -1;
893 return 0;
894 }
895
tpm_marshal_TPM_DAA_SESSION_DATA(BYTE ** ptr,UINT32 * length,TPM_DAA_SESSION_DATA * v)896 int tpm_marshal_TPM_DAA_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_DAA_SESSION_DATA *v)
897 {
898 if (tpm_marshal_BYTE(ptr, length, v->type)
899 || tpm_marshal_TPM_DAA_ISSUER(ptr, length, &v->DAA_issuerSettings)
900 || tpm_marshal_TPM_DAA_TPM(ptr, length, &v->DAA_tpmSpecific)
901 || tpm_marshal_TPM_DAA_CONTEXT(ptr, length, &v->DAA_session)
902 || tpm_marshal_TPM_DAA_JOINDATA(ptr, length, &v->DAA_joinSession)
903 || tpm_marshal_TPM_HANDLE(ptr, length, v->handle)) return -1;
904 return 0;
905 }
906
tpm_unmarshal_TPM_DAA_SESSION_DATA(BYTE ** ptr,UINT32 * length,TPM_DAA_SESSION_DATA * v)907 int tpm_unmarshal_TPM_DAA_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_DAA_SESSION_DATA *v)
908 {
909 if (tpm_unmarshal_BYTE(ptr, length, &v->type)
910 || tpm_unmarshal_TPM_DAA_ISSUER(ptr, length, &v->DAA_issuerSettings)
911 || tpm_unmarshal_TPM_DAA_TPM(ptr, length, &v->DAA_tpmSpecific)
912 || tpm_unmarshal_TPM_DAA_CONTEXT(ptr, length, &v->DAA_session)
913 || tpm_unmarshal_TPM_DAA_JOINDATA(ptr, length, &v->DAA_joinSession)
914 || tpm_unmarshal_TPM_HANDLE(ptr, length, &v->handle)) return -1;
915 return 0;
916 }
917
tpm_marshal_TPM_MSA_COMPOSITE(BYTE ** ptr,UINT32 * length,TPM_MSA_COMPOSITE * v)918 int tpm_marshal_TPM_MSA_COMPOSITE(BYTE **ptr, UINT32 *length, TPM_MSA_COMPOSITE *v)
919 {
920 UINT32 i;
921 if (tpm_marshal_UINT32(ptr, length, v->MSAlist))
922 return -1;
923 for (i = 0; i < v->MSAlist; i++) {
924 if (tpm_marshal_TPM_DIGEST(ptr, length, &v->migAuthDigest[i])) return -1;
925 }
926 return 0;
927 }
928
tpm_unmarshal_TPM_MSA_COMPOSITE(BYTE ** ptr,UINT32 * length,TPM_MSA_COMPOSITE * v)929 int tpm_unmarshal_TPM_MSA_COMPOSITE(BYTE **ptr, UINT32 *length, TPM_MSA_COMPOSITE *v)
930 {
931 UINT32 i;
932 if (tpm_unmarshal_UINT32(ptr, length, &v->MSAlist))
933 return -1;
934 if (v->MSAlist > MAX_MSA_COMPOSITE_ENTRIES) return -1;
935 for (i = 0; i < v->MSAlist; i++) {
936 if (tpm_unmarshal_TPM_DIGEST(ptr, length, &v->migAuthDigest[i])) return -1;
937 }
938 return 0;
939 }
940
tpm_marshal_TPM_CMK_AUTH(BYTE ** ptr,UINT32 * length,TPM_CMK_AUTH * v)941 int tpm_marshal_TPM_CMK_AUTH(BYTE **ptr, UINT32 *length, TPM_CMK_AUTH *v)
942 {
943 if (tpm_marshal_TPM_DIGEST(ptr, length, &v->migrationAuthorityDigest)
944 || tpm_marshal_TPM_DIGEST(ptr, length, &v->destinationKeyDigest)
945 || tpm_marshal_TPM_DIGEST(ptr, length, &v->sourceKeyDigest))
946 return -1;
947 return 0;
948 }
949
tpm_unmarshal_TPM_CMK_AUTH(BYTE ** ptr,UINT32 * length,TPM_CMK_AUTH * v)950 int tpm_unmarshal_TPM_CMK_AUTH(BYTE **ptr, UINT32 *length, TPM_CMK_AUTH *v)
951 {
952 if (tpm_unmarshal_TPM_DIGEST(ptr, length, &v->migrationAuthorityDigest)
953 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->destinationKeyDigest)
954 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->sourceKeyDigest))
955 return -1;
956 return 0;
957 }
958
tpm_marshal_TPM_SELECT_SIZE(BYTE ** ptr,UINT32 * length,TPM_SELECT_SIZE * v)959 int tpm_marshal_TPM_SELECT_SIZE(BYTE **ptr, UINT32 *length, TPM_SELECT_SIZE *v)
960 {
961 if (tpm_marshal_BYTE(ptr, length, v->major)
962 || tpm_marshal_BYTE(ptr, length, v->minor)
963 || tpm_marshal_UINT16(ptr, length, v->reqSize)) return -1;
964 return 0;
965 }
966
tpm_unmarshal_TPM_SELECT_SIZE(BYTE ** ptr,UINT32 * length,TPM_SELECT_SIZE * v)967 int tpm_unmarshal_TPM_SELECT_SIZE(BYTE **ptr, UINT32 *length, TPM_SELECT_SIZE *v)
968 {
969 if (tpm_unmarshal_BYTE(ptr, length, &v->major)
970 || tpm_unmarshal_BYTE(ptr, length, &v->minor)
971 || tpm_unmarshal_UINT16(ptr, length, &v->reqSize)) return -1;
972 return 0;
973 }
974
tpm_marshal_TPM_CAP_VERSION_INFO(BYTE ** ptr,UINT32 * length,TPM_CAP_VERSION_INFO * v)975 int tpm_marshal_TPM_CAP_VERSION_INFO(BYTE **ptr, UINT32 *length, TPM_CAP_VERSION_INFO *v)
976 {
977 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
978 || tpm_marshal_TPM_VERSION(ptr, length, &v->version)
979 || tpm_marshal_UINT16(ptr, length, v->specLevel)
980 || tpm_marshal_BYTE(ptr, length, v->errataRev)
981 || tpm_marshal_BYTE(ptr, length, v->tpmVendorID[0])
982 || tpm_marshal_BYTE(ptr, length, v->tpmVendorID[1])
983 || tpm_marshal_BYTE(ptr, length, v->tpmVendorID[2])
984 || tpm_marshal_BYTE(ptr, length, v->tpmVendorID[3])
985 || tpm_marshal_UINT16(ptr, length, v->vendorSpecificSize)
986 || tpm_marshal_BLOB(ptr, length, v->vendorSpecific, v->vendorSpecificSize))
987 return -1;
988 return 0;
989 }
990
tpm_unmarshal_TPM_CAP_VERSION_INFO(BYTE ** ptr,UINT32 * length,TPM_CAP_VERSION_INFO * v)991 int tpm_unmarshal_TPM_CAP_VERSION_INFO(BYTE **ptr, UINT32 *length, TPM_CAP_VERSION_INFO *v)
992 {
993 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
994 || tpm_unmarshal_TPM_VERSION(ptr, length, &v->version)
995 || tpm_unmarshal_UINT16(ptr, length, &v->specLevel)
996 || tpm_unmarshal_BYTE(ptr, length, &v->errataRev)
997 || tpm_unmarshal_BYTE(ptr, length, &v->tpmVendorID[0])
998 || tpm_unmarshal_BYTE(ptr, length, &v->tpmVendorID[1])
999 || tpm_unmarshal_BYTE(ptr, length, &v->tpmVendorID[2])
1000 || tpm_unmarshal_BYTE(ptr, length, &v->tpmVendorID[3])
1001 || tpm_unmarshal_UINT16(ptr, length, &v->vendorSpecificSize)
1002 || tpm_unmarshal_BLOB(ptr, length, &v->vendorSpecific, v->vendorSpecificSize))
1003 return -1;
1004 return 0;
1005 }
1006
tpm_marshal_TPM_ASYM_CA_CONTENTS(BYTE ** ptr,UINT32 * length,TPM_ASYM_CA_CONTENTS * v)1007 int tpm_marshal_TPM_ASYM_CA_CONTENTS(BYTE **ptr, UINT32 *length, TPM_ASYM_CA_CONTENTS *v)
1008 {
1009 if (tpm_marshal_TPM_SYMMETRIC_KEY(ptr, length, &v->sessionKey)
1010 || tpm_marshal_TPM_DIGEST(ptr, length, &v->idDigest))
1011 return -1;
1012 return 0;
1013 }
1014
tpm_unmarshal_TPM_ASYM_CA_CONTENTS(BYTE ** ptr,UINT32 * length,TPM_ASYM_CA_CONTENTS * v)1015 int tpm_unmarshal_TPM_ASYM_CA_CONTENTS(BYTE **ptr, UINT32 *length, TPM_ASYM_CA_CONTENTS *v)
1016 {
1017 if (tpm_unmarshal_TPM_SYMMETRIC_KEY(ptr, length, &v->sessionKey)
1018 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->idDigest))
1019 return -1;
1020 return 0;
1021 }
1022
tpm_marshal_TPM_QUOTE_INFO2(BYTE ** ptr,UINT32 * length,TPM_QUOTE_INFO2 * v)1023 int tpm_marshal_TPM_QUOTE_INFO2(BYTE **ptr, UINT32 *length, TPM_QUOTE_INFO2 *v)
1024 {
1025 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
1026 || tpm_marshal_BYTE(ptr, length, v->fixed[0])
1027 || tpm_marshal_BYTE(ptr, length, v->fixed[1])
1028 || tpm_marshal_BYTE(ptr, length, v->fixed[2])
1029 || tpm_marshal_BYTE(ptr, length, v->fixed[3])
1030 || tpm_marshal_TPM_NONCE(ptr, length, &v->externalData)
1031 || tpm_marshal_TPM_PCR_INFO_SHORT(ptr, length, &v->infoShort))
1032 return -1;
1033 return 0;
1034 }
1035
tpm_unmarshal_TPM_QUOTE_INFO2(BYTE ** ptr,UINT32 * length,TPM_QUOTE_INFO2 * v)1036 int tpm_unmarshal_TPM_QUOTE_INFO2(BYTE **ptr, UINT32 *length, TPM_QUOTE_INFO2 *v)
1037 {
1038 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
1039 || tpm_unmarshal_BYTE(ptr, length, &v->fixed[0])
1040 || tpm_unmarshal_BYTE(ptr, length, &v->fixed[1])
1041 || tpm_unmarshal_BYTE(ptr, length, &v->fixed[2])
1042 || tpm_unmarshal_BYTE(ptr, length, &v->fixed[3])
1043 || tpm_unmarshal_TPM_NONCE(ptr, length, &v->externalData)
1044 || tpm_unmarshal_TPM_PCR_INFO_SHORT(ptr, length, &v->infoShort))
1045 return -1;
1046 return 0;
1047 }
1048
tpm_marshal_TPM_EK_BLOB(BYTE ** ptr,UINT32 * length,TPM_EK_BLOB * v)1049 int tpm_marshal_TPM_EK_BLOB(BYTE **ptr, UINT32 *length, TPM_EK_BLOB *v)
1050 {
1051 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
1052 || tpm_marshal_TPM_EK_TYPE(ptr, length, v->ekType)
1053 || tpm_marshal_UINT32(ptr, length, v->blobSize)
1054 || tpm_marshal_BLOB(ptr, length, v->blob, v->blobSize))
1055 return -1;
1056 return 0;
1057 }
1058
tpm_unmarshal_TPM_EK_BLOB(BYTE ** ptr,UINT32 * length,TPM_EK_BLOB * v)1059 int tpm_unmarshal_TPM_EK_BLOB(BYTE **ptr, UINT32 *length, TPM_EK_BLOB *v)
1060 {
1061 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
1062 || tpm_unmarshal_TPM_EK_TYPE(ptr, length, &v->ekType)
1063 || tpm_unmarshal_UINT32(ptr, length, &v->blobSize)
1064 || tpm_unmarshal_BLOB(ptr, length, &v->blob, v->blobSize))
1065 return -1;
1066 return 0;
1067 }
1068
tpm_marshal_TPM_EK_BLOB_ACTIVATE(BYTE ** ptr,UINT32 * length,TPM_EK_BLOB_ACTIVATE * v)1069 int tpm_marshal_TPM_EK_BLOB_ACTIVATE(BYTE **ptr, UINT32 *length, TPM_EK_BLOB_ACTIVATE *v)
1070 {
1071 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
1072 || tpm_marshal_TPM_SYMMETRIC_KEY(ptr, length, &v->sessionKey)
1073 || tpm_marshal_TPM_DIGEST(ptr, length, &v->idDigest)
1074 || tpm_marshal_TPM_PCR_INFO_SHORT(ptr, length, &v->pcrInfo))
1075 return -1;
1076 return 0;
1077 }
1078
tpm_unmarshal_TPM_EK_BLOB_ACTIVATE(BYTE ** ptr,UINT32 * length,TPM_EK_BLOB_ACTIVATE * v)1079 int tpm_unmarshal_TPM_EK_BLOB_ACTIVATE(BYTE **ptr, UINT32 *length, TPM_EK_BLOB_ACTIVATE *v)
1080 {
1081 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
1082 || tpm_unmarshal_TPM_SYMMETRIC_KEY(ptr, length, &v->sessionKey)
1083 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->idDigest)
1084 || tpm_unmarshal_TPM_PCR_INFO_SHORT(ptr, length, &v->pcrInfo))
1085 return -1;
1086 return 0;
1087 }
1088
tpm_marshal_TPM_NV_ATTRIBUTES(BYTE ** ptr,UINT32 * length,TPM_NV_ATTRIBUTES * v)1089 int tpm_marshal_TPM_NV_ATTRIBUTES(BYTE **ptr, UINT32 *length, TPM_NV_ATTRIBUTES *v)
1090 {
1091 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
1092 || tpm_marshal_UINT32(ptr, length, v->attributes)) return -1;
1093 return 0;
1094 }
1095
tpm_unmarshal_TPM_NV_ATTRIBUTES(BYTE ** ptr,UINT32 * length,TPM_NV_ATTRIBUTES * v)1096 int tpm_unmarshal_TPM_NV_ATTRIBUTES(BYTE **ptr, UINT32 *length, TPM_NV_ATTRIBUTES *v)
1097 {
1098 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
1099 || tpm_unmarshal_UINT32(ptr, length, &v->attributes)) return -1;
1100 return 0;
1101 }
1102
tpm_marshal_TPM_NV_DATA_PUBLIC(BYTE ** ptr,UINT32 * length,TPM_NV_DATA_PUBLIC * v)1103 int tpm_marshal_TPM_NV_DATA_PUBLIC(BYTE **ptr, UINT32 *length, TPM_NV_DATA_PUBLIC *v)
1104 {
1105 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
1106 || tpm_marshal_TPM_NV_INDEX(ptr, length, v->nvIndex)
1107 || tpm_marshal_TPM_PCR_INFO_SHORT(ptr, length, &v->pcrInfoRead)
1108 || tpm_marshal_TPM_PCR_INFO_SHORT(ptr, length, &v->pcrInfoWrite)
1109 || tpm_marshal_TPM_NV_ATTRIBUTES(ptr, length, &v->permission)
1110 || tpm_marshal_BOOL(ptr, length, v->bReadSTClear)
1111 || tpm_marshal_BOOL(ptr, length, v->bWriteSTClear)
1112 || tpm_marshal_BOOL(ptr, length, v->bWriteDefine)
1113 || tpm_marshal_UINT32(ptr, length, v->dataSize)) return -1;
1114 return 0;
1115 }
1116
tpm_unmarshal_TPM_NV_DATA_PUBLIC(BYTE ** ptr,UINT32 * length,TPM_NV_DATA_PUBLIC * v)1117 int tpm_unmarshal_TPM_NV_DATA_PUBLIC(BYTE **ptr, UINT32 *length, TPM_NV_DATA_PUBLIC *v)
1118 {
1119 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
1120 || tpm_unmarshal_TPM_NV_INDEX(ptr, length, &v->nvIndex)
1121 || tpm_unmarshal_TPM_PCR_INFO_SHORT(ptr, length, &v->pcrInfoRead)
1122 || tpm_unmarshal_TPM_PCR_INFO_SHORT(ptr, length, &v->pcrInfoWrite)
1123 || tpm_unmarshal_TPM_NV_ATTRIBUTES(ptr, length, &v->permission)
1124 || tpm_unmarshal_BOOL(ptr, length, &v->bReadSTClear)
1125 || tpm_unmarshal_BOOL(ptr, length, &v->bWriteSTClear)
1126 || tpm_unmarshal_BOOL(ptr, length, &v->bWriteDefine)
1127 || tpm_unmarshal_UINT32(ptr, length, &v->dataSize)) return -1;
1128 return 0;
1129 }
1130
tpm_marshal_TPM_NV_DATA_SENSITIVE(BYTE ** ptr,UINT32 * length,TPM_NV_DATA_SENSITIVE * v)1131 int tpm_marshal_TPM_NV_DATA_SENSITIVE(BYTE **ptr, UINT32 *length, TPM_NV_DATA_SENSITIVE *v)
1132 {
1133 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
1134 || tpm_marshal_TPM_NV_DATA_PUBLIC(ptr, length, &v->pubInfo)
1135 || tpm_marshal_TPM_AUTHDATA(ptr, length, &v->authValue)
1136 || tpm_marshal_UINT32(ptr, length, v->dataIndex)) return -1;
1137 return 0;
1138 }
1139
tpm_unmarshal_TPM_NV_DATA_SENSITIVE(BYTE ** ptr,UINT32 * length,TPM_NV_DATA_SENSITIVE * v)1140 int tpm_unmarshal_TPM_NV_DATA_SENSITIVE(BYTE **ptr, UINT32 *length, TPM_NV_DATA_SENSITIVE *v)
1141 {
1142 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
1143 || tpm_unmarshal_TPM_NV_DATA_PUBLIC(ptr, length, &v->pubInfo)
1144 || tpm_unmarshal_TPM_AUTHDATA(ptr, length, &v->authValue)
1145 || tpm_unmarshal_UINT32(ptr, length, &v->dataIndex)) return -1;
1146 return 0;
1147 }
1148
tpm_marshal_TPM_DELEGATIONS(BYTE ** ptr,UINT32 * length,TPM_DELEGATIONS * v)1149 int tpm_marshal_TPM_DELEGATIONS(BYTE **ptr, UINT32 *length, TPM_DELEGATIONS *v)
1150 {
1151 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
1152 || tpm_marshal_UINT32(ptr, length, v->delegateType)
1153 || tpm_marshal_UINT32(ptr, length, v->per1)
1154 || tpm_marshal_UINT32(ptr, length, v->per2)) return -1;
1155 return 0;
1156 }
1157
tpm_unmarshal_TPM_DELEGATIONS(BYTE ** ptr,UINT32 * length,TPM_DELEGATIONS * v)1158 int tpm_unmarshal_TPM_DELEGATIONS(BYTE **ptr, UINT32 *length, TPM_DELEGATIONS *v)
1159 {
1160 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
1161 || tpm_unmarshal_UINT32(ptr, length, &v->delegateType)
1162 || tpm_unmarshal_UINT32(ptr, length, &v->per1)
1163 || tpm_unmarshal_UINT32(ptr, length, &v->per2)) return -1;
1164 return 0;
1165 }
1166
tpm_marshal_TPM_FAMILY_LABEL(BYTE ** ptr,UINT32 * length,TPM_FAMILY_LABEL * v)1167 int tpm_marshal_TPM_FAMILY_LABEL(BYTE **ptr, UINT32 *length, TPM_FAMILY_LABEL *v)
1168 {
1169 if (tpm_marshal_BYTE(ptr, length, v->label)) return -1;
1170 return 0;
1171 }
1172
tpm_unmarshal_TPM_FAMILY_LABEL(BYTE ** ptr,UINT32 * length,TPM_FAMILY_LABEL * v)1173 int tpm_unmarshal_TPM_FAMILY_LABEL(BYTE **ptr, UINT32 *length, TPM_FAMILY_LABEL *v)
1174 {
1175 if (tpm_unmarshal_BYTE(ptr, length, &v->label)) return -1;
1176 return 0;
1177 }
1178
tpm_marshal_TPM_FAMILY_TABLE_ENTRY(BYTE ** ptr,UINT32 * length,TPM_FAMILY_TABLE_ENTRY * v)1179 int tpm_marshal_TPM_FAMILY_TABLE_ENTRY(BYTE **ptr, UINT32 *length, TPM_FAMILY_TABLE_ENTRY *v)
1180 {
1181 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
1182 || tpm_marshal_TPM_FAMILY_LABEL(ptr, length, &v->familyLabel)
1183 || tpm_marshal_TPM_FAMILY_ID(ptr, length, v->familyID)
1184 || tpm_marshal_TPM_FAMILY_VERIFICATION(ptr, length, v->verificationCount)
1185 || tpm_marshal_TPM_FAMILY_FLAGS(ptr, length, v->flags)) return -1;
1186 return 0;
1187 }
1188
tpm_unmarshal_TPM_FAMILY_TABLE_ENTRY(BYTE ** ptr,UINT32 * length,TPM_FAMILY_TABLE_ENTRY * v)1189 int tpm_unmarshal_TPM_FAMILY_TABLE_ENTRY(BYTE **ptr, UINT32 *length, TPM_FAMILY_TABLE_ENTRY *v)
1190 {
1191 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
1192 || tpm_unmarshal_TPM_FAMILY_LABEL(ptr, length, &v->familyLabel)
1193 || tpm_unmarshal_TPM_FAMILY_ID(ptr, length, &v->familyID)
1194 || tpm_unmarshal_TPM_FAMILY_VERIFICATION(ptr, length, &v->verificationCount)
1195 || tpm_unmarshal_TPM_FAMILY_FLAGS(ptr, length, &v->flags)) return -1;
1196 return 0;
1197 }
1198
tpm_marshal_TPM_DELEGATE_LABEL(BYTE ** ptr,UINT32 * length,TPM_DELEGATE_LABEL * v)1199 int tpm_marshal_TPM_DELEGATE_LABEL(BYTE **ptr, UINT32 *length, TPM_DELEGATE_LABEL *v)
1200 {
1201 if (tpm_marshal_BYTE(ptr, length, v->label)) return -1;
1202 return 0;
1203 }
1204
tpm_unmarshal_TPM_DELEGATE_LABEL(BYTE ** ptr,UINT32 * length,TPM_DELEGATE_LABEL * v)1205 int tpm_unmarshal_TPM_DELEGATE_LABEL(BYTE **ptr, UINT32 *length, TPM_DELEGATE_LABEL *v)
1206 {
1207 if (tpm_unmarshal_BYTE(ptr, length, &v->label)) return -1;
1208 return 0;
1209 }
1210
tpm_marshal_TPM_DELEGATE_PUBLIC(BYTE ** ptr,UINT32 * length,TPM_DELEGATE_PUBLIC * v)1211 int tpm_marshal_TPM_DELEGATE_PUBLIC(BYTE **ptr, UINT32 *length, TPM_DELEGATE_PUBLIC *v)
1212 {
1213 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
1214 || tpm_marshal_TPM_DELEGATE_LABEL(ptr, length, &v->rowLabel)
1215 || tpm_marshal_TPM_PCR_INFO_SHORT(ptr, length, &v->pcrInfo)
1216 || tpm_marshal_TPM_DELEGATIONS(ptr, length, &v->permissions)
1217 || tpm_marshal_TPM_FAMILY_ID(ptr, length, v->familyID)
1218 || tpm_marshal_TPM_FAMILY_VERIFICATION(ptr, length, v->verificationCount)) return -1;
1219 return 0;
1220 }
1221
tpm_unmarshal_TPM_DELEGATE_PUBLIC(BYTE ** ptr,UINT32 * length,TPM_DELEGATE_PUBLIC * v)1222 int tpm_unmarshal_TPM_DELEGATE_PUBLIC(BYTE **ptr, UINT32 *length, TPM_DELEGATE_PUBLIC *v)
1223 {
1224 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
1225 || tpm_unmarshal_TPM_DELEGATE_LABEL(ptr, length, &v->rowLabel)
1226 || tpm_unmarshal_TPM_PCR_INFO_SHORT(ptr, length, &v->pcrInfo)
1227 || tpm_unmarshal_TPM_DELEGATIONS(ptr, length, &v->permissions)
1228 || tpm_unmarshal_TPM_FAMILY_ID(ptr, length, &v->familyID)
1229 || tpm_unmarshal_TPM_FAMILY_VERIFICATION(ptr, length, &v->verificationCount)) return -1;
1230 return 0;
1231 }
1232
tpm_marshal_TPM_DELEGATE_PUBLIC_ARRAY(BYTE ** ptr,UINT32 * length,TPM_DELEGATE_PUBLIC * v,UINT32 n)1233 int tpm_marshal_TPM_DELEGATE_PUBLIC_ARRAY(BYTE **ptr, UINT32 *length,
1234 TPM_DELEGATE_PUBLIC *v, UINT32 n)
1235 {
1236 UINT32 i;
1237 for (i = 0; i < n; i++) {
1238 if (tpm_marshal_TPM_DELEGATE_PUBLIC(ptr, length, &v[i])) return -1;
1239 }
1240 return 0;
1241 }
1242
tpm_unmarshal_TPM_DELEGATE_PUBLIC_ARRAY(BYTE ** ptr,UINT32 * length,TPM_DELEGATE_PUBLIC * v,UINT32 n)1243 int tpm_unmarshal_TPM_DELEGATE_PUBLIC_ARRAY(BYTE **ptr, UINT32 *length,
1244 TPM_DELEGATE_PUBLIC *v, UINT32 n)
1245 {
1246 UINT32 i;
1247 for (i = 0; i < n; i++) {
1248 if (tpm_unmarshal_TPM_DELEGATE_PUBLIC(ptr, length, &v[i])) return -1;
1249 }
1250 return 0;
1251 }
1252
tpm_marshal_TPM_DELEGATE_TABLE_ROW(BYTE ** ptr,UINT32 * length,TPM_DELEGATE_TABLE_ROW * v)1253 int tpm_marshal_TPM_DELEGATE_TABLE_ROW(BYTE **ptr, UINT32 *length, TPM_DELEGATE_TABLE_ROW *v)
1254 {
1255 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
1256 || tpm_marshal_TPM_DELEGATE_PUBLIC(ptr, length, &v->pub)
1257 || tpm_marshal_TPM_SECRET(ptr, length, &v->authValue)) return -1;
1258 return 0;
1259 }
1260
tpm_unmarshal_TPM_DELEGATE_TABLE_ROW(BYTE ** ptr,UINT32 * length,TPM_DELEGATE_TABLE_ROW * v)1261 int tpm_unmarshal_TPM_DELEGATE_TABLE_ROW(BYTE **ptr, UINT32 *length, TPM_DELEGATE_TABLE_ROW *v)
1262 {
1263 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
1264 || tpm_unmarshal_TPM_DELEGATE_PUBLIC(ptr, length, &v->pub)
1265 || tpm_unmarshal_TPM_SECRET(ptr, length, &v->authValue)) return -1;
1266 return 0;
1267 }
1268
tpm_marshal_TPM_DELEGATE_SENSITIVE(BYTE ** ptr,UINT32 * length,TPM_DELEGATE_SENSITIVE * v)1269 int tpm_marshal_TPM_DELEGATE_SENSITIVE(BYTE **ptr, UINT32 *length, TPM_DELEGATE_SENSITIVE *v)
1270 {
1271 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
1272 || tpm_marshal_TPM_SECRET(ptr, length, &v->authValue)) return -1;
1273 return 0;
1274 }
1275
tpm_unmarshal_TPM_DELEGATE_SENSITIVE(BYTE ** ptr,UINT32 * length,TPM_DELEGATE_SENSITIVE * v)1276 int tpm_unmarshal_TPM_DELEGATE_SENSITIVE(BYTE **ptr, UINT32 *length, TPM_DELEGATE_SENSITIVE *v)
1277 {
1278 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
1279 || tpm_unmarshal_TPM_SECRET(ptr, length, &v->authValue)) return -1;
1280 return 0;
1281 }
1282
tpm_marshal_TPM_DELEGATE_OWNER_BLOB(BYTE ** ptr,UINT32 * length,TPM_DELEGATE_OWNER_BLOB * v)1283 int tpm_marshal_TPM_DELEGATE_OWNER_BLOB(BYTE **ptr, UINT32 *length, TPM_DELEGATE_OWNER_BLOB *v)
1284 {
1285 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
1286 || tpm_marshal_TPM_DELEGATE_PUBLIC(ptr, length, &v->pub)
1287 || tpm_marshal_TPM_DIGEST(ptr, length, &v->integrityDigest)
1288 || tpm_marshal_UINT32(ptr, length, v->additionalSize)
1289 || tpm_marshal_BLOB(ptr, length, v->additionalArea, v->additionalSize)
1290 || tpm_marshal_UINT32(ptr, length, v->sensitiveSize)
1291 || tpm_marshal_BLOB(ptr, length, v->sensitiveArea, v->sensitiveSize)) return -1;
1292 return 0;
1293 }
1294
tpm_unmarshal_TPM_DELEGATE_OWNER_BLOB(BYTE ** ptr,UINT32 * length,TPM_DELEGATE_OWNER_BLOB * v)1295 int tpm_unmarshal_TPM_DELEGATE_OWNER_BLOB(BYTE **ptr, UINT32 *length, TPM_DELEGATE_OWNER_BLOB *v)
1296 {
1297 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
1298 || tpm_unmarshal_TPM_DELEGATE_PUBLIC(ptr, length, &v->pub)
1299 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->integrityDigest)
1300 || tpm_unmarshal_UINT32(ptr, length, &v->additionalSize)
1301 || tpm_unmarshal_BLOB(ptr, length, &v->additionalArea, v->additionalSize)
1302 || tpm_unmarshal_UINT32(ptr, length, &v->sensitiveSize)
1303 || tpm_unmarshal_BLOB(ptr, length, &v->sensitiveArea, v->sensitiveSize)) return -1;
1304 return 0;
1305 }
1306
tpm_marshal_TPM_DELEGATE_KEY_BLOB(BYTE ** ptr,UINT32 * length,TPM_DELEGATE_KEY_BLOB * v)1307 int tpm_marshal_TPM_DELEGATE_KEY_BLOB(BYTE **ptr, UINT32 *length, TPM_DELEGATE_KEY_BLOB *v)
1308 {
1309 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
1310 || tpm_marshal_TPM_DELEGATE_PUBLIC(ptr, length, &v->pub)
1311 || tpm_marshal_TPM_DIGEST(ptr, length, &v->integrityDigest)
1312 || tpm_marshal_TPM_DIGEST(ptr, length, &v->pubKeyDigest)
1313 || tpm_marshal_UINT32(ptr, length, v->additionalSize)
1314 || tpm_marshal_BLOB(ptr, length, v->additionalArea, v->additionalSize)
1315 || tpm_marshal_UINT32(ptr, length, v->sensitiveSize)
1316 || tpm_marshal_BLOB(ptr, length, v->sensitiveArea, v->sensitiveSize)) return -1;
1317 return 0;
1318 }
1319
tpm_unmarshal_TPM_DELEGATE_KEY_BLOB(BYTE ** ptr,UINT32 * length,TPM_DELEGATE_KEY_BLOB * v)1320 int tpm_unmarshal_TPM_DELEGATE_KEY_BLOB(BYTE **ptr, UINT32 *length, TPM_DELEGATE_KEY_BLOB *v)
1321 {
1322 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
1323 || tpm_unmarshal_TPM_DELEGATE_PUBLIC(ptr, length, &v->pub)
1324 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->integrityDigest)
1325 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->pubKeyDigest)
1326 || tpm_unmarshal_UINT32(ptr, length, &v->additionalSize)
1327 || tpm_unmarshal_BLOB(ptr, length, &v->additionalArea, v->additionalSize)
1328 || tpm_unmarshal_UINT32(ptr, length, &v->sensitiveSize)
1329 || tpm_unmarshal_BLOB(ptr, length, &v->sensitiveArea, v->sensitiveSize)) return -1;
1330 return 0;
1331 }
1332
tpm_marshal_TPM_PERMANENT_FLAGS(BYTE ** ptr,UINT32 * length,TPM_PERMANENT_FLAGS * v)1333 int tpm_marshal_TPM_PERMANENT_FLAGS(BYTE **ptr, UINT32 *length, TPM_PERMANENT_FLAGS *v)
1334 {
1335 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
1336 || tpm_marshal_BOOL(ptr, length, v->disable)
1337 || tpm_marshal_BOOL(ptr, length, v->ownership)
1338 || tpm_marshal_BOOL(ptr, length, v->deactivated)
1339 || tpm_marshal_BOOL(ptr, length, v->readPubek)
1340 || tpm_marshal_BOOL(ptr, length, v->disableOwnerClear)
1341 || tpm_marshal_BOOL(ptr, length, v->allowMaintenance)
1342 || tpm_marshal_BOOL(ptr, length, v->physicalPresenceLifetimeLock)
1343 || tpm_marshal_BOOL(ptr, length, v->physicalPresenceHWEnable)
1344 || tpm_marshal_BOOL(ptr, length, v->physicalPresenceCMDEnable)
1345 || tpm_marshal_BOOL(ptr, length, v->CEKPUsed)
1346 || tpm_marshal_BOOL(ptr, length, v->TPMpost)
1347 || tpm_marshal_BOOL(ptr, length, v->TPMpostLock)
1348 || tpm_marshal_BOOL(ptr, length, v->FIPS)
1349 || tpm_marshal_BOOL(ptr, length, v->operator)
1350 || tpm_marshal_BOOL(ptr, length, v->enableRevokeEK)
1351 || tpm_marshal_BOOL(ptr, length, v->nvLocked)
1352 || tpm_marshal_BOOL(ptr, length, v->readSRKPub)
1353 || tpm_marshal_BOOL(ptr, length, v->tpmEstablished)
1354 || tpm_marshal_BOOL(ptr, length, v->maintenanceDone)
1355 || tpm_marshal_BOOL(ptr, length, v->disableFullDALogicInfo)) return -1;
1356 return 0;
1357 }
1358
tpm_unmarshal_TPM_PERMANENT_FLAGS(BYTE ** ptr,UINT32 * length,TPM_PERMANENT_FLAGS * v)1359 int tpm_unmarshal_TPM_PERMANENT_FLAGS(BYTE **ptr, UINT32 *length, TPM_PERMANENT_FLAGS *v)
1360 {
1361 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
1362 || tpm_unmarshal_BOOL(ptr, length, &v->disable)
1363 || tpm_unmarshal_BOOL(ptr, length, &v->ownership)
1364 || tpm_unmarshal_BOOL(ptr, length, &v->deactivated)
1365 || tpm_unmarshal_BOOL(ptr, length, &v->readPubek)
1366 || tpm_unmarshal_BOOL(ptr, length, &v->disableOwnerClear)
1367 || tpm_unmarshal_BOOL(ptr, length, &v->allowMaintenance)
1368 || tpm_unmarshal_BOOL(ptr, length, &v->physicalPresenceLifetimeLock)
1369 || tpm_unmarshal_BOOL(ptr, length, &v->physicalPresenceHWEnable)
1370 || tpm_unmarshal_BOOL(ptr, length, &v->physicalPresenceCMDEnable)
1371 || tpm_unmarshal_BOOL(ptr, length, &v->CEKPUsed)
1372 || tpm_unmarshal_BOOL(ptr, length, &v->TPMpost)
1373 || tpm_unmarshal_BOOL(ptr, length, &v->TPMpostLock)
1374 || tpm_unmarshal_BOOL(ptr, length, &v->FIPS)
1375 || tpm_unmarshal_BOOL(ptr, length, &v->operator)
1376 || tpm_unmarshal_BOOL(ptr, length, &v->enableRevokeEK)
1377 || tpm_unmarshal_BOOL(ptr, length, &v->nvLocked)
1378 || tpm_unmarshal_BOOL(ptr, length, &v->readSRKPub)
1379 || tpm_unmarshal_BOOL(ptr, length, &v->tpmEstablished)
1380 || tpm_unmarshal_BOOL(ptr, length, &v->maintenanceDone)
1381 || tpm_unmarshal_BOOL(ptr, length, &v->disableFullDALogicInfo)) return -1;
1382 return 0;
1383 }
1384
tpm_marshal_TPM_STCLEAR_FLAGS(BYTE ** ptr,UINT32 * length,TPM_STCLEAR_FLAGS * v)1385 int tpm_marshal_TPM_STCLEAR_FLAGS(BYTE **ptr, UINT32 *length, TPM_STCLEAR_FLAGS *v)
1386 {
1387 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
1388 || tpm_marshal_BOOL(ptr, length, v->deactivated)
1389 || tpm_marshal_BOOL(ptr, length, v->disableForceClear)
1390 || tpm_marshal_BOOL(ptr, length, v->physicalPresence)
1391 || tpm_marshal_BOOL(ptr, length, v->physicalPresenceLock)
1392 || tpm_marshal_BOOL(ptr, length, v->bGlobalLock)) return -1;
1393 return 0;
1394 }
1395
tpm_unmarshal_TPM_STCLEAR_FLAGS(BYTE ** ptr,UINT32 * length,TPM_STCLEAR_FLAGS * v)1396 int tpm_unmarshal_TPM_STCLEAR_FLAGS(BYTE **ptr, UINT32 *length, TPM_STCLEAR_FLAGS *v)
1397 {
1398 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
1399 || tpm_unmarshal_BOOL(ptr, length, &v->deactivated)
1400 || tpm_unmarshal_BOOL(ptr, length, &v->disableForceClear)
1401 || tpm_unmarshal_BOOL(ptr, length, &v->physicalPresence)
1402 || tpm_unmarshal_BOOL(ptr, length, &v->physicalPresenceLock)
1403 || tpm_unmarshal_BOOL(ptr, length, &v->bGlobalLock)) return -1;
1404 return 0;
1405 }
1406
tpm_marshal_TPM_STANY_FLAGS(BYTE ** ptr,UINT32 * length,TPM_STANY_FLAGS * v)1407 int tpm_marshal_TPM_STANY_FLAGS(BYTE **ptr, UINT32 *length, TPM_STANY_FLAGS *v)
1408 {
1409 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
1410 || tpm_marshal_BOOL(ptr, length, v->postInitialise)
1411 || tpm_marshal_UINT32(ptr, length, v->localityModifier)
1412 || tpm_marshal_BOOL(ptr, length, v->transportExclusive)
1413 || tpm_marshal_BOOL(ptr, length, v->TOSPresent)) return -1;
1414 return 0;
1415 }
1416
tpm_unmarshal_TPM_STANY_FLAGS(BYTE ** ptr,UINT32 * length,TPM_STANY_FLAGS * v)1417 int tpm_unmarshal_TPM_STANY_FLAGS(BYTE **ptr, UINT32 *length, TPM_STANY_FLAGS *v)
1418 {
1419 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
1420 || tpm_unmarshal_BOOL(ptr, length, &v->postInitialise)
1421 || tpm_unmarshal_UINT32(ptr, length, &v->localityModifier)
1422 || tpm_unmarshal_BOOL(ptr, length, &v->transportExclusive)
1423 || tpm_unmarshal_BOOL(ptr, length, &v->TOSPresent)) return -1;
1424 return 0;
1425 }
1426
tpm_marshal_RSA(BYTE ** ptr,UINT32 * length,tpm_rsa_private_key_t * v)1427 int tpm_marshal_RSA(BYTE **ptr, UINT32 *length, tpm_rsa_private_key_t *v)
1428 {
1429 size_t m_len, e_len, q_len;
1430 if (*length < (UINT32)sizeof_RSA((*v))) return -1;
1431 if (v->size > 0) {
1432 tpm_rsa_export_modulus(v, &(*ptr)[6], &m_len);
1433 tpm_rsa_export_exponent(v, &(*ptr)[6+m_len], &e_len);
1434 tpm_rsa_export_prime1(v, &(*ptr)[6+m_len+e_len], &q_len);
1435 tpm_marshal_UINT16(ptr, length, m_len);
1436 tpm_marshal_UINT16(ptr, length, e_len);
1437 tpm_marshal_UINT16(ptr, length, q_len);
1438 *ptr += m_len + e_len + q_len;
1439 *length -= m_len + e_len + q_len;
1440 } else {
1441 tpm_marshal_UINT16(ptr, length, 0);
1442 tpm_marshal_UINT16(ptr, length, 0);
1443 tpm_marshal_UINT16(ptr, length, 0);
1444 }
1445 return 0;
1446 }
1447
tpm_unmarshal_RSA(BYTE ** ptr,UINT32 * length,tpm_rsa_private_key_t * v)1448 int tpm_unmarshal_RSA(BYTE **ptr, UINT32 *length, tpm_rsa_private_key_t *v)
1449 {
1450 UINT16 m_len, e_len, q_len;
1451 if (tpm_unmarshal_UINT16(ptr, length, &m_len)
1452 || tpm_unmarshal_UINT16(ptr, length, &e_len)
1453 || tpm_unmarshal_UINT16(ptr, length, &q_len)) return -1;
1454 if (m_len == 0) {
1455 v->size = 0;
1456 return 0;
1457 }
1458 if (*length < (UINT32)m_len + (UINT32)e_len + (UINT32)q_len
1459 || q_len != m_len/2
1460 || tpm_rsa_import_key(v, RSA_MSB_FIRST,
1461 &(*ptr)[0], m_len,
1462 &(*ptr)[m_len], e_len,
1463 &(*ptr)[m_len+e_len], NULL)) return -1;
1464 *ptr += m_len + e_len + q_len;
1465 *length -= m_len + e_len + q_len;
1466 return 0;
1467 }
1468
tpm_marshal_RSAPub(BYTE ** ptr,UINT32 * length,tpm_rsa_public_key_t * v)1469 int tpm_marshal_RSAPub(BYTE **ptr, UINT32 *length, tpm_rsa_public_key_t *v)
1470 {
1471 size_t m_len, e_len;
1472 if (*length < (UINT32)sizeof_RSAPub((*v))) return -1;
1473 if (v->size > 0) {
1474 tpm_rsa_export_public_modulus(v, &(*ptr)[4], &m_len);
1475 tpm_rsa_export_public_exponent(v, &(*ptr)[4+m_len], &e_len);
1476 tpm_marshal_UINT16(ptr, length, m_len);
1477 tpm_marshal_UINT16(ptr, length, e_len);
1478 *ptr += m_len + e_len;
1479 *length -= m_len + e_len;
1480 } else {
1481 tpm_marshal_UINT16(ptr, length, 0);
1482 tpm_marshal_UINT16(ptr, length, 0);
1483 }
1484 return 0;
1485 }
1486
tpm_unmarshal_RSAPub(BYTE ** ptr,UINT32 * length,tpm_rsa_public_key_t * v)1487 int tpm_unmarshal_RSAPub(BYTE **ptr, UINT32 *length, tpm_rsa_public_key_t *v)
1488 {
1489 UINT16 m_len, e_len;
1490 if (tpm_unmarshal_UINT16(ptr, length, &m_len)
1491 || tpm_unmarshal_UINT16(ptr, length, &e_len)) return -1;
1492 if (m_len == 0) {
1493 v->size = 0;
1494 return 0;
1495 }
1496 if (*length < (UINT32)m_len + (UINT32)e_len
1497 || tpm_rsa_import_public_key(v, RSA_MSB_FIRST, &(*ptr)[0], m_len,
1498 &(*ptr)[m_len], e_len)) return -1;
1499 *ptr += m_len + e_len;
1500 *length -= m_len + e_len;
1501 return 0;
1502 }
1503
tpm_marshal_TPM_KEY_DATA(BYTE ** ptr,UINT32 * length,TPM_KEY_DATA * v)1504 int tpm_marshal_TPM_KEY_DATA(BYTE **ptr, UINT32 *length, TPM_KEY_DATA *v)
1505 {
1506 if (tpm_marshal_TPM_PAYLOAD_TYPE(ptr, length, v->payload)) return -1;
1507 if (v->payload) {
1508 if (tpm_marshal_TPM_KEY_USAGE(ptr, length, v->keyUsage)
1509 || tpm_marshal_TPM_KEY_FLAGS(ptr, length, v->keyFlags)
1510 || tpm_marshal_TPM_KEY_CONTROL(ptr, length, v->keyControl)
1511 || tpm_marshal_TPM_AUTH_DATA_USAGE(ptr, length, v->authDataUsage)
1512 || tpm_marshal_TPM_ENC_SCHEME(ptr, length, v->encScheme)
1513 || tpm_marshal_TPM_SIG_SCHEME(ptr, length, v->sigScheme)
1514 || tpm_marshal_TPM_SECRET(ptr, length, &v->usageAuth)
1515 || tpm_marshal_TPM_SECRET(ptr, length, &v->migrationAuth)
1516 || (v->keyFlags & TPM_KEY_FLAG_HAS_PCR
1517 && tpm_marshal_TPM_PCR_INFO(ptr, length, &v->pcrInfo))
1518 || tpm_marshal_BOOL(ptr, length, v->parentPCRStatus)
1519 || tpm_marshal_RSA(ptr, length, &v->key)) return -1;
1520 }
1521 return 0;
1522 }
1523
tpm_unmarshal_TPM_KEY_DATA(BYTE ** ptr,UINT32 * length,TPM_KEY_DATA * v)1524 int tpm_unmarshal_TPM_KEY_DATA(BYTE **ptr, UINT32 *length, TPM_KEY_DATA *v)
1525 {
1526 if (tpm_unmarshal_TPM_PAYLOAD_TYPE(ptr, length, &v->payload)) return -1;
1527 if (v->payload) {
1528 if (tpm_unmarshal_TPM_KEY_USAGE(ptr, length, &v->keyUsage)
1529 || tpm_unmarshal_TPM_KEY_FLAGS(ptr, length, &v->keyFlags)
1530 || tpm_unmarshal_TPM_KEY_CONTROL(ptr, length, &v->keyControl)
1531 || tpm_unmarshal_TPM_AUTH_DATA_USAGE(ptr, length, &v->authDataUsage)
1532 || tpm_unmarshal_TPM_ENC_SCHEME(ptr, length, &v->encScheme)
1533 || tpm_unmarshal_TPM_SIG_SCHEME(ptr, length, &v->sigScheme)
1534 || tpm_unmarshal_TPM_SECRET(ptr, length, &v->usageAuth)
1535 || tpm_unmarshal_TPM_SECRET(ptr, length, &v->migrationAuth)
1536 || (v->keyFlags & TPM_KEY_FLAG_HAS_PCR
1537 && tpm_unmarshal_TPM_PCR_INFO(ptr, length, &v->pcrInfo))
1538 || tpm_unmarshal_BOOL(ptr, length, &v->parentPCRStatus)
1539 || tpm_unmarshal_RSA(ptr, length, &v->key)) return -1;
1540 }
1541 return 0;
1542 }
1543
tpm_marshal_TPM_PUBKEY_DATA(BYTE ** ptr,UINT32 * length,TPM_PUBKEY_DATA * v)1544 int tpm_marshal_TPM_PUBKEY_DATA(BYTE **ptr, UINT32 *length, TPM_PUBKEY_DATA *v)
1545 {
1546 if (tpm_marshal_BOOL(ptr, length, v->valid)) return -1;
1547 if (v->valid) {
1548 if (tpm_marshal_TPM_ENC_SCHEME(ptr, length, v->encScheme)
1549 || tpm_marshal_TPM_SIG_SCHEME(ptr, length, v->sigScheme)
1550 || tpm_marshal_RSAPub(ptr, length, &v->key)) return -1;
1551 }
1552 return 0;
1553 }
1554
tpm_unmarshal_TPM_PUBKEY_DATA(BYTE ** ptr,UINT32 * length,TPM_PUBKEY_DATA * v)1555 int tpm_unmarshal_TPM_PUBKEY_DATA(BYTE **ptr, UINT32 *length, TPM_PUBKEY_DATA *v)
1556 {
1557 if (tpm_unmarshal_BOOL(ptr, length, &v->valid)) return -1;
1558 if (v->valid) {
1559 if (tpm_unmarshal_TPM_ENC_SCHEME(ptr, length, &v->encScheme)
1560 || tpm_unmarshal_TPM_SIG_SCHEME(ptr, length, &v->sigScheme)
1561 || tpm_unmarshal_RSAPub(ptr, length, &v->key)) return -1;
1562 }
1563 return 0;
1564 }
1565
tpm_marshal_TPM_PERMANENT_DATA(BYTE ** ptr,UINT32 * length,TPM_PERMANENT_DATA * v)1566 int tpm_marshal_TPM_PERMANENT_DATA(BYTE **ptr, UINT32 *length, TPM_PERMANENT_DATA *v)
1567 {
1568 UINT32 i;
1569 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
1570 || tpm_marshal_TPM_VERSION(ptr, length, &v->version)
1571 || tpm_marshal_TPM_NONCE(ptr, length, &v->tpmProof)
1572 || tpm_marshal_TPM_NONCE(ptr, length, &v->ekReset)
1573 || tpm_marshal_TPM_SECRET(ptr, length, &v->ownerAuth)
1574 || tpm_marshal_TPM_SECRET(ptr, length, &v->operatorAuth)
1575 || tpm_marshal_TPM_NONCE(ptr, length, &v->tpmDAASeed)
1576 || tpm_marshal_TPM_NONCE(ptr, length, &v->daaProof)
1577 || tpm_marshal_TPM_PUBKEY_DATA(ptr, length, &v->manuMaintPub)
1578 || tpm_marshal_RSA(ptr, length, &v->endorsementKey)
1579 || tpm_marshal_TPM_KEY_DATA(ptr, length, &v->srk)
1580 || tpm_marshal_BYTE_ARRAY(ptr, length, v->contextKey, sizeof(v->contextKey))
1581 || tpm_marshal_BYTE_ARRAY(ptr, length, v->delegateKey, sizeof(v->contextKey))
1582 || tpm_marshal_BYTE_ARRAY(ptr, length, v->daaKey, sizeof(v->contextKey))
1583 || tpm_marshal_TPM_ACTUAL_COUNT(ptr, length, v->auditMonotonicCounter)) return -1;
1584 for (i = 0; i < TPM_MAX_COUNTERS; i++) {
1585 if (tpm_marshal_TPM_COUNTER_VALUE(ptr, length, &v->counters[i])
1586 || tpm_marshal_TPM_SECRET(ptr, length, &v->counters[i].usageAuth)
1587 || tpm_marshal_BOOL(ptr, length, v->counters[i].valid)) return -1;
1588 }
1589 for (i = 0; i < TPM_NUM_PCR; i++) {
1590 if (tpm_marshal_TPM_PCR_ATTRIBUTES(ptr, length, &v->pcrAttrib[i])) return -1;
1591 }
1592 for (i = 0; i < TPM_NUM_PCR; i++) {
1593 if (tpm_marshal_TPM_PCRVALUE(ptr, length, &v->pcrValue[i])) return -1;
1594 }
1595 if (tpm_marshal_BYTE_ARRAY(ptr, length, v->ordinalAuditStatus, sizeof(v->ordinalAuditStatus))
1596 || tpm_marshal_BYTE_ARRAY(ptr, length, v->rngState, sizeof(v->rngState))) return -1;
1597 for (i = 0; i < TPM_NUM_FAMILY_TABLE_ENTRY; i++) {
1598 if (tpm_marshal_BOOL(ptr, length, v->familyTable.famRow[i].valid)) return -1;
1599 if (v->familyTable.famRow[i].valid) {
1600 if (tpm_marshal_TPM_FAMILY_TABLE_ENTRY(ptr, length, &v->familyTable.famRow[i])) return -1;
1601 }
1602 }
1603 for (i = 0; i < TPM_NUM_DELEGATE_TABLE_ENTRY; i++) {
1604 if (tpm_marshal_BOOL(ptr, length, v->delegateTable.delRow[i].valid)) return -1;
1605 if (v->delegateTable.delRow[i].valid) {
1606 if (tpm_marshal_TPM_DELEGATE_TABLE_ROW(ptr, length, &v->delegateTable.delRow[i])) return -1;
1607 }
1608 }
1609 if (tpm_marshal_UINT32(ptr, length, v->lastFamilyID)
1610 || tpm_marshal_TPM_CMK_DELEGATE(ptr, length, v->restrictDelegate)
1611 || tpm_marshal_UINT32(ptr, length, v->maxNVBufSize)
1612 || tpm_marshal_UINT32(ptr, length, v->noOwnerNVWrite)
1613 || tpm_marshal_UINT32(ptr, length, v->nvDataSize)
1614 || tpm_marshal_BYTE_ARRAY(ptr, length, v->nvData, sizeof(v->nvData))) return -1;
1615 for (i = 0; i < TPM_MAX_NVS; i++) {
1616 if (tpm_marshal_BOOL(ptr, length, v->nvStorage[i].valid)) return -1;
1617 if (v->nvStorage[i].valid) {
1618 if (tpm_marshal_TPM_NV_DATA_SENSITIVE(ptr, length, &v->nvStorage[i])) return -1;
1619 }
1620 }
1621 for (i = 0; i < TPM_MAX_KEYS; i++) {
1622 if (tpm_marshal_TPM_KEY_DATA(ptr, length, &v->keys[i])) return -1;
1623 }
1624 if (tpm_marshal_UINT32_ARRAY(ptr, length, v->tis_timeouts, TPM_NUM_TIS_TIMEOUTS)
1625 || tpm_marshal_UINT32_ARRAY(ptr, length, v->cmd_durations, TPM_NUM_CMD_DURATIONS)) return -1;
1626 return 0;
1627 }
1628
tpm_unmarshal_TPM_PERMANENT_DATA(BYTE ** ptr,UINT32 * length,TPM_PERMANENT_DATA * v)1629 int tpm_unmarshal_TPM_PERMANENT_DATA(BYTE **ptr, UINT32 *length, TPM_PERMANENT_DATA *v)
1630 {
1631 UINT32 i;
1632 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
1633 || tpm_unmarshal_TPM_VERSION(ptr, length, &v->version)
1634 || tpm_unmarshal_TPM_NONCE(ptr, length, &v->tpmProof)
1635 || tpm_unmarshal_TPM_NONCE(ptr, length, &v->ekReset)
1636 || tpm_unmarshal_TPM_SECRET(ptr, length, &v->ownerAuth)
1637 || tpm_unmarshal_TPM_SECRET(ptr, length, &v->operatorAuth)
1638 || tpm_unmarshal_TPM_NONCE(ptr, length, &v->tpmDAASeed)
1639 || tpm_unmarshal_TPM_NONCE(ptr, length, &v->daaProof)
1640 || tpm_unmarshal_TPM_PUBKEY_DATA(ptr, length, &v->manuMaintPub)
1641 || tpm_unmarshal_RSA(ptr, length, &v->endorsementKey)
1642 || tpm_unmarshal_TPM_KEY_DATA(ptr, length, &v->srk)
1643 || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->contextKey, sizeof(v->contextKey))
1644 || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->delegateKey, sizeof(v->contextKey))
1645 || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->daaKey, sizeof(v->contextKey))
1646 || tpm_unmarshal_TPM_ACTUAL_COUNT(ptr, length, &v->auditMonotonicCounter)) return -1;
1647 for (i = 0; i < TPM_MAX_COUNTERS; i++) {
1648 if (tpm_unmarshal_TPM_COUNTER_VALUE(ptr, length, &v->counters[i])
1649 || tpm_unmarshal_TPM_SECRET(ptr, length, &v->counters[i].usageAuth)
1650 || tpm_unmarshal_BOOL(ptr, length, &v->counters[i].valid)) return -1;
1651 }
1652 for (i = 0; i < TPM_NUM_PCR; i++) {
1653 if (tpm_unmarshal_TPM_PCR_ATTRIBUTES(ptr, length, &v->pcrAttrib[i])) return -1;
1654 }
1655 for (i = 0; i < TPM_NUM_PCR; i++) {
1656 if (tpm_unmarshal_TPM_PCRVALUE(ptr, length, &v->pcrValue[i])) return -1;
1657 }
1658 if (tpm_unmarshal_BYTE_ARRAY(ptr, length, v->ordinalAuditStatus, sizeof(v->ordinalAuditStatus))
1659 || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->rngState, sizeof(v->rngState))) return -1;
1660 for (i = 0; i < TPM_NUM_FAMILY_TABLE_ENTRY; i++) {
1661 if (tpm_unmarshal_BOOL(ptr, length, &v->familyTable.famRow[i].valid)) return -1;
1662 if (v->familyTable.famRow[i].valid) {
1663 if (tpm_unmarshal_TPM_FAMILY_TABLE_ENTRY(ptr, length, &v->familyTable.famRow[i])) return -1;
1664 }
1665 }
1666 for (i = 0; i < TPM_NUM_DELEGATE_TABLE_ENTRY; i++) {
1667 if (tpm_unmarshal_BOOL(ptr, length, &v->delegateTable.delRow[i].valid)) return -1;
1668 if (v->delegateTable.delRow[i].valid) {
1669 if (tpm_unmarshal_TPM_DELEGATE_TABLE_ROW(ptr, length, &v->delegateTable.delRow[i])) return -1;
1670 }
1671 }
1672 if (tpm_unmarshal_UINT32(ptr, length, &v->lastFamilyID)
1673 || tpm_unmarshal_TPM_CMK_DELEGATE(ptr, length, &v->restrictDelegate)
1674 || tpm_unmarshal_UINT32(ptr, length, &v->maxNVBufSize)
1675 || tpm_unmarshal_UINT32(ptr, length, &v->noOwnerNVWrite)
1676 || tpm_unmarshal_UINT32(ptr, length, &v->nvDataSize)
1677 || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->nvData, sizeof(v->nvData))) return -1;
1678 for (i = 0; i < TPM_MAX_NVS; i++) {
1679 if (tpm_unmarshal_BOOL(ptr, length, &v->nvStorage[i].valid)) return -1;
1680 if (v->nvStorage[i].valid) {
1681 if (tpm_unmarshal_TPM_NV_DATA_SENSITIVE(ptr, length, &v->nvStorage[i])) return -1;
1682 }
1683 }
1684 for (i = 0; i < TPM_MAX_KEYS; i++) {
1685 if (tpm_unmarshal_TPM_KEY_DATA(ptr, length, &v->keys[i])) return -1;
1686 }
1687 if (tpm_unmarshal_UINT32_ARRAY(ptr, length, v->tis_timeouts, TPM_NUM_TIS_TIMEOUTS)
1688 || tpm_unmarshal_UINT32_ARRAY(ptr, length, v->cmd_durations, TPM_NUM_CMD_DURATIONS)) return -1;
1689 return 0;
1690 }
1691
tpm_marshal_TPM_STCLEAR_DATA(BYTE ** ptr,UINT32 * length,TPM_STCLEAR_DATA * v)1692 int tpm_marshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v)
1693 {
1694 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
1695 || tpm_marshal_TPM_NONCE(ptr, length, &v->contextNonceKey)
1696 || tpm_marshal_TPM_COUNT_ID(ptr, length, v->countID)
1697 || tpm_marshal_UINT32(ptr, length, v->ownerReference)
1698 || tpm_marshal_BOOL(ptr, length, v->disableResetLock)
1699 || tpm_marshal_UINT32(ptr, length, v->deferredPhysicalPresence)) return -1;
1700 return 0;
1701 }
1702
tpm_unmarshal_TPM_STCLEAR_DATA(BYTE ** ptr,UINT32 * length,TPM_STCLEAR_DATA * v)1703 int tpm_unmarshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v)
1704 {
1705 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
1706 || tpm_unmarshal_TPM_NONCE(ptr, length, &v->contextNonceKey)
1707 || tpm_unmarshal_TPM_COUNT_ID(ptr, length, &v->countID)
1708 || tpm_unmarshal_UINT32(ptr, length, &v->ownerReference)
1709 || tpm_unmarshal_BOOL(ptr, length, &v->disableResetLock)
1710 || tpm_unmarshal_UINT32(ptr, length, &v->deferredPhysicalPresence)) return -1;
1711 return 0;
1712 }
1713
tpm_marshal_TPM_SESSION_DATA(BYTE ** ptr,UINT32 * length,TPM_SESSION_DATA * v)1714 int tpm_marshal_TPM_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_SESSION_DATA *v)
1715 {
1716 if (tpm_marshal_BYTE(ptr, length, v->type)
1717 || tpm_marshal_TPM_NONCE(ptr, length, &v->nonceEven)
1718 || tpm_marshal_TPM_NONCE(ptr, length, &v->lastNonceEven)
1719 || tpm_marshal_TPM_SECRET(ptr, length, &v->sharedSecret)
1720 || tpm_marshal_TPM_HANDLE(ptr, length, v->handle)
1721 || tpm_marshal_TPM_ENTITY_TYPE(ptr, length, v->entityType)
1722 || (v->type == TPM_ST_DSAP
1723 && (tpm_marshal_TPM_DELEGATIONS(ptr, length, &v->permissions)
1724 || tpm_marshal_TPM_FAMILY_ID(ptr, length, v->familyID)))
1725 || (v->type == TPM_ST_TRANSPORT
1726 && tpm_marshal_TPM_TRANSPORT_INTERNAL(ptr, length, &v->transInternal))) return -1;
1727 return 0;
1728 }
1729
tpm_unmarshal_TPM_SESSION_DATA(BYTE ** ptr,UINT32 * length,TPM_SESSION_DATA * v)1730 int tpm_unmarshal_TPM_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_SESSION_DATA *v)
1731 {
1732 if (tpm_unmarshal_BYTE(ptr, length, &v->type)
1733 || tpm_unmarshal_TPM_NONCE(ptr, length, &v->nonceEven)
1734 || tpm_unmarshal_TPM_NONCE(ptr, length, &v->lastNonceEven)
1735 || tpm_unmarshal_TPM_SECRET(ptr, length, &v->sharedSecret)
1736 || tpm_unmarshal_TPM_HANDLE(ptr, length, &v->handle)
1737 || tpm_unmarshal_TPM_ENTITY_TYPE(ptr, length, &v->entityType)
1738 || (v->type == TPM_ST_DSAP
1739 && (tpm_unmarshal_TPM_DELEGATIONS(ptr, length, &v->permissions)
1740 || tpm_unmarshal_TPM_FAMILY_ID(ptr, length, &v->familyID)))
1741 || (v->type == TPM_ST_TRANSPORT
1742 && tpm_unmarshal_TPM_TRANSPORT_INTERNAL(ptr, length, &v->transInternal))) return -1;
1743 return 0;
1744 }
1745
tpm_marshal_TPM_STANY_DATA(BYTE ** ptr,UINT32 * length,TPM_STANY_DATA * v)1746 int tpm_marshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v)
1747 {
1748 UINT32 i;
1749 if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
1750 || tpm_marshal_TPM_NONCE(ptr, length, &v->contextNonceSession)
1751 || tpm_marshal_TPM_DIGEST(ptr, length, &v->auditDigest)
1752 || tpm_marshal_BOOL(ptr, length, v->auditSession)
1753 || tpm_marshal_TPM_CURRENT_TICKS(ptr, length, &v->currentTicks)
1754 || tpm_marshal_UINT32(ptr, length, v->contextCount)
1755 || tpm_marshal_UINT32_ARRAY(ptr, length, v->contextList, TPM_MAX_SESSION_LIST)) return -1;
1756 for (i = 0; i < TPM_MAX_SESSIONS; i++) {
1757 if (tpm_marshal_TPM_SESSION_DATA(ptr, length, &v->sessions[i])) return -1;
1758 }
1759 for (i = 0; i < TPM_MAX_SESSIONS_DAA; i++) {
1760 if (tpm_marshal_TPM_DAA_SESSION_DATA(ptr, length, &v->sessionsDAA[i])) return -1;
1761 }
1762 if (tpm_marshal_DAAHANDLE(ptr, length, v->currentDAA)
1763 || tpm_marshal_TPM_TRANSHANDLE(ptr, length, v->transExclusive)) return -1;
1764 return 0;
1765 }
1766
tpm_unmarshal_TPM_STANY_DATA(BYTE ** ptr,UINT32 * length,TPM_STANY_DATA * v)1767 int tpm_unmarshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v)
1768 {
1769 UINT32 i;
1770 if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
1771 || tpm_unmarshal_TPM_NONCE(ptr, length, &v->contextNonceSession)
1772 || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->auditDigest)
1773 || tpm_unmarshal_BOOL(ptr, length, &v->auditSession)
1774 || tpm_unmarshal_TPM_CURRENT_TICKS(ptr, length, &v->currentTicks)
1775 || tpm_unmarshal_UINT32(ptr, length, &v->contextCount)
1776 || tpm_unmarshal_UINT32_ARRAY(ptr, length, v->contextList, TPM_MAX_SESSION_LIST)) return -1;
1777 for (i = 0; i < TPM_MAX_SESSIONS; i++) {
1778 if (tpm_unmarshal_TPM_SESSION_DATA(ptr, length, &v->sessions[i])) return -1;
1779 }
1780 for (i = 0; i < TPM_MAX_SESSIONS_DAA; i++) {
1781 if (tpm_unmarshal_TPM_DAA_SESSION_DATA(ptr, length, &v->sessionsDAA[i])) return -1;
1782 }
1783 if (tpm_unmarshal_DAAHANDLE(ptr, length, &v->currentDAA)
1784 || tpm_unmarshal_TPM_TRANSHANDLE(ptr, length, &v->transExclusive)) return -1;
1785 return 0;
1786 }
1787
tpm_marshal_TPM_DATA(BYTE ** ptr,UINT32 * length,TPM_DATA * v)1788 int tpm_marshal_TPM_DATA(BYTE **ptr, UINT32 *length, TPM_DATA *v)
1789 {
1790 if (tpm_marshal_TPM_PERMANENT_FLAGS(ptr, length, &v->permanent.flags)
1791 || tpm_marshal_BOOL(ptr, length, v->permanent.flags.selfTestSucceeded)
1792 || tpm_marshal_BOOL(ptr, length, v->permanent.flags.owned)
1793 || tpm_marshal_TPM_PERMANENT_DATA(ptr, length, &v->permanent.data)
1794 || tpm_marshal_TPM_STCLEAR_FLAGS(ptr, length, &v->stclear.flags)
1795 || tpm_marshal_TPM_STCLEAR_DATA(ptr, length, &v->stclear.data)
1796 || tpm_marshal_TPM_STANY_DATA(ptr, length, &v->stany.data)) return -1;
1797 return 0;
1798 }
1799
tpm_unmarshal_TPM_DATA(BYTE ** ptr,UINT32 * length,TPM_DATA * v)1800 int tpm_unmarshal_TPM_DATA(BYTE **ptr, UINT32 *length, TPM_DATA *v)
1801 {
1802 if (tpm_unmarshal_TPM_PERMANENT_FLAGS(ptr, length, &v->permanent.flags)
1803 || tpm_unmarshal_BOOL(ptr, length, &v->permanent.flags.selfTestSucceeded)
1804 || tpm_unmarshal_BOOL(ptr, length, &v->permanent.flags.owned)
1805 || tpm_unmarshal_TPM_PERMANENT_DATA(ptr, length, &v->permanent.data)
1806 || tpm_unmarshal_TPM_STCLEAR_FLAGS(ptr, length, &v->stclear.flags)
1807 || tpm_unmarshal_TPM_STCLEAR_DATA(ptr, length, &v->stclear.data)
1808 || tpm_unmarshal_TPM_STANY_DATA(ptr, length, &v->stany.data)) return -1;
1809 return 0;
1810 }
1811
tpm_marshal_TPM_RESPONSE(BYTE ** ptr,UINT32 * length,TPM_RESPONSE * v)1812 int tpm_marshal_TPM_RESPONSE(BYTE **ptr, UINT32 *length, TPM_RESPONSE *v)
1813 {
1814 if (tpm_marshal_TPM_TAG(ptr, length, v->tag)
1815 || tpm_marshal_UINT32(ptr, length, v->size)
1816 || tpm_marshal_TPM_RESULT(ptr, length, v->result)
1817 || tpm_marshal_BLOB(ptr, length, v->param, v->paramSize)) return -1;
1818 if (v->tag == TPM_TAG_RSP_AUTH2_COMMAND) {
1819 if (tpm_marshal_TPM_AUTH(ptr, length, v->auth1)
1820 || tpm_marshal_TPM_AUTH(ptr, length, v->auth2)) return -1;
1821 } else if (v->tag == TPM_TAG_RSP_AUTH1_COMMAND) {
1822 if (tpm_marshal_TPM_AUTH(ptr, length, v->auth1)) return -1;
1823 }
1824 return 0;
1825 }
1826
tpm_unmarshal_TPM_REQUEST(BYTE ** ptr,UINT32 * length,TPM_REQUEST * v)1827 int tpm_unmarshal_TPM_REQUEST(BYTE **ptr, UINT32 *length, TPM_REQUEST *v)
1828 {
1829 if (tpm_unmarshal_TPM_TAG(ptr, length, &v->tag)
1830 || tpm_unmarshal_UINT32(ptr, length, &v->size)
1831 || tpm_unmarshal_TPM_COMMAND_CODE(ptr, length, &v->ordinal)) return -1;
1832 v->param = *ptr;
1833 v->paramSize = *length;
1834 if (v->tag == TPM_TAG_RQU_AUTH2_COMMAND) {
1835 if (*length < 2 * 45) return -1;
1836 v->paramSize = *length - 2 * 45;
1837 if (tpm_unmarshal_BLOB(ptr, length, &v->param, v->paramSize)
1838 || tpm_unmarshal_TPM_AUTH(ptr, length, &v->auth1)
1839 || tpm_unmarshal_TPM_AUTH(ptr, length, &v->auth2)) return -1;
1840 v->auth1.ordinal = v->ordinal;
1841 v->auth2.ordinal = v->ordinal;
1842 } else if (v->tag == TPM_TAG_RQU_AUTH1_COMMAND) {
1843 if (*length < 45) return -1;
1844 v->paramSize = *length - 45;
1845 if (tpm_unmarshal_BLOB(ptr, length, &v->param, v->paramSize)
1846 || tpm_unmarshal_TPM_AUTH(ptr, length, &v->auth1)) return -1;
1847 v->auth1.ordinal = v->ordinal;
1848 v->auth2.authHandle = TPM_INVALID_HANDLE;
1849 } else {
1850 v->auth1.authHandle = TPM_INVALID_HANDLE;
1851 v->auth2.authHandle = TPM_INVALID_HANDLE;
1852 }
1853 return 0;
1854 }
1855