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 <syslog.h>
14 #include <string.h>
15 #include <netdb.h>
16
17 #include "trousers/tss.h"
18 #include "trousers_types.h"
19 #include "tcs_tsp.h"
20 #include "tcs_utils.h"
21 #include "tcs_int_literals.h"
22 #include "capabilities.h"
23 #include "tcslog.h"
24 #include "tcsd_wrap.h"
25 #include "tcsd.h"
26 #include "tcs_utils.h"
27 #include "rpc_tcstp_tcs.h"
28
29
30 TSS_RESULT
tcs_wrap_Delegate_Manage(struct tcsd_thread_data * data)31 tcs_wrap_Delegate_Manage(struct tcsd_thread_data *data)
32 {
33 TCS_CONTEXT_HANDLE hContext;
34 TPM_FAMILY_ID familyId;
35 TPM_FAMILY_OPERATION opFlag;
36 UINT32 opDataSize;
37 BYTE *opData;
38 TPM_AUTH ownerAuth, nullAuth, *pAuth;
39 UINT32 retDataSize;
40 BYTE *retData;
41 TSS_RESULT result;
42 int i;
43
44 memset(&ownerAuth, 0, sizeof(TPM_AUTH));
45 memset(&nullAuth, 0, sizeof(TPM_AUTH));
46
47 if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
48 return TCSERR(TSS_E_INTERNAL_ERROR);
49
50 if ((result = ctx_verify_context(hContext)))
51 goto done;
52
53 LogDebugFn("thread %ld context %x", THREAD_ID, hContext);
54
55 if (getData(TCSD_PACKET_TYPE_UINT32, 1, &familyId, 0, &data->comm))
56 return TCSERR(TSS_E_INTERNAL_ERROR);
57
58 if (getData(TCSD_PACKET_TYPE_UINT32, 2, &opFlag, 0, &data->comm))
59 return TCSERR(TSS_E_INTERNAL_ERROR);
60
61 if (getData(TCSD_PACKET_TYPE_UINT32, 3, &opDataSize, 0, &data->comm))
62 return TCSERR(TSS_E_INTERNAL_ERROR);
63
64 opData = malloc(opDataSize);
65 if (opData == NULL) {
66 LogError("malloc of %u bytes failed.", opDataSize);
67 return TCSERR(TSS_E_OUTOFMEMORY);
68 }
69 if (getData(TCSD_PACKET_TYPE_PBYTE, 4, opData, opDataSize, &data->comm)) {
70 free(opData);
71 return TCSERR(TSS_E_INTERNAL_ERROR);
72 }
73
74 if (getData(TCSD_PACKET_TYPE_AUTH, 5, &ownerAuth, 0, &data->comm)) {
75 free(opData);
76 return TCSERR(TSS_E_INTERNAL_ERROR);
77 }
78
79 if (memcmp(&nullAuth, &ownerAuth, sizeof(TPM_AUTH)))
80 pAuth = &ownerAuth;
81 else
82 pAuth = NULL;
83
84 MUTEX_LOCK(tcsp_lock);
85
86 result = TCSP_Delegate_Manage_Internal(hContext, familyId, opFlag,
87 opDataSize, opData, pAuth, &retDataSize, &retData);
88
89 MUTEX_UNLOCK(tcsp_lock);
90 free(opData);
91
92 if (result == TSS_SUCCESS) {
93 i = 0;
94 initData(&data->comm, 3);
95 if (pAuth) {
96 if (setData(TCSD_PACKET_TYPE_AUTH, i++, pAuth, 0, &data->comm)) {
97 free(retData);
98 return TCSERR(TSS_E_INTERNAL_ERROR);
99 }
100 }
101
102 if (setData(TCSD_PACKET_TYPE_UINT32, i++, &retDataSize, 0, &data->comm)) {
103 free(retData);
104 return TCSERR(TSS_E_INTERNAL_ERROR);
105 }
106 if (setData(TCSD_PACKET_TYPE_PBYTE, i++, retData, retDataSize, &data->comm)) {
107 free(retData);
108 return TCSERR(TSS_E_INTERNAL_ERROR);
109 }
110 free(retData);
111 } else
112 done: initData(&data->comm, 0);
113
114 data->comm.hdr.u.result = result;
115
116 return TSS_SUCCESS;
117 }
118
119 TSS_RESULT
tcs_wrap_Delegate_CreateKeyDelegation(struct tcsd_thread_data * data)120 tcs_wrap_Delegate_CreateKeyDelegation(struct tcsd_thread_data *data)
121 {
122 TCS_CONTEXT_HANDLE hContext;
123 TCS_KEY_HANDLE hKey;
124 UINT32 publicInfoSize;
125 BYTE *publicInfo;
126 TPM_ENCAUTH encDelAuth;
127 TPM_AUTH keyAuth, nullAuth, *pAuth;
128 UINT32 blobSize;
129 BYTE *blob;
130 TSS_RESULT result;
131 int i;
132
133 memset(&keyAuth, 0, sizeof(TPM_AUTH));
134 memset(&nullAuth, 0, sizeof(TPM_AUTH));
135
136 if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
137 return TCSERR(TSS_E_INTERNAL_ERROR);
138
139 if ((result = ctx_verify_context(hContext)))
140 goto done;
141
142 LogDebugFn("thread %ld context %x", THREAD_ID, hContext);
143
144 if (getData(TCSD_PACKET_TYPE_UINT32, 1, &hKey, 0, &data->comm))
145 return TCSERR(TSS_E_INTERNAL_ERROR);
146
147 if (getData(TCSD_PACKET_TYPE_UINT32, 2, &publicInfoSize, 0, &data->comm))
148 return TCSERR(TSS_E_INTERNAL_ERROR);
149
150 publicInfo = malloc(publicInfoSize);
151 if (publicInfo == NULL) {
152 LogError("malloc of %u bytes failed.", publicInfoSize);
153 return TCSERR(TSS_E_OUTOFMEMORY);
154 }
155 if (getData(TCSD_PACKET_TYPE_PBYTE, 3, publicInfo, publicInfoSize, &data->comm)) {
156 free(publicInfo);
157 return TCSERR(TSS_E_INTERNAL_ERROR);
158 }
159
160 if (getData(TCSD_PACKET_TYPE_ENCAUTH, 4, &encDelAuth, 0, &data->comm)) {
161 free(publicInfo);
162 return TCSERR(TSS_E_INTERNAL_ERROR);
163 }
164
165 if (getData(TCSD_PACKET_TYPE_AUTH, 5, &keyAuth, 0, &data->comm)) {
166 free(publicInfo);
167 return TCSERR(TSS_E_INTERNAL_ERROR);
168 }
169
170 if (memcmp(&nullAuth, &keyAuth, sizeof(TPM_AUTH)))
171 pAuth = &keyAuth;
172 else
173 pAuth = NULL;
174
175 MUTEX_LOCK(tcsp_lock);
176
177 result = TCSP_Delegate_CreateKeyDelegation_Internal(hContext, hKey,
178 publicInfoSize, publicInfo, &encDelAuth, pAuth, &blobSize, &blob);
179
180 MUTEX_UNLOCK(tcsp_lock);
181 free(publicInfo);
182
183 if (result == TSS_SUCCESS) {
184 i = 0;
185 initData(&data->comm, 3);
186 if (pAuth) {
187 if (setData(TCSD_PACKET_TYPE_AUTH, i++, pAuth, 0, &data->comm)) {
188 free(blob);
189 return TCSERR(TSS_E_INTERNAL_ERROR);
190 }
191 }
192
193 if (setData(TCSD_PACKET_TYPE_UINT32, i++, &blobSize, 0, &data->comm)) {
194 free(blob);
195 return TCSERR(TSS_E_INTERNAL_ERROR);
196 }
197 if (setData(TCSD_PACKET_TYPE_PBYTE, i++, blob, blobSize, &data->comm)) {
198 free(blob);
199 return TCSERR(TSS_E_INTERNAL_ERROR);
200 }
201 free(blob);
202 } else
203 done: initData(&data->comm, 0);
204
205 data->comm.hdr.u.result = result;
206
207 return TSS_SUCCESS;
208 }
209
210 TSS_RESULT
tcs_wrap_Delegate_CreateOwnerDelegation(struct tcsd_thread_data * data)211 tcs_wrap_Delegate_CreateOwnerDelegation(struct tcsd_thread_data *data)
212 {
213 TCS_CONTEXT_HANDLE hContext;
214 TSS_BOOL increment;
215 UINT32 publicInfoSize;
216 BYTE *publicInfo;
217 TPM_ENCAUTH encDelAuth;
218 TPM_AUTH ownerAuth, nullAuth, *pAuth;
219 UINT32 blobSize;
220 BYTE *blob;
221 TSS_RESULT result;
222 int i;
223
224 memset(&ownerAuth, 0, sizeof(TPM_AUTH));
225 memset(&nullAuth, 0, sizeof(TPM_AUTH));
226
227 if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
228 return TCSERR(TSS_E_INTERNAL_ERROR);
229
230 if ((result = ctx_verify_context(hContext)))
231 goto done;
232
233 LogDebugFn("thread %ld context %x", THREAD_ID, hContext);
234
235 if (getData(TCSD_PACKET_TYPE_BOOL, 1, &increment, 0, &data->comm))
236 return TCSERR(TSS_E_INTERNAL_ERROR);
237
238 if (getData(TCSD_PACKET_TYPE_UINT32, 2, &publicInfoSize, 0, &data->comm))
239 return TCSERR(TSS_E_INTERNAL_ERROR);
240
241 publicInfo = malloc(publicInfoSize);
242 if (publicInfo == NULL) {
243 LogError("malloc of %u bytes failed.", publicInfoSize);
244 return TCSERR(TSS_E_OUTOFMEMORY);
245 }
246 if (getData(TCSD_PACKET_TYPE_PBYTE, 3, publicInfo, publicInfoSize, &data->comm)) {
247 free(publicInfo);
248 return TCSERR(TSS_E_INTERNAL_ERROR);
249 }
250
251 if (getData(TCSD_PACKET_TYPE_ENCAUTH, 4, &encDelAuth, 0, &data->comm)) {
252 free(publicInfo);
253 return TCSERR(TSS_E_INTERNAL_ERROR);
254 }
255
256 if (getData(TCSD_PACKET_TYPE_AUTH, 5, &ownerAuth, 0, &data->comm)) {
257 free(publicInfo);
258 return TCSERR(TSS_E_INTERNAL_ERROR);
259 }
260
261 if (memcmp(&nullAuth, &ownerAuth, sizeof(TPM_AUTH)))
262 pAuth = &ownerAuth;
263 else
264 pAuth = NULL;
265
266 MUTEX_LOCK(tcsp_lock);
267
268 result = TCSP_Delegate_CreateOwnerDelegation_Internal(hContext, increment,
269 publicInfoSize, publicInfo, &encDelAuth, pAuth, &blobSize, &blob);
270
271 MUTEX_UNLOCK(tcsp_lock);
272 free(publicInfo);
273
274 if (result == TSS_SUCCESS) {
275 i = 0;
276 initData(&data->comm, 3);
277 if (pAuth) {
278 if (setData(TCSD_PACKET_TYPE_AUTH, i++, pAuth, 0, &data->comm)) {
279 free(blob);
280 return TCSERR(TSS_E_INTERNAL_ERROR);
281 }
282 }
283
284 if (setData(TCSD_PACKET_TYPE_UINT32, i++, &blobSize, 0, &data->comm)) {
285 free(blob);
286 return TCSERR(TSS_E_INTERNAL_ERROR);
287 }
288 if (setData(TCSD_PACKET_TYPE_PBYTE, i++, blob, blobSize, &data->comm)) {
289 free(blob);
290 return TCSERR(TSS_E_INTERNAL_ERROR);
291 }
292 free(blob);
293 } else
294 done: initData(&data->comm, 0);
295
296 data->comm.hdr.u.result = result;
297
298 return TSS_SUCCESS;
299 }
300
301 TSS_RESULT
tcs_wrap_Delegate_LoadOwnerDelegation(struct tcsd_thread_data * data)302 tcs_wrap_Delegate_LoadOwnerDelegation(struct tcsd_thread_data *data)
303 {
304 TCS_CONTEXT_HANDLE hContext;
305 TPM_DELEGATE_INDEX index;
306 UINT32 blobSize;
307 BYTE *blob;
308 TPM_AUTH ownerAuth, nullAuth, *pAuth;
309 TSS_RESULT result;
310
311 memset(&ownerAuth, 0, sizeof(TPM_AUTH));
312 memset(&nullAuth, 0, sizeof(TPM_AUTH));
313
314 if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
315 return TCSERR(TSS_E_INTERNAL_ERROR);
316
317 if ((result = ctx_verify_context(hContext)))
318 goto done;
319
320 LogDebugFn("thread %ld context %x", THREAD_ID, hContext);
321
322 if (getData(TCSD_PACKET_TYPE_UINT32, 1, &index, 0, &data->comm))
323 return TCSERR(TSS_E_INTERNAL_ERROR);
324
325 if (getData(TCSD_PACKET_TYPE_UINT32, 2, &blobSize, 0, &data->comm))
326 return TCSERR(TSS_E_INTERNAL_ERROR);
327
328 blob = malloc(blobSize);
329 if (blob == NULL) {
330 LogError("malloc of %u bytes failed.", blobSize);
331 return TCSERR(TSS_E_OUTOFMEMORY);
332 }
333 if (getData(TCSD_PACKET_TYPE_PBYTE, 3, blob, blobSize, &data->comm)) {
334 free(blob);
335 return TCSERR(TSS_E_INTERNAL_ERROR);
336 }
337
338 if (getData(TCSD_PACKET_TYPE_AUTH, 4, &ownerAuth, 0, &data->comm)) {
339 free(blob);
340 return TCSERR(TSS_E_INTERNAL_ERROR);
341 }
342
343 if (memcmp(&nullAuth, &ownerAuth, sizeof(TPM_AUTH)))
344 pAuth = &ownerAuth;
345 else
346 pAuth = NULL;
347
348 MUTEX_LOCK(tcsp_lock);
349
350 result = TCSP_Delegate_LoadOwnerDelegation_Internal(hContext, index, blobSize, blob,
351 pAuth);
352
353 MUTEX_UNLOCK(tcsp_lock);
354 free(blob);
355
356 if (result == TSS_SUCCESS) {
357 initData(&data->comm, 1);
358 if (pAuth) {
359 if (setData(TCSD_PACKET_TYPE_AUTH, 0, pAuth, 0, &data->comm)) {
360 return TCSERR(TSS_E_INTERNAL_ERROR);
361 }
362 }
363 } else
364 done: initData(&data->comm, 0);
365
366 data->comm.hdr.u.result = result;
367
368 return TSS_SUCCESS;
369 }
370
371 TSS_RESULT
tcs_wrap_Delegate_ReadTable(struct tcsd_thread_data * data)372 tcs_wrap_Delegate_ReadTable(struct tcsd_thread_data *data)
373 {
374 TCS_CONTEXT_HANDLE hContext;
375 UINT32 familyTableSize;
376 BYTE *familyTable;
377 UINT32 delegateTableSize;
378 BYTE *delegateTable;
379 TSS_RESULT result;
380
381 if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
382 return TCSERR(TSS_E_INTERNAL_ERROR);
383
384 if ((result = ctx_verify_context(hContext)))
385 goto done;
386
387 LogDebugFn("thread %ld context %x", THREAD_ID, hContext);
388
389 MUTEX_LOCK(tcsp_lock);
390
391 result = TCSP_Delegate_ReadTable_Internal(hContext, &familyTableSize, &familyTable,
392 &delegateTableSize, &delegateTable);
393
394 MUTEX_UNLOCK(tcsp_lock);
395
396 if (result == TSS_SUCCESS) {
397 initData(&data->comm, 4);
398 if (setData(TCSD_PACKET_TYPE_UINT32, 0, &familyTableSize, 0, &data->comm)) {
399 free(familyTable);
400 free(delegateTable);
401 return TCSERR(TSS_E_INTERNAL_ERROR);
402 }
403 if (setData(TCSD_PACKET_TYPE_PBYTE, 1, familyTable, familyTableSize, &data->comm)) {
404 free(familyTable);
405 free(delegateTable);
406 return TCSERR(TSS_E_INTERNAL_ERROR);
407 }
408 free(familyTable);
409
410 if (setData(TCSD_PACKET_TYPE_UINT32, 2, &delegateTableSize, 0, &data->comm)) {
411 free(delegateTable);
412 return TCSERR(TSS_E_INTERNAL_ERROR);
413 }
414 if (setData(TCSD_PACKET_TYPE_PBYTE, 3, delegateTable, delegateTableSize, &data->comm)) {
415 free(delegateTable);
416 return TCSERR(TSS_E_INTERNAL_ERROR);
417 }
418 free(delegateTable);
419 } else
420 done: initData(&data->comm, 0);
421
422 data->comm.hdr.u.result = result;
423
424 return TSS_SUCCESS;
425 }
426
427 TSS_RESULT
tcs_wrap_Delegate_UpdateVerificationCount(struct tcsd_thread_data * data)428 tcs_wrap_Delegate_UpdateVerificationCount(struct tcsd_thread_data *data)
429 {
430 TCS_CONTEXT_HANDLE hContext;
431 UINT32 inputSize;
432 BYTE *input;
433 TPM_AUTH ownerAuth, nullAuth, *pAuth;
434 UINT32 outputSize;
435 BYTE *output;
436 TSS_RESULT result;
437 int i;
438
439 memset(&ownerAuth, 0, sizeof(TPM_AUTH));
440 memset(&nullAuth, 0, sizeof(TPM_AUTH));
441
442 if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
443 return TCSERR(TSS_E_INTERNAL_ERROR);
444
445 if ((result = ctx_verify_context(hContext)))
446 goto done;
447
448 LogDebugFn("thread %ld context %x", THREAD_ID, hContext);
449
450 if (getData(TCSD_PACKET_TYPE_UINT32, 1, &inputSize, 0, &data->comm))
451 return TCSERR(TSS_E_INTERNAL_ERROR);
452
453 input = malloc(inputSize);
454 if (input == NULL) {
455 LogError("malloc of %u bytes failed.", inputSize);
456 return TCSERR(TSS_E_OUTOFMEMORY);
457 }
458 if (getData(TCSD_PACKET_TYPE_PBYTE, 2, input, inputSize, &data->comm)) {
459 free(input);
460 return TCSERR(TSS_E_INTERNAL_ERROR);
461 }
462
463 if (getData(TCSD_PACKET_TYPE_AUTH, 3, &ownerAuth, 0, &data->comm)) {
464 free(input);
465 return TCSERR(TSS_E_INTERNAL_ERROR);
466 }
467
468 if (memcmp(&nullAuth, &ownerAuth, sizeof(TPM_AUTH)))
469 pAuth = &ownerAuth;
470 else
471 pAuth = NULL;
472
473 MUTEX_LOCK(tcsp_lock);
474
475 result = TCSP_Delegate_UpdateVerificationCount_Internal(hContext, inputSize, input,
476 pAuth, &outputSize, &output);
477
478 MUTEX_UNLOCK(tcsp_lock);
479 free(input);
480
481 if (result == TSS_SUCCESS) {
482 i = 0;
483 initData(&data->comm, 3);
484 if (pAuth) {
485 if (setData(TCSD_PACKET_TYPE_AUTH, i++, pAuth, 0, &data->comm)) {
486 free(output);
487 return TCSERR(TSS_E_INTERNAL_ERROR);
488 }
489 }
490
491 if (setData(TCSD_PACKET_TYPE_UINT32, i++, &outputSize, 0, &data->comm)) {
492 free(output);
493 return TCSERR(TSS_E_INTERNAL_ERROR);
494 }
495 if (setData(TCSD_PACKET_TYPE_PBYTE, i++, output, outputSize, &data->comm)) {
496 free(output);
497 return TCSERR(TSS_E_INTERNAL_ERROR);
498 }
499 free(output);
500 } else
501 done: initData(&data->comm, 0);
502
503 data->comm.hdr.u.result = result;
504
505 return TSS_SUCCESS;
506 }
507
508 TSS_RESULT
tcs_wrap_Delegate_VerifyDelegation(struct tcsd_thread_data * data)509 tcs_wrap_Delegate_VerifyDelegation(struct tcsd_thread_data *data)
510 {
511 TCS_CONTEXT_HANDLE hContext;
512 UINT32 delegateSize;
513 BYTE *delegate;
514 TSS_RESULT result;
515
516 if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
517 return TCSERR(TSS_E_INTERNAL_ERROR);
518
519 if ((result = ctx_verify_context(hContext)))
520 goto done;
521
522 LogDebugFn("thread %ld context %x", THREAD_ID, hContext);
523
524 if (getData(TCSD_PACKET_TYPE_UINT32, 1, &delegateSize, 0, &data->comm))
525 return TCSERR(TSS_E_INTERNAL_ERROR);
526
527 delegate = malloc(delegateSize);
528 if (delegate == NULL) {
529 LogError("malloc of %u bytes failed.", delegateSize);
530 return TCSERR(TSS_E_OUTOFMEMORY);
531 }
532 if (getData(TCSD_PACKET_TYPE_PBYTE, 2, delegate, delegateSize, &data->comm)) {
533 free(delegate);
534 return TCSERR(TSS_E_INTERNAL_ERROR);
535 }
536
537 MUTEX_LOCK(tcsp_lock);
538
539 result = TCSP_Delegate_VerifyDelegation_Internal(hContext, delegateSize, delegate);
540
541 MUTEX_UNLOCK(tcsp_lock);
542 free(delegate);
543 done:
544 initData(&data->comm, 0);
545
546 data->comm.hdr.u.result = result;
547
548 return TSS_SUCCESS;
549 }
550
551 TSS_RESULT
tcs_wrap_DSAP(struct tcsd_thread_data * data)552 tcs_wrap_DSAP(struct tcsd_thread_data *data)
553 {
554 TCS_CONTEXT_HANDLE hContext;
555 UINT16 entityType;
556 TCS_KEY_HANDLE keyHandle;
557 TPM_NONCE nonceOddDSAP, nonceEven, nonceEvenDSAP;
558 UINT32 entityValueSize;
559 BYTE *entityValue;
560 TCS_AUTHHANDLE authHandle;
561 TSS_RESULT result;
562
563 if (getData(TCSD_PACKET_TYPE_UINT32, 0, &hContext, 0, &data->comm))
564 return TCSERR(TSS_E_INTERNAL_ERROR);
565
566 if ((result = ctx_verify_context(hContext)))
567 goto done;
568
569 LogDebugFn("thread %ld context %x", THREAD_ID, hContext);
570
571 if (getData(TCSD_PACKET_TYPE_UINT16, 1, &entityType, 0, &data->comm))
572 return TCSERR(TSS_E_INTERNAL_ERROR);
573 if (getData(TCSD_PACKET_TYPE_UINT32, 2, &keyHandle, 0, &data->comm))
574 return TCSERR(TSS_E_INTERNAL_ERROR);
575 if (getData(TCSD_PACKET_TYPE_NONCE, 3, &nonceOddDSAP, 0, &data->comm))
576 return TCSERR(TSS_E_INTERNAL_ERROR);
577 if (getData(TCSD_PACKET_TYPE_UINT32, 4, &entityValueSize, 0, &data->comm))
578 return TCSERR(TSS_E_INTERNAL_ERROR);
579
580 entityValue = malloc(entityValueSize);
581 if (entityValue == NULL) {
582 LogError("malloc of %u bytes failed.", entityValueSize);
583 return TCSERR(TSS_E_OUTOFMEMORY);
584 }
585 if (getData(TCSD_PACKET_TYPE_PBYTE, 5, entityValue, entityValueSize, &data->comm)) {
586 free(entityValue);
587 return TCSERR(TSS_E_INTERNAL_ERROR);
588 }
589
590 MUTEX_LOCK(tcsp_lock);
591
592 result = TCSP_DSAP_Internal(hContext, entityType, keyHandle, &nonceOddDSAP, entityValueSize,
593 entityValue, &authHandle, &nonceEven, &nonceEvenDSAP);
594
595 MUTEX_UNLOCK(tcsp_lock);
596 free(entityValue);
597
598 if (result == TSS_SUCCESS) {
599 initData(&data->comm, 3);
600
601 if (setData(TCSD_PACKET_TYPE_UINT32, 0, &authHandle, 0, &data->comm))
602 return TCSERR(TSS_E_INTERNAL_ERROR);
603 if (setData(TCSD_PACKET_TYPE_NONCE, 1, &nonceEven, 0, &data->comm))
604 return TCSERR(TSS_E_INTERNAL_ERROR);
605 if (setData(TCSD_PACKET_TYPE_NONCE, 2, &nonceEvenDSAP, 0, &data->comm))
606 return TCSERR(TSS_E_INTERNAL_ERROR);
607 } else
608 done: initData(&data->comm, 0);
609
610 data->comm.hdr.u.result = result;
611
612 return TSS_SUCCESS;
613 }
614
615