1
2 /*
3 * Licensed Materials - Property of IBM
4 *
5 * trousers - An open source TCG Software Stack
6 *
7 * (C) Copyright International Business Machines Corp. 2007
8 *
9 */
10
11 #include <stdlib.h>
12 #include <stdio.h>
13 #include <string.h>
14 #include <assert.h>
15
16 #include "trousers/tss.h"
17 #include "trousers/trousers.h"
18 #include "trousers_types.h"
19 #include "spi_utils.h"
20 #include "tsplog.h"
21 #include "hosttable.h"
22 #include "tcsd_wrap.h"
23 #include "rpc_tcstp_tsp.h"
24
25
26 TSS_RESULT
RPC_Delegate_Manage_TP(struct host_table_entry * hte,TPM_FAMILY_ID familyID,TPM_FAMILY_OPERATION opFlag,UINT32 opDataSize,BYTE * opData,TPM_AUTH * ownerAuth,UINT32 * retDataSize,BYTE ** retData)27 RPC_Delegate_Manage_TP(struct host_table_entry *hte,
28 TPM_FAMILY_ID familyID, /* in */
29 TPM_FAMILY_OPERATION opFlag, /* in */
30 UINT32 opDataSize, /* in */
31 BYTE *opData, /* in */
32 TPM_AUTH *ownerAuth, /* in/out */
33 UINT32 *retDataSize, /* out */
34 BYTE **retData) /* out */
35 {
36 TSS_RESULT result;
37 int i;
38
39 initData(&hte->comm, 6);
40 hte->comm.hdr.u.ordinal = TCSD_ORD_DELEGATE_MANAGE;
41 LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
42
43 if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
44 return TSPERR(TSS_E_INTERNAL_ERROR);
45 if (setData(TCSD_PACKET_TYPE_UINT32, 1, &familyID, 0, &hte->comm))
46 return TSPERR(TSS_E_INTERNAL_ERROR);
47 if (setData(TCSD_PACKET_TYPE_UINT32, 2, &opFlag, 0, &hte->comm))
48 return TSPERR(TSS_E_INTERNAL_ERROR);
49 if (setData(TCSD_PACKET_TYPE_UINT32, 3, &opDataSize, 0, &hte->comm))
50 return TSPERR(TSS_E_INTERNAL_ERROR);
51 if (setData(TCSD_PACKET_TYPE_PBYTE, 4, opData, opDataSize, &hte->comm))
52 return TSPERR(TSS_E_INTERNAL_ERROR);
53 if (ownerAuth) {
54 if (setData(TCSD_PACKET_TYPE_AUTH, 5, ownerAuth, 0, &hte->comm))
55 return TSPERR(TSS_E_INTERNAL_ERROR);
56 } else {
57 TPM_AUTH nullAuth;
58
59 __tspi_memset(&nullAuth, 0, sizeof(TPM_AUTH));
60 if (setData(TCSD_PACKET_TYPE_AUTH, 5, &nullAuth, 0, &hte->comm))
61 return TSPERR(TSS_E_INTERNAL_ERROR);
62 }
63
64 result = sendTCSDPacket(hte);
65
66 if (result == TSS_SUCCESS)
67 result = hte->comm.hdr.u.result;
68
69 if (result == TSS_SUCCESS) {
70 i = 0;
71 if (ownerAuth) {
72 if (getData(TCSD_PACKET_TYPE_AUTH, i++, ownerAuth, 0, &hte->comm))
73 return TSPERR(TSS_E_INTERNAL_ERROR);
74 }
75 if (getData(TCSD_PACKET_TYPE_UINT32, i++, retDataSize, 0, &hte->comm))
76 return TSPERR(TSS_E_INTERNAL_ERROR);
77 *retData = (BYTE *)malloc(*retDataSize);
78 if (*retData == NULL) {
79 LogError("malloc of %u bytes failed.", *retDataSize);
80 return TSPERR(TSS_E_OUTOFMEMORY);
81 }
82 if (getData(TCSD_PACKET_TYPE_PBYTE, i++, *retData, *retDataSize, &hte->comm)) {
83 free(*retData);
84 return TSPERR(TSS_E_INTERNAL_ERROR);
85 }
86 }
87
88 return result;
89 }
90
91 TSS_RESULT
RPC_Delegate_CreateKeyDelegation_TP(struct host_table_entry * hte,TCS_KEY_HANDLE hKey,UINT32 publicInfoSize,BYTE * publicInfo,TPM_ENCAUTH * encDelAuth,TPM_AUTH * keyAuth,UINT32 * blobSize,BYTE ** blob)92 RPC_Delegate_CreateKeyDelegation_TP(struct host_table_entry *hte,
93 TCS_KEY_HANDLE hKey, /* in */
94 UINT32 publicInfoSize, /* in */
95 BYTE *publicInfo, /* in */
96 TPM_ENCAUTH *encDelAuth, /* in */
97 TPM_AUTH *keyAuth, /* in/out */
98 UINT32 *blobSize, /* out */
99 BYTE **blob) /* out */
100 {
101 TSS_RESULT result;
102 int i;
103
104 initData(&hte->comm, 8);
105 hte->comm.hdr.u.ordinal = TCSD_ORD_DELEGATE_CREATEKEYDELEGATION;
106 LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
107
108 if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
109 return TSPERR(TSS_E_INTERNAL_ERROR);
110 if (setData(TCSD_PACKET_TYPE_UINT32, 1, &hKey, 0, &hte->comm))
111 return TSPERR(TSS_E_INTERNAL_ERROR);
112 if (setData(TCSD_PACKET_TYPE_UINT32, 2, &publicInfoSize, 0, &hte->comm))
113 return TSPERR(TSS_E_INTERNAL_ERROR);
114 if (setData(TCSD_PACKET_TYPE_PBYTE, 3, publicInfo, publicInfoSize, &hte->comm))
115 return TSPERR(TSS_E_INTERNAL_ERROR);
116 if (setData(TCSD_PACKET_TYPE_ENCAUTH, 4, encDelAuth, 0, &hte->comm))
117 return TSPERR(TSS_E_INTERNAL_ERROR);
118 if (keyAuth) {
119 if (setData(TCSD_PACKET_TYPE_AUTH, 5, keyAuth, 0, &hte->comm))
120 return TSPERR(TSS_E_INTERNAL_ERROR);
121 } else {
122 TPM_AUTH nullAuth;
123
124 __tspi_memset(&nullAuth, 0, sizeof(TPM_AUTH));
125 if (setData(TCSD_PACKET_TYPE_AUTH, 5, &nullAuth, 0, &hte->comm))
126 return TSPERR(TSS_E_INTERNAL_ERROR);
127 }
128
129 result = sendTCSDPacket(hte);
130
131 if (result == TSS_SUCCESS)
132 result = hte->comm.hdr.u.result;
133
134 if (result == TSS_SUCCESS) {
135 i = 0;
136 if (keyAuth) {
137 if (getData(TCSD_PACKET_TYPE_AUTH, i++, keyAuth, 0, &hte->comm))
138 return TSPERR(TSS_E_INTERNAL_ERROR);
139 }
140 if (getData(TCSD_PACKET_TYPE_UINT32, i++, blobSize, 0, &hte->comm))
141 return TSPERR(TSS_E_INTERNAL_ERROR);
142 *blob = (BYTE *)malloc(*blobSize);
143 if (*blob == NULL) {
144 LogError("malloc of %u bytes failed.", *blobSize);
145 return TSPERR(TSS_E_OUTOFMEMORY);
146 }
147 if (getData(TCSD_PACKET_TYPE_PBYTE, i++, *blob, *blobSize, &hte->comm)) {
148 free(*blob);
149 return TSPERR(TSS_E_INTERNAL_ERROR);
150 }
151 }
152
153 return result;
154 }
155
156 TSS_RESULT
RPC_Delegate_CreateOwnerDelegation_TP(struct host_table_entry * hte,TSS_BOOL increment,UINT32 publicInfoSize,BYTE * publicInfo,TPM_ENCAUTH * encDelAuth,TPM_AUTH * ownerAuth,UINT32 * blobSize,BYTE ** blob)157 RPC_Delegate_CreateOwnerDelegation_TP(struct host_table_entry *hte,
158 TSS_BOOL increment, /* in */
159 UINT32 publicInfoSize, /* in */
160 BYTE *publicInfo, /* in */
161 TPM_ENCAUTH *encDelAuth, /* in */
162 TPM_AUTH *ownerAuth, /* in/out */
163 UINT32 *blobSize, /* out */
164 BYTE **blob) /* out */
165 {
166 TSS_RESULT result;
167 int i;
168
169 initData(&hte->comm, 8);
170 hte->comm.hdr.u.ordinal = TCSD_ORD_DELEGATE_CREATEOWNERDELEGATION;
171 LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
172
173 if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
174 return TSPERR(TSS_E_INTERNAL_ERROR);
175 if (setData(TCSD_PACKET_TYPE_BOOL, 1, &increment, 0, &hte->comm))
176 return TSPERR(TSS_E_INTERNAL_ERROR);
177 if (setData(TCSD_PACKET_TYPE_UINT32, 2, &publicInfoSize, 0, &hte->comm))
178 return TSPERR(TSS_E_INTERNAL_ERROR);
179 if (setData(TCSD_PACKET_TYPE_PBYTE, 3, publicInfo, publicInfoSize, &hte->comm))
180 return TSPERR(TSS_E_INTERNAL_ERROR);
181 if (setData(TCSD_PACKET_TYPE_ENCAUTH, 4, encDelAuth, 0, &hte->comm))
182 return TSPERR(TSS_E_INTERNAL_ERROR);
183 if (ownerAuth) {
184 if (setData(TCSD_PACKET_TYPE_AUTH, 5, ownerAuth, 0, &hte->comm))
185 return TSPERR(TSS_E_INTERNAL_ERROR);
186 } else {
187 TPM_AUTH nullAuth;
188
189 __tspi_memset(&nullAuth, 0, sizeof(TPM_AUTH));
190 if (setData(TCSD_PACKET_TYPE_AUTH, 5, &nullAuth, 0, &hte->comm))
191 return TSPERR(TSS_E_INTERNAL_ERROR);
192 }
193
194 result = sendTCSDPacket(hte);
195
196 if (result == TSS_SUCCESS)
197 result = hte->comm.hdr.u.result;
198
199 if (result == TSS_SUCCESS) {
200 i = 0;
201 if (ownerAuth) {
202 if (getData(TCSD_PACKET_TYPE_AUTH, i++, ownerAuth, 0, &hte->comm))
203 return TSPERR(TSS_E_INTERNAL_ERROR);
204 }
205 if (getData(TCSD_PACKET_TYPE_UINT32, i++, blobSize, 0, &hte->comm))
206 return TSPERR(TSS_E_INTERNAL_ERROR);
207 *blob = (BYTE *)malloc(*blobSize);
208 if (*blob == NULL) {
209 LogError("malloc of %u bytes failed.", *blobSize);
210 return TSPERR(TSS_E_OUTOFMEMORY);
211 }
212 if (getData(TCSD_PACKET_TYPE_PBYTE, i++, *blob, *blobSize, &hte->comm)) {
213 free(*blob);
214 return TSPERR(TSS_E_INTERNAL_ERROR);
215 }
216 }
217
218 return result;
219 }
220
221 TSS_RESULT
RPC_Delegate_LoadOwnerDelegation_TP(struct host_table_entry * hte,TPM_DELEGATE_INDEX index,UINT32 blobSize,BYTE * blob,TPM_AUTH * ownerAuth)222 RPC_Delegate_LoadOwnerDelegation_TP(struct host_table_entry *hte,
223 TPM_DELEGATE_INDEX index, /* in */
224 UINT32 blobSize, /* in */
225 BYTE *blob, /* in */
226 TPM_AUTH *ownerAuth) /* in/out */
227 {
228 TSS_RESULT result;
229
230 initData(&hte->comm, 5);
231 hte->comm.hdr.u.ordinal = TCSD_ORD_DELEGATE_LOADOWNERDELEGATION;
232 LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
233
234 if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
235 return TSPERR(TSS_E_INTERNAL_ERROR);
236 if (setData(TCSD_PACKET_TYPE_UINT32, 1, &index, 0, &hte->comm))
237 return TSPERR(TSS_E_INTERNAL_ERROR);
238 if (setData(TCSD_PACKET_TYPE_UINT32, 2, &blobSize, 0, &hte->comm))
239 return TSPERR(TSS_E_INTERNAL_ERROR);
240 if (setData(TCSD_PACKET_TYPE_PBYTE, 3, blob, blobSize, &hte->comm))
241 return TSPERR(TSS_E_INTERNAL_ERROR);
242 if (ownerAuth) {
243 if (setData(TCSD_PACKET_TYPE_AUTH, 4, ownerAuth, 0, &hte->comm))
244 return TSPERR(TSS_E_INTERNAL_ERROR);
245 } else {
246 TPM_AUTH nullAuth;
247
248 __tspi_memset(&nullAuth, 0, sizeof(TPM_AUTH));
249 if (setData(TCSD_PACKET_TYPE_AUTH, 4, &nullAuth, 0, &hte->comm))
250 return TSPERR(TSS_E_INTERNAL_ERROR);
251 }
252
253 result = sendTCSDPacket(hte);
254
255 if (result == TSS_SUCCESS)
256 result = hte->comm.hdr.u.result;
257
258 if (result == TSS_SUCCESS) {
259 if (ownerAuth) {
260 if (getData(TCSD_PACKET_TYPE_AUTH, 0, ownerAuth, 0, &hte->comm))
261 return TSPERR(TSS_E_INTERNAL_ERROR);
262 }
263 }
264
265 return result;
266 }
267
268 TSS_RESULT
RPC_Delegate_ReadTable_TP(struct host_table_entry * hte,UINT32 * familyTableSize,BYTE ** familyTable,UINT32 * delegateTableSize,BYTE ** delegateTable)269 RPC_Delegate_ReadTable_TP(struct host_table_entry *hte,
270 UINT32 *familyTableSize, /* out */
271 BYTE **familyTable, /* out */
272 UINT32 *delegateTableSize, /* out */
273 BYTE **delegateTable) /* out */
274 {
275 TSS_RESULT result;
276
277 initData(&hte->comm, 1);
278 hte->comm.hdr.u.ordinal = TCSD_ORD_DELEGATE_READTABLE;
279 LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
280
281 if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
282 return TSPERR(TSS_E_INTERNAL_ERROR);
283
284 result = sendTCSDPacket(hte);
285
286 if (result == TSS_SUCCESS)
287 result = hte->comm.hdr.u.result;
288
289 if (result == TSS_SUCCESS) {
290 if (getData(TCSD_PACKET_TYPE_UINT32, 0, familyTableSize, 0, &hte->comm))
291 return TSPERR(TSS_E_INTERNAL_ERROR);
292 *familyTable = (BYTE *)malloc(*familyTableSize);
293 if (*familyTable == NULL) {
294 LogError("malloc of %u bytes failed.", *familyTableSize);
295 return TSPERR(TSS_E_OUTOFMEMORY);
296 }
297 if (getData(TCSD_PACKET_TYPE_PBYTE, 1, *familyTable, *familyTableSize, &hte->comm)) {
298 free(*familyTable);
299 return TSPERR(TSS_E_INTERNAL_ERROR);
300 }
301
302 if (getData(TCSD_PACKET_TYPE_UINT32, 2, delegateTableSize, 0, &hte->comm)) {
303 free(*familyTable);
304 return TSPERR(TSS_E_INTERNAL_ERROR);
305 }
306 *delegateTable = (BYTE *)malloc(*delegateTableSize);
307 if (*delegateTable == NULL) {
308 free(*familyTable);
309 LogError("malloc of %u bytes failed.", *delegateTableSize);
310 return TSPERR(TSS_E_OUTOFMEMORY);
311 }
312 if (getData(TCSD_PACKET_TYPE_PBYTE, 3, *delegateTable, *delegateTableSize, &hte->comm)) {
313 free(*familyTable);
314 free(*delegateTable);
315 return TSPERR(TSS_E_INTERNAL_ERROR);
316 }
317 }
318
319 return result;
320 }
321
322 TSS_RESULT
RPC_Delegate_UpdateVerificationCount_TP(struct host_table_entry * hte,UINT32 inputSize,BYTE * input,TPM_AUTH * ownerAuth,UINT32 * outputSize,BYTE ** output)323 RPC_Delegate_UpdateVerificationCount_TP(struct host_table_entry *hte,
324 UINT32 inputSize, /* in */
325 BYTE *input, /* in */
326 TPM_AUTH *ownerAuth, /* in/out */
327 UINT32 *outputSize, /* out */
328 BYTE **output) /* out */
329 {
330 TSS_RESULT result;
331 int i;
332
333 initData(&hte->comm, 4);
334 hte->comm.hdr.u.ordinal = TCSD_ORD_DELEGATE_UPDATEVERIFICATIONCOUNT;
335 LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
336
337 if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
338 return TSPERR(TSS_E_INTERNAL_ERROR);
339 if (setData(TCSD_PACKET_TYPE_UINT32, 1, &inputSize, 0, &hte->comm))
340 return TSPERR(TSS_E_INTERNAL_ERROR);
341 if (setData(TCSD_PACKET_TYPE_PBYTE, 2, input, inputSize, &hte->comm))
342 return TSPERR(TSS_E_INTERNAL_ERROR);
343 if (ownerAuth) {
344 if (setData(TCSD_PACKET_TYPE_AUTH, 3, ownerAuth, 0, &hte->comm))
345 return TSPERR(TSS_E_INTERNAL_ERROR);
346 } else {
347 TPM_AUTH nullAuth;
348
349 __tspi_memset(&nullAuth, 0, sizeof(TPM_AUTH));
350 if (setData(TCSD_PACKET_TYPE_AUTH, 3, &nullAuth, 0, &hte->comm))
351 return TSPERR(TSS_E_INTERNAL_ERROR);
352 }
353
354 result = sendTCSDPacket(hte);
355
356 if (result == TSS_SUCCESS)
357 result = hte->comm.hdr.u.result;
358
359 if (result == TSS_SUCCESS) {
360 i = 0;
361 if (ownerAuth) {
362 if (getData(TCSD_PACKET_TYPE_AUTH, i++, ownerAuth, 0, &hte->comm))
363 return TSPERR(TSS_E_INTERNAL_ERROR);
364 }
365 if (getData(TCSD_PACKET_TYPE_UINT32, i++, outputSize, 0, &hte->comm))
366 return TSPERR(TSS_E_INTERNAL_ERROR);
367 *output = (BYTE *)malloc(*outputSize);
368 if (*output == NULL) {
369 LogError("malloc of %u bytes failed.", *outputSize);
370 return TSPERR(TSS_E_OUTOFMEMORY);
371 }
372 if (getData(TCSD_PACKET_TYPE_PBYTE, i++, *output, *outputSize, &hte->comm)) {
373 free(*output);
374 output = NULL;
375 return TSPERR(TSS_E_INTERNAL_ERROR);
376 }
377 }
378
379 return result;
380 }
381
382 TSS_RESULT
RPC_Delegate_VerifyDelegation_TP(struct host_table_entry * hte,UINT32 delegateSize,BYTE * delegate)383 RPC_Delegate_VerifyDelegation_TP(struct host_table_entry *hte,
384 UINT32 delegateSize, /* in */
385 BYTE *delegate) /* in */
386 {
387 TSS_RESULT result;
388
389 initData(&hte->comm, 3);
390 hte->comm.hdr.u.ordinal = TCSD_ORD_DELEGATE_VERIFYDELEGATION;
391 LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
392
393 if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
394 return TSPERR(TSS_E_INTERNAL_ERROR);
395 if (setData(TCSD_PACKET_TYPE_UINT32, 1, &delegateSize, 0, &hte->comm))
396 return TSPERR(TSS_E_INTERNAL_ERROR);
397 if (setData(TCSD_PACKET_TYPE_PBYTE, 2, delegate, delegateSize, &hte->comm))
398 return TSPERR(TSS_E_INTERNAL_ERROR);
399
400 result = sendTCSDPacket(hte);
401
402 if (result == TSS_SUCCESS)
403 result = hte->comm.hdr.u.result;
404
405 return result;
406 }
407
408 TSS_RESULT
RPC_DSAP_TP(struct host_table_entry * hte,TPM_ENTITY_TYPE entityType,TCS_KEY_HANDLE keyHandle,TPM_NONCE * nonceOddDSAP,UINT32 entityValueSize,BYTE * entityValue,TCS_AUTHHANDLE * authHandle,TPM_NONCE * nonceEven,TPM_NONCE * nonceEvenDSAP)409 RPC_DSAP_TP(struct host_table_entry *hte,
410 TPM_ENTITY_TYPE entityType, /* in */
411 TCS_KEY_HANDLE keyHandle, /* in */
412 TPM_NONCE *nonceOddDSAP, /* in */
413 UINT32 entityValueSize, /* in */
414 BYTE * entityValue, /* in */
415 TCS_AUTHHANDLE *authHandle, /* out */
416 TPM_NONCE *nonceEven, /* out */
417 TPM_NONCE *nonceEvenDSAP) /* out */
418 {
419 TSS_RESULT result;
420
421 initData(&hte->comm, 6);
422 hte->comm.hdr.u.ordinal = TCSD_ORD_DSAP;
423 LogDebugFn("TCS Context: 0x%x", hte->tcsContext);
424
425 if (setData(TCSD_PACKET_TYPE_UINT32, 0, &hte->tcsContext, 0, &hte->comm))
426 return TSPERR(TSS_E_INTERNAL_ERROR);
427 if (setData(TCSD_PACKET_TYPE_UINT16, 1, &entityType, 0, &hte->comm))
428 return TSPERR(TSS_E_INTERNAL_ERROR);
429 if (setData(TCSD_PACKET_TYPE_UINT32, 2, &keyHandle, 0, &hte->comm))
430 return TSPERR(TSS_E_INTERNAL_ERROR);
431 if (setData(TCSD_PACKET_TYPE_NONCE, 3, nonceOddDSAP, 0, &hte->comm))
432 return TSPERR(TSS_E_INTERNAL_ERROR);
433 if (setData(TCSD_PACKET_TYPE_UINT32, 4, &entityValueSize, 0, &hte->comm))
434 return TSPERR(TSS_E_INTERNAL_ERROR);
435 if (setData(TCSD_PACKET_TYPE_PBYTE, 5, entityValue, entityValueSize, &hte->comm))
436 return TSPERR(TSS_E_INTERNAL_ERROR);
437
438 result = sendTCSDPacket(hte);
439
440 if (result == TSS_SUCCESS)
441 result = hte->comm.hdr.u.result;
442
443 if (result == TSS_SUCCESS) {
444 if (getData(TCSD_PACKET_TYPE_UINT32, 0, authHandle, 0, &hte->comm))
445 return TSPERR(TSS_E_INTERNAL_ERROR);
446 if (getData(TCSD_PACKET_TYPE_NONCE, 1, nonceEven, 0, &hte->comm))
447 return TSPERR(TSS_E_INTERNAL_ERROR);
448 if (getData(TCSD_PACKET_TYPE_NONCE, 2, nonceEvenDSAP, 0, &hte->comm))
449 return TSPERR(TSS_E_INTERNAL_ERROR);
450 }
451
452 return result;
453 }
454