Home | History | Annotate | Line # | Download | only in tcstp 
      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
     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
    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
    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
    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
    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
    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
    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
    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