TSS_RESULT
TCSP_GetRegisteredKeyByPublicInfo_Internal(TCS_CONTEXT_HANDLE tcsContext, /* in */
TCPA_ALGORITHM_ID algID, /* in */
UINT32 ulPublicInfoLength, /* in */
BYTE * rgbPublicInfo, /* in */
UINT32 * keySize, /* out */
BYTE ** keyBlob) /* out */
{
TCPA_STORE_PUBKEY pubKey;
TSS_RESULT result = TCSERR(TSS_E_FAIL);
if ((result = ctx_verify_context(tcsContext)))
return result;
if (algID == TCPA_ALG_RSA) {
/*--- Convert Public info to a structure */
pubKey.keyLength = ulPublicInfoLength;
pubKey.key = malloc(pubKey.keyLength);
if (pubKey.key == NULL) {
LogError("malloc of %d bytes failed.", pubKey.keyLength);
return TCSERR(TSS_E_OUTOFMEMORY);
}
memcpy(pubKey.key, rgbPublicInfo, pubKey.keyLength);
if ((result = ps_get_key_by_pub(&pubKey, keySize, keyBlob))) {
LogDebug("Public key data not found in PS");
free(pubKey.key);
return TCSERR(TSS_E_PS_KEY_NOTFOUND);
}
}
free(pubKey.key);
return result;
}
TSS_RESULT
Tspi_Context_GetKeyByPublicInfo(TSS_HCONTEXT tspContext, /* in */
TSS_FLAG persistentStorageType, /* in */
TSS_ALGORITHM_ID algID, /* in */
UINT32 ulPublicInfoLength, /* in */
BYTE * rgbPublicInfo, /* in */
TSS_HKEY * phKey) /* out */
{
TCPA_ALGORITHM_ID tcsAlgID;
UINT32 keyBlobSize;
BYTE *keyBlob;
TSS_RESULT result;
TSS_HKEY keyOutHandle;
UINT32 flag = 0;
TSS_KEY keyContainer;
UINT64 offset;
if (phKey == NULL)
return TSPERR(TSS_E_BAD_PARAMETER);
if (!obj_is_context(tspContext))
return TSPERR(TSS_E_INVALID_HANDLE);
switch (algID) {
case TSS_ALG_RSA:
tcsAlgID = TCPA_ALG_RSA;
break;
default:
LogError("Algorithm ID was not type RSA.");
return TSPERR(TSS_E_BAD_PARAMETER);
}
if (persistentStorageType == TSS_PS_TYPE_SYSTEM) {
if ((result = RPC_GetRegisteredKeyByPublicInfo(tspContext, tcsAlgID,
ulPublicInfoLength, rgbPublicInfo,
&keyBlobSize, &keyBlob)))
return result;
} else if (persistentStorageType == TSS_PS_TYPE_USER) {
return ps_get_key_by_pub(tspContext, ulPublicInfoLength, rgbPublicInfo,
phKey);
} else
return TSPERR(TSS_E_BAD_PARAMETER);
/* need to setup the init flags of the create object based on
* the size of the blob's pubkey */
offset = 0;
if ((result = UnloadBlob_TSS_KEY(&offset, keyBlob, &keyContainer))) {
free(keyBlob);
return result;
}
/* begin setting up the key object */
switch (keyContainer.pubKey.keyLength) {
case 16384/8:
flag |= TSS_KEY_SIZE_16384;
break;
case 8192/8:
flag |= TSS_KEY_SIZE_8192;
break;
case 4096/8:
flag |= TSS_KEY_SIZE_4096;
break;
case 2048/8:
flag |= TSS_KEY_SIZE_2048;
break;
case 1024/8:
flag |= TSS_KEY_SIZE_1024;
break;
case 512/8:
flag |= TSS_KEY_SIZE_512;
break;
default:
LogError("Key was not a known keylength.");
free(keyBlob);
free_key_refs(&keyContainer);
return TSPERR(TSS_E_INTERNAL_ERROR);
}
if (keyContainer.keyUsage == TPM_KEY_SIGNING)
flag |= TSS_KEY_TYPE_SIGNING;
else if (keyContainer.keyUsage == TPM_KEY_STORAGE)
flag |= TSS_KEY_TYPE_STORAGE;
else if (keyContainer.keyUsage == TPM_KEY_IDENTITY)
flag |= TSS_KEY_TYPE_IDENTITY;
else if (keyContainer.keyUsage == TPM_KEY_AUTHCHANGE)
flag |= TSS_KEY_TYPE_AUTHCHANGE;
else if (keyContainer.keyUsage == TPM_KEY_BIND)
flag |= TSS_KEY_TYPE_BIND;
else if (keyContainer.keyUsage == TPM_KEY_LEGACY)
flag |= TSS_KEY_TYPE_LEGACY;
if (keyContainer.authDataUsage == TPM_AUTH_NEVER)
flag |= TSS_KEY_NO_AUTHORIZATION;
else
flag |= TSS_KEY_AUTHORIZATION;
if (keyContainer.keyFlags & TPM_MIGRATABLE)
flag |= TSS_KEY_MIGRATABLE;
else
flag |= TSS_KEY_NOT_MIGRATABLE;
if (keyContainer.keyFlags & TPM_VOLATILE)
flag |= TSS_KEY_VOLATILE;
else
flag |= TSS_KEY_NON_VOLATILE;
#ifdef TSS_BUILD_CMK
if (keyContainer.keyFlags & TPM_MIGRATEAUTHORITY)
flag |= TSS_KEY_CERTIFIED_MIGRATABLE;
else
flag |= TSS_KEY_NOT_CERTIFIED_MIGRATABLE;
#endif
/* Create a new Key Object */
if ((result = obj_rsakey_add(tspContext, flag, &keyOutHandle))) {
free(keyBlob);
free_key_refs(&keyContainer);
return result;
}
/* Stick the info into this net KeyObject */
if ((result = obj_rsakey_set_tcpakey(keyOutHandle, keyBlobSize, keyBlob))) {
free(keyBlob);
free_key_refs(&keyContainer);
return result;
}
free(keyBlob);
free_key_refs(&keyContainer);
*phKey = keyOutHandle;
return TSS_SUCCESS;
}
