/*
* return a key blob from PS given its cache entry. The disk cache must be
* locked by the caller.
*/
TSS_RESULT
psfile_get_key_by_cache_entry(int fd, struct key_disk_cache *c, BYTE *ret_buffer,
UINT16 *ret_buffer_size)
{
int rc;
UINT32 file_offset = 0;
/* jump to the location of the key blob */
file_offset = TSSPS_BLOB_DATA_OFFSET(c);
rc = lseek(fd, file_offset, SEEK_SET);
if (rc == ((off_t) - 1)) {
LogError("lseek: %s", strerror(errno));
return TCSERR(TSS_E_INTERNAL_ERROR);
}
/* we found the key; file ptr is pointing at the blob */
if (*ret_buffer_size < c->blob_size) {
/* not enough room */
LogError("%s: Buf size too small. Needed %d bytes, passed %d", __FUNCTION__,
c->blob_size, *ret_buffer_size);
return TCSERR(TSS_E_INTERNAL_ERROR);
}
if ((rc = read_data(fd, ret_buffer, c->blob_size))) {
LogError("%s: error reading %d bytes", __FUNCTION__, c->blob_size);
return TCSERR(TSS_E_INTERNAL_ERROR);
}
*ret_buffer_size = c->blob_size;
return TSS_SUCCESS;
}
/*
* return a key struct from PS given a uuid
*/
TSS_RESULT
psfile_get_key_by_uuid(int fd, TSS_UUID *uuid, BYTE *key)
{
int rc;
TSS_RESULT result;
off_t file_offset;
struct key_disk_cache tmp;
BYTE buf[4096];
if ((result = psfile_get_cache_entry_by_uuid(fd, uuid, &tmp)))
return result;
/* jump to the location of the key blob */
file_offset = TSSPS_BLOB_DATA_OFFSET(&tmp);
rc = lseek(fd, file_offset, SEEK_SET);
if (rc == ((off_t)-1)) {
LogDebugFn("lseek: %s", strerror(errno));
return TSPERR(TSS_E_INTERNAL_ERROR);
}
if (tmp.blob_size > 4096) {
LogError("Blob size greater than 4096! Size: %d",
tmp.blob_size);
return TSPERR(TSS_E_INTERNAL_ERROR);
}
if ((rc = read_data(fd, buf, tmp.blob_size))) {
LogDebugFn("Blob read from disk failed.");
return rc;
}
memcpy(key, buf, tmp.blob_size);
return TSS_SUCCESS;
}
TSS_RESULT
copy_key_info2(int fd, TSS_KM_KEYINFO2 *ki, struct key_disk_cache *c)
{
TSS_KEY key;
BYTE blob[4096];
UINT64 offset;
TSS_RESULT result;
off_t off;
/* Set the file pointer to the offset that the key blob is at */
off = lseek(fd, TSSPS_BLOB_DATA_OFFSET(c), SEEK_SET);
if (off == ((off_t)-1)) {
LogDebug("lseek: %s", strerror(errno));
return TSPERR(TSS_E_INTERNAL_ERROR);
}
/* Read in the key blob */
if ((result = read_data(fd, (void *)blob, c->blob_size))) {
LogDebug("%s", __FUNCTION__);
return result;
}
/* Expand the blob into a useable form */
offset = 0;
if ((result = UnloadBlob_TSS_KEY(&offset, blob, &key)))
return result;
if (key.hdr.key12.tag == TPM_TAG_KEY12) {
ki->versionInfo.bMajor = TSS_SPEC_MAJOR;
ki->versionInfo.bMinor = TSS_SPEC_MINOR;
ki->versionInfo.bRevMajor = 0;
ki->versionInfo.bRevMinor = 0;
} else
memcpy(&ki->versionInfo, &key.hdr.key11.ver, sizeof(TSS_VERSION));
memcpy(&ki->keyUUID, &c->uuid, sizeof(TSS_UUID));
memcpy(&ki->parentKeyUUID, &c->parent_uuid, sizeof(TSS_UUID));
/* CHECK: fill the two new fields of TSS_KM_KEYINFO2 */
ki->persistentStorageType = TSS_PS_TYPE_USER;
ki->persistentStorageTypeParent = c->flags & CACHE_FLAG_PARENT_PS_SYSTEM ?
TSS_PS_TYPE_SYSTEM : TSS_PS_TYPE_USER;
ki->bAuthDataUsage = key.authDataUsage;
free_key_refs(&key);
return TSS_SUCCESS;
}
/*
* return a key blob from PS given a uuid
*/
TSS_RESULT
psfile_get_key_by_uuid(int fd, TSS_UUID *uuid, BYTE *ret_buffer, UINT16 *ret_buffer_size)
{
int rc;
UINT32 file_offset = 0;
struct key_disk_cache *tmp;
MUTEX_LOCK(disk_cache_lock);
tmp = key_disk_cache_head;
while (tmp) {
if (memcmp(uuid, &tmp->uuid, sizeof(TSS_UUID)) || !(tmp->flags & CACHE_FLAG_VALID)) {
tmp = tmp->next;
continue;
}
/* jump to the location of the key blob */
file_offset = TSSPS_BLOB_DATA_OFFSET(tmp);
rc = lseek(fd, file_offset, SEEK_SET);
if (rc == ((off_t) - 1)) {
LogError("lseek: %s", strerror(errno));
MUTEX_UNLOCK(disk_cache_lock);
return TCSERR(TSS_E_INTERNAL_ERROR);
}
/* we found the key; file ptr is pointing at the blob */
if (*ret_buffer_size < tmp->blob_size) {
/* not enough room */
MUTEX_UNLOCK(disk_cache_lock);
return TCSERR(TSS_E_FAIL);
}
if ((rc = read_data(fd, ret_buffer, tmp->blob_size))) {
LogError("%s", __FUNCTION__);
MUTEX_UNLOCK(disk_cache_lock);
return rc;
}
*ret_buffer_size = tmp->blob_size;
LogDebugUnrollKey(ret_buffer);
MUTEX_UNLOCK(disk_cache_lock);
return TSS_SUCCESS;
}
MUTEX_UNLOCK(disk_cache_lock);
/* key not found */
return TCSERR(TSS_E_FAIL);
}
TSS_RESULT
psfile_get_key_by_pub(int fd, TCPA_STORE_PUBKEY *pub, UINT32 *size, BYTE **ret_key)
{
int rc;
UINT32 file_offset = 0;
struct key_disk_cache *tmp;
BYTE tmp_buffer[4096];
MUTEX_LOCK(disk_cache_lock);
tmp = key_disk_cache_head;
while (tmp) {
/* if the key is of the wrong size or is invalid, try the next one */
if (pub->keyLength != tmp->pub_data_size || !(tmp->flags & CACHE_FLAG_VALID)) {
tmp = tmp->next;
continue;
}
/* we have a valid key with the same key size as the one we're looking for.
* grab the pub key data off disk and compare it. */
/* jump to the location of the public key */
file_offset = TSSPS_PUB_DATA_OFFSET(tmp);
rc = lseek(fd, file_offset, SEEK_SET);
if (rc == ((off_t) - 1)) {
LogError("lseek: %s", strerror(errno));
MUTEX_UNLOCK(disk_cache_lock);
return TCSERR(TSS_E_INTERNAL_ERROR);
}
DBG_ASSERT(tmp->pub_data_size < 2048);
if (tmp->pub_data_size > sizeof(tmp_buffer)) {
LogError("Source buffer size too big! Size: %d",
tmp->pub_data_size);
MUTEX_UNLOCK(disk_cache_lock);
return TCSERR(TSS_E_INTERNAL_ERROR);
}
/* read in the key */
if ((rc = read_data(fd, tmp_buffer, tmp->pub_data_size))) {
LogError("%s", __FUNCTION__);
MUTEX_UNLOCK(disk_cache_lock);
return rc;
}
/* do the compare */
if (memcmp(tmp_buffer, pub->key, tmp->pub_data_size)) {
tmp = tmp->next;
continue;
}
/* jump to the location of the key blob */
file_offset = TSSPS_BLOB_DATA_OFFSET(tmp);
rc = lseek(fd, file_offset, SEEK_SET);
if (rc == ((off_t) - 1)) {
LogError("lseek: %s", strerror(errno));
MUTEX_UNLOCK(disk_cache_lock);
return TCSERR(TSS_E_INTERNAL_ERROR);
}
DBG_ASSERT(tmp->blob_size < 4096);
if (tmp->blob_size > sizeof(tmp_buffer)) {
LogError("Blob size greater than 4096! Size: %d",
tmp->blob_size);
MUTEX_UNLOCK(disk_cache_lock);
return TCSERR(TSS_E_INTERNAL_ERROR);
}
/* read in the key blob */
if ((rc = read_data(fd, tmp_buffer, tmp->blob_size))) {
LogError("%s", __FUNCTION__);
MUTEX_UNLOCK(disk_cache_lock);
return rc;
}
*ret_key = malloc(tmp->blob_size);
if (*ret_key == NULL) {
LogError("malloc of %d bytes failed.", tmp->blob_size);
MUTEX_UNLOCK(disk_cache_lock);
return TCSERR(TSS_E_OUTOFMEMORY);
}
memcpy(*ret_key, tmp_buffer, tmp->blob_size);
*size = tmp->blob_size;
MUTEX_UNLOCK(disk_cache_lock);
return rc;
}
MUTEX_UNLOCK(disk_cache_lock);
/* key not found */
return -2;
}
