static TPM_RESULT execute_TPM_MakeIdentity(TPM_REQUEST *req, TPM_RESPONSE *rsp)
{
BYTE *ptr;
UINT32 len;
TPM_ENCAUTH identityAuth;
TPM_CHOSENID_HASH labelPrivCADigest;
TPM_KEY idKeyParams;
TPM_KEY idKey;
UINT32 identityBindingSize;
BYTE *identityBinding = NULL;
TPM_RESULT res;
/* compute parameter digest */
tpm_compute_in_param_digest(req);
/* unmarshal input */
ptr = req->param;
len = req->paramSize;
if (tpm_unmarshal_TPM_ENCAUTH(&ptr, &len, &identityAuth)
|| tpm_unmarshal_TPM_CHOSENID_HASH(&ptr, &len, &labelPrivCADigest)
|| tpm_unmarshal_TPM_KEY(&ptr, &len, &idKeyParams)
|| len != 0) return TPM_BAD_PARAMETER;
/* execute command */
res = TPM_MakeIdentity(&identityAuth, &labelPrivCADigest, &idKeyParams,
&req->auth1, &req->auth2, &idKey, &identityBindingSize, &identityBinding);
if (res != TPM_SUCCESS) return res;
/* marshal output */
rsp->paramSize = len = sizeof_TPM_KEY(idKey) + 4 + identityBindingSize;
rsp->param = ptr = ExtendBuf;
if (tpm_marshal_TPM_KEY(&ptr, &len, &idKey)
|| tpm_marshal_UINT32(&ptr, &len, identityBindingSize)
|| tpm_marshal_BLOB(&ptr, &len, identityBinding, identityBindingSize)) {
res = TPM_FAIL;
}
return res;
}
static TPM_RESULT execute_TPM_UnBind(TPM_REQUEST *req, TPM_RESPONSE *rsp)
{
BYTE *ptr;
UINT32 len;
TPM_KEY_HANDLE keyHandle;
UINT32 inDataSize;
BYTE *inData;
UINT32 outDataSize;
BYTE *outData = NULL;
TPM_RESULT res;
/* compute parameter digest */
tpm_compute_in_param_digest(req);
/* unmarshal input */
ptr = req->param;
len = req->paramSize;
if (tpm_unmarshal_TPM_KEY_HANDLE(&ptr, &len, &keyHandle)
|| tpm_unmarshal_UINT32(&ptr, &len, &inDataSize)
|| tpm_unmarshal_BLOB(&ptr, &len, &inData, inDataSize)
|| len != 0) return TPM_BAD_PARAMETER;
/* execute command */
res = TPM_UnBind(keyHandle, inDataSize, inData, &req->auth1, &outDataSize, &outData);
if (res != TPM_SUCCESS) return res;
/* marshal output */
rsp->paramSize = len = 4 + outDataSize;
rsp->param = ptr = ExtendBuf;
if (ptr == NULL
|| tpm_marshal_UINT32(&ptr, &len, outDataSize)
|| tpm_marshal_BLOB(&ptr, &len, outData, outDataSize)) {
free(rsp->param);
res = TPM_FAIL;
}
free(outData);
return res;
}
static void transport_log_in(BYTE *params, BYTE *pubKeyHash,
TPM_DIGEST *transDigest)
{
BYTE *ptr, buf[sizeof_TPM_TRANSPORT_LOG_IN(x)];
UINT32 len;
tpm_sha1_ctx_t sha1;
ptr = buf; len = sizeof(buf);
tpm_marshal_TPM_TAG(&ptr, &len, TPM_TAG_TRANSPORT_LOG_IN);
tpm_marshal_BLOB(&ptr, &len, params, SHA1_DIGEST_LENGTH);
tpm_marshal_BLOB(&ptr, &len, pubKeyHash, SHA1_DIGEST_LENGTH);
tpm_sha1_init(&sha1);
tpm_sha1_update(&sha1, transDigest->digest, sizeof(transDigest->digest));
tpm_sha1_update(&sha1, buf, sizeof(buf));
tpm_sha1_final(&sha1, transDigest->digest);
debug_buf("LogIn: transDigest: ", transDigest->digest, sizeof(transDigest->digest));
}
static void transport_log_out(BYTE *params, TPM_DIGEST *transDigest)
{
BYTE *ptr, buf[sizeof_TPM_TRANSPORT_LOG_OUT(x)];
UINT32 len;
tpm_sha1_ctx_t sha1;
ptr = buf; len = sizeof(buf);
tpm_marshal_TPM_TAG(&ptr, &len, TPM_TAG_TRANSPORT_LOG_OUT);
tpm_marshal_TPM_CURRENT_TICKS(&ptr, &len, &tpmData.stany.data.currentTicks);
tpm_marshal_BLOB(&ptr, &len, params, SHA1_DIGEST_LENGTH);
tpm_marshal_TPM_MODIFIER_INDICATOR(&ptr, &len, tpmData.stany.flags.localityModifier);
tpm_sha1_init(&sha1);
tpm_sha1_update(&sha1, transDigest->digest, sizeof(transDigest->digest));
tpm_sha1_update(&sha1, buf, sizeof(buf));
tpm_sha1_final(&sha1, transDigest->digest);
debug_buf("LogOut: transDigest: ", transDigest->digest, sizeof(transDigest->digest));
}
static TPM_RESULT execute_TPM_CertifyKey(TPM_REQUEST *req, TPM_RESPONSE *rsp)
{
BYTE *ptr;
UINT32 len;
TPM_KEY_HANDLE certHandle;
TPM_KEY_HANDLE keyHandle;
TPM_NONCE antiReplay;
TPM_CERTIFY_INFO certifyInfo;
UINT32 outDataSize;
BYTE *outData = NULL;
TPM_RESULT res;
/* compute parameter digest */
tpm_compute_in_param_digest(req);
/* unmarshal input */
ptr = req->param;
len = req->paramSize;
if (tpm_unmarshal_TPM_KEY_HANDLE(&ptr, &len, &certHandle)
|| tpm_unmarshal_TPM_KEY_HANDLE(&ptr, &len, &keyHandle)
|| tpm_unmarshal_TPM_NONCE(&ptr, &len, &antiReplay)
|| len != 0) return TPM_BAD_PARAMETER;
/* execute command */
res = TPM_CertifyKey(certHandle, keyHandle, &antiReplay, &req->auth1,
&req->auth2, &certifyInfo, &outDataSize, &outData);
if (res != TPM_SUCCESS) return res;
/* marshal output */
rsp->paramSize = len = sizeof_TPM_CERTIFY_INFO(certifyInfo) + 4 + outDataSize;
rsp->param = ptr = ExtendBuf;
if (ptr == NULL
|| tpm_marshal_TPM_CERTIFY_INFO(&ptr, &len, &certifyInfo)
|| tpm_marshal_UINT32(&ptr, &len, outDataSize)
|| tpm_marshal_BLOB(&ptr, &len, outData, outDataSize)) {
free(rsp->param);
res = TPM_FAIL;
}
free_TPM_CERTIFY_INFO(certifyInfo);
free(outData);
return res;
}
static TPM_RESULT execute_TPM_Quote(TPM_REQUEST *req, TPM_RESPONSE *rsp)
{
BYTE *ptr;
UINT32 len;
TPM_KEY_HANDLE keyHandle;
TPM_NONCE extrnalData;
TPM_PCR_SELECTION targetPCR;
TPM_PCR_COMPOSITE *pcrData;
UINT32 sigSize;
BYTE *sig = NULL;
TPM_RESULT res;
pcrData = (TPM_PCR_COMPOSITE *)InOutBuf;
/* compute parameter digest */
tpm_compute_in_param_digest(req);
/* unmarshal input */
ptr = req->param;
len = req->paramSize;
if (tpm_unmarshal_TPM_KEY_HANDLE(&ptr, &len, &keyHandle)
|| tpm_unmarshal_TPM_NONCE(&ptr, &len, &extrnalData)
|| tpm_unmarshal_TPM_PCR_SELECTION(&ptr, &len, &targetPCR)
|| len != 0) return TPM_BAD_PARAMETER;
/* execute command */
res = TPM_Quote(keyHandle, &extrnalData, &targetPCR, &req->auth1, pcrData, &sigSize, &sig);
if (res != TPM_SUCCESS) return res;
/* marshal output */
rsp->paramSize = len = sizeof_TPM_PCR_COMPOSITE((*pcrData)) + 4 + sigSize;
rsp->param = ptr = ExtendBuf;
if (ptr == NULL
|| tpm_marshal_TPM_PCR_COMPOSITE(&ptr, &len, pcrData)
|| tpm_marshal_UINT32(&ptr, &len, sigSize)
|| tpm_marshal_BLOB(&ptr, &len, sig, sigSize)) {
free(rsp->param);
res = TPM_FAIL;
}
free(sig);
return res;
}