| /* Software-based Trusted Platform Module (TPM) Emulator |
| * Copyright (C) 2004-2010 Mario Strasser <mast@gmx.net> |
| * |
| * This module is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published |
| * by the Free Software Foundation; either version 2 of the License, |
| * or (at your option) any later version. |
| * |
| * This module is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * $Id: tpm_delegation.c 367 2010-02-13 15:52:18Z mast $ |
| */ |
| |
| #include "tpm_emulator.h" |
| #include "tpm_commands.h" |
| #include "tpm_marshalling.h" |
| #include "tpm_data.h" |
| #include "tpm_handles.h" |
| #include "crypto/hmac.h" |
| #include "crypto/rc4.h" |
| |
| /* |
| * Delegation Commands ([TPM_Part3], Section 19) |
| */ |
| |
| TPM_FAMILY_TABLE_ENTRY *tpm_get_family_row(TPM_FAMILY_ID id) |
| { |
| UINT32 i; |
| for (i = 0; i < TPM_NUM_FAMILY_TABLE_ENTRY; i++) { |
| if (tpmData.permanent.data.familyTable.famRow[i].valid |
| && tpmData.permanent.data.familyTable.famRow[i].familyID == id) |
| return &tpmData.permanent.data.familyTable.famRow[i]; |
| } |
| return NULL; |
| } |
| |
| TPM_DELEGATE_TABLE_ROW *tpm_get_delegate_row(UINT32 row) |
| { |
| if (row < TPM_NUM_DELEGATE_TABLE_ENTRY |
| && tpmData.permanent.data.delegateTable.delRow[row].valid) |
| return &tpmData.permanent.data.delegateTable.delRow[row]; |
| return NULL; |
| } |
| |
| void tpm_compute_owner_blob_digest(TPM_DELEGATE_OWNER_BLOB *blob, |
| TPM_DIGEST *digest) |
| { |
| tpm_hmac_ctx_t ctx; |
| BYTE buf[sizeof_TPM_DELEGATE_OWNER_BLOB((*blob))]; |
| BYTE *ptr = buf; |
| UINT32 length = sizeof(buf); |
| tpm_marshal_TPM_DELEGATE_OWNER_BLOB(&ptr, &length, blob); |
| memset(&buf[2 + sizeof_TPM_DELEGATE_PUBLIC(blob->pub)], 0, 20); |
| tpm_hmac_init(&ctx, tpmData.permanent.data.tpmProof.nonce, |
| sizeof(tpmData.permanent.data.tpmProof.nonce)); |
| tpm_hmac_update(&ctx, buf, sizeof(buf) - length); |
| tpm_hmac_final(&ctx, digest->digest); |
| } |
| |
| void tpm_compute_key_blob_digest(TPM_DELEGATE_KEY_BLOB *blob, |
| TPM_DIGEST *digest) |
| { |
| tpm_hmac_ctx_t ctx; |
| BYTE buf[sizeof_TPM_DELEGATE_KEY_BLOB((*blob))]; |
| BYTE *ptr = buf; |
| UINT32 length = sizeof(buf); |
| tpm_marshal_TPM_DELEGATE_KEY_BLOB(&ptr, &length, blob); |
| memset(&buf[2 + sizeof_TPM_DELEGATE_PUBLIC(blob->pub)], 0, 20); |
| tpm_hmac_init(&ctx, tpmData.permanent.data.tpmProof.nonce, |
| sizeof(tpmData.permanent.data.tpmProof.nonce)); |
| tpm_hmac_update(&ctx, buf, sizeof(buf) - length); |
| tpm_hmac_final(&ctx, digest->digest); |
| } |
| |
| int tpm_encrypt_sensitive(BYTE *iv, UINT32 iv_size, |
| TPM_DELEGATE_SENSITIVE *sensitive, |
| BYTE **enc, UINT32 *enc_size) |
| { |
| UINT32 len; |
| BYTE *ptr; |
| tpm_rc4_ctx_t rc4_ctx; |
| BYTE key[TPM_SYM_KEY_SIZE + iv_size]; |
| /* marshal context */ |
| *enc_size = len = sizeof_TPM_DELEGATE_SENSITIVE((*sensitive)); |
| *enc = ptr = tpm_malloc(len); |
| if (*enc == NULL) return -1; |
| if (tpm_marshal_TPM_DELEGATE_SENSITIVE(&ptr, &len, sensitive)) { |
| tpm_free(*enc); |
| return -1; |
| } |
| /* encrypt context */ |
| memcpy(key, tpmData.permanent.data.delegateKey, TPM_SYM_KEY_SIZE); |
| memcpy(&key[TPM_SYM_KEY_SIZE], iv, iv_size); |
| tpm_rc4_init(&rc4_ctx, key, sizeof(key)); |
| tpm_rc4_crypt(&rc4_ctx, *enc, *enc, *enc_size); |
| return 0; |
| } |
| |
| int tpm_decrypt_sensitive(BYTE *iv, UINT32 iv_size, BYTE *enc, UINT32 enc_size, |
| TPM_DELEGATE_SENSITIVE *sensitive, BYTE **buf) |
| { |
| UINT32 len; |
| BYTE *ptr; |
| tpm_rc4_ctx_t rc4_ctx; |
| BYTE key[TPM_SYM_KEY_SIZE + iv_size]; |
| len = enc_size; |
| *buf = ptr = tpm_malloc(len); |
| if (*buf == NULL) return -1; |
| /* decrypt context */ |
| memcpy(key, tpmData.permanent.data.delegateKey, TPM_SYM_KEY_SIZE); |
| memcpy(&key[TPM_SYM_KEY_SIZE], iv, iv_size); |
| tpm_rc4_init(&rc4_ctx, key, sizeof(key)); |
| tpm_rc4_crypt(&rc4_ctx, enc, *buf, enc_size); |
| /* unmarshal context */ |
| if (tpm_unmarshal_TPM_DELEGATE_SENSITIVE(&ptr, &len, sensitive)) { |
| tpm_free(*buf); |
| return -1; |
| } |
| return 0; |
| } |
| |
| static TPM_FAMILY_TABLE_ENTRY *tpm_get_free_family_row(void) { |
| UINT32 i; |
| for(i = 0; i < TPM_NUM_FAMILY_TABLE_ENTRY; i++) { |
| if(!tpmData.permanent.data.familyTable.famRow[i].valid) { |
| tpmData.permanent.data.familyTable.famRow[i].valid = TRUE; |
| return &tpmData.permanent.data.familyTable.famRow[i]; |
| } |
| } |
| return NULL; |
| } |
| |
| TPM_RESULT TPM_Delegate_Manage(TPM_FAMILY_ID familyID, |
| TPM_FAMILY_OPERATION opFlag, |
| UINT32 opDataSize, BYTE *opData, |
| TPM_AUTH *auth1, |
| UINT32 *retDataSize, BYTE **retData) |
| { |
| TPM_RESULT res; |
| TPM_SESSION_DATA *session; |
| TPM_FAMILY_TABLE_ENTRY *fr; |
| UINT32 i; |
| |
| info("[TPM_Delegate_Manage]"); |
| /* if no new family row is to be created, get the existing one */ |
| if (opFlag != TPM_FAMILY_CREATE) { |
| fr = tpm_get_family_row(familyID); |
| if (fr == NULL) return TPM_BADINDEX; |
| } else { |
| fr = NULL; |
| } |
| /* verify authorization */ |
| session = tpm_get_auth(auth1->authHandle); |
| if (session == NULL) return TPM_AUTHFAIL; |
| if (auth1->authHandle != TPM_INVALID_AUTHHANDLE) { |
| res = tpm_verify_auth(auth1, tpmData.permanent.data.ownerAuth, TPM_KH_OWNER); |
| if (res != TPM_SUCCESS) return res; |
| if (session->type == TPM_ST_DSAP) { |
| if (session->familyID != familyID) return TPM_DELEGATE_FAMILY; |
| auth1->continueAuthSession = FALSE; |
| } |
| } else { |
| if (tpmData.permanent.flags.owned) return TPM_AUTHFAIL; |
| /* check delegate admin lock */ |
| if (fr != NULL && (fr->flags & TPM_DELEGATE_ADMIN_LOCK)) { |
| debug("delegate admin lock is set"); |
| return TPM_DELEGATE_LOCK; |
| } |
| /* verify maximal number of writes without an owner */ |
| if (tpmData.permanent.data.noOwnerNVWrite >= TPM_MAX_NV_WRITE_NOOWNER) |
| return TPM_MAXNVWRITES; |
| tpmData.permanent.data.noOwnerNVWrite++; |
| } |
| /* invalidate all but this auth session */ |
| for (i = 0; i < TPM_MAX_SESSIONS; i++) { |
| TPM_SESSION_DATA *s = &tpmData.stany.data.sessions[i]; |
| if (s->type != TPM_ST_TRANSPORT && s != session) memset(s, 0, sizeof(*s)); |
| } |
| tpmData.stclear.data.ownerReference = TPM_KH_OWNER; |
| /* perform requested operation */ |
| if (opFlag == TPM_FAMILY_CREATE) { |
| BYTE *ptr; |
| UINT32 length; |
| debug("ofFlag = TPM_FAMILY_CREATE"); |
| if (opDataSize != 1) return TPM_BAD_PARAM_SIZE; |
| /* get a free family row */ |
| fr = tpm_get_free_family_row(); |
| if (fr == NULL) return TPM_NOSPACE; |
| /* initialize the new row */ |
| fr->tag = TPM_TAG_FAMILY_TABLE_ENTRY; |
| fr->familyLabel.label = *opData; |
| tpmData.permanent.data.lastFamilyID++; |
| fr->familyID = tpmData.permanent.data.lastFamilyID; |
| fr->verificationCount = 1; |
| fr->flags = 0; |
| /* return the familyID */ |
| length = *retDataSize = 4; |
| ptr = *retData = tpm_malloc(*retDataSize); |
| if (*retData == NULL) { |
| debug("tpm_malloc() failed."); |
| fr->valid = FALSE; |
| return TPM_FAIL; |
| } |
| if (tpm_marshal_UINT32(&ptr, &length, fr->familyID) != 0) { |
| debug("tpm_marshal_UINT32() failed."); |
| tpm_free(*retData); |
| fr->valid = FALSE; |
| return TPM_FAIL; |
| } |
| } else if (opFlag == TPM_FAMILY_ADMIN) { |
| debug("opFlag = TPM_FAMILY_ADMIN"); |
| if (opDataSize != 1) return TPM_BAD_PARAM_SIZE; |
| if (*opData)fr->flags |= TPM_DELEGATE_ADMIN_LOCK; |
| else fr->flags &= ~TPM_DELEGATE_ADMIN_LOCK; |
| *retDataSize = 0; |
| } else if (opFlag == TPM_FAMILY_ENABLE) { |
| debug("opFlag = TPM_FAMFLAG_ENABLED"); |
| if (opDataSize != 1) return TPM_BAD_PARAM_SIZE; |
| if (*opData)fr->flags |= TPM_FAMFLAG_ENABLED; |
| else fr->flags &= ~TPM_FAMFLAG_ENABLED; |
| *retDataSize = 0; |
| return TPM_SUCCESS; |
| } else if (opFlag == TPM_FAMILY_INVALIDATE) { |
| debug("opFlag = TPM_FAMILY_INVALIDATE"); |
| /* invalidate all family data */ |
| memset(fr, 0, sizeof(*fr)); |
| fr->valid = FALSE; |
| *retDataSize = 0; |
| } else { |
| debug("unknown opFlag value: %d", opFlag); |
| return TPM_BAD_PARAMETER; |
| } |
| return TPM_SUCCESS; |
| } |
| |
| TPM_RESULT TPM_Delegate_CreateKeyDelegation(TPM_KEY_HANDLE keyHandle, |
| TPM_DELEGATE_PUBLIC *publicInfo, |
| TPM_ENCAUTH *delAuth, |
| TPM_AUTH *auth1, |
| TPM_DELEGATE_KEY_BLOB *blob) |
| { |
| TPM_RESULT res; |
| TPM_SESSION_DATA *session; |
| TPM_FAMILY_TABLE_ENTRY *fr; |
| TPM_SECRET secret; |
| TPM_KEY_DATA *key; |
| TPM_PUBKEY pubKey; |
| TPM_DELEGATE_SENSITIVE sensitive; |
| info("TPM_Delegate_CreateKeyDelegation()"); |
| /* get key */ |
| key = tpm_get_key(keyHandle); |
| if (key == NULL) return TPM_INVALID_KEYHANDLE; |
| /* verify authorization */ |
| session = tpm_get_auth(auth1->authHandle); |
| if (session == NULL) return TPM_FAIL; |
| if (session->type != TPM_ST_OSAP && session->type != TPM_ST_DSAP) { |
| debug("session is neither of type OSAP nor DSAP"); |
| return TPM_INVALID_AUTHHANDLE; |
| } |
| res = tpm_verify_auth(auth1, key->usageAuth, keyHandle); |
| if (res != TPM_SUCCESS) return res; |
| auth1->continueAuthSession = FALSE; |
| /* get specified family entry */ |
| fr = tpm_get_family_row(publicInfo->familyID); |
| if (fr == NULL) return TPM_BADINDEX; |
| /* check delegation type */ |
| if (publicInfo->permissions.delegateType != TPM_DEL_KEY_BITS) { |
| debug("invalid delegation type: %d", publicInfo->permissions.delegateType); |
| return TPM_BAD_PARAMETER; |
| } |
| blob->tag = TPM_TAG_DELEGATE_KEY_BLOB; |
| /* verify permissions if the access was delegated */ |
| if (session->type == TPM_ST_DSAP) { |
| if (!(fr->flags & TPM_FAMFLAG_ENABLED)) return TPM_DISABLED_CMD; |
| if (session->familyID != publicInfo->familyID) return TPM_DELEGATE_FAMILY; |
| if (((session->permissions.per1 | publicInfo->permissions.per1) |
| != session->permissions.per1) |
| || ((session->permissions.per2 | publicInfo->permissions.per2) |
| != session->permissions.per2)) return TPM_AUTHFAIL; |
| } |
| /* decrypt delegation secret */ |
| tpm_decrypt_auth_secret(*delAuth, session->sharedSecret, |
| &session->lastNonceEven, secret); |
| /* compute key digest */ |
| if (tpm_extract_pubkey(key, &pubKey)) { |
| debug("tpm_extraxt_pubkey() failed."); |
| return TPM_FAIL; |
| } |
| if (tpm_compute_pubkey_digest(&pubKey, &blob->pubKeyDigest)) { |
| debug("tpm_compute_pubkey_digest() failed"); |
| free_TPM_PUBKEY(pubKey); |
| return TPM_FAIL; |
| } |
| free_TPM_PUBKEY(pubKey); |
| /* create a delegate sensitive structure */ |
| sensitive.tag = TPM_TAG_DELEGATE_SENSITIVE; |
| memcpy(&sensitive.authValue, &secret, sizeof(TPM_SECRET)); |
| /* generate IV and encrypt sensitive area */ |
| blob->additionalSize = TPM_SYM_KEY_SIZE; |
| blob->additionalArea = tpm_malloc(blob->additionalSize); |
| if (blob->additionalArea == NULL) { |
| debug("tpm_malloc() failed."); |
| return TPM_NOSPACE; |
| } |
| tpm_get_random_bytes(blob->additionalArea, blob->additionalSize); |
| if (tpm_encrypt_sensitive(blob->additionalArea, blob->additionalSize, |
| &sensitive, &blob->sensitiveArea, &blob->sensitiveSize)) { |
| debug("tpm_encrypt_sensitive() failed."); |
| tpm_free(blob->additionalArea); |
| return TPM_ENCRYPT_ERROR; |
| } |
| /* copy public delegation information */ |
| memcpy(&blob->pub, publicInfo, sizeof(TPM_DELEGATE_PUBLIC)); |
| blob->pub.verificationCount = fr->verificationCount; |
| /* compute integrity digest */ |
| tpm_compute_key_blob_digest(blob, &blob->integrityDigest); |
| return TPM_SUCCESS; |
| } |
| |
| TPM_RESULT TPM_Delegate_CreateOwnerDelegation(BOOL increment, |
| TPM_DELEGATE_PUBLIC *publicInfo, |
| TPM_ENCAUTH *delAuth, |
| TPM_AUTH *auth1, |
| TPM_DELEGATE_OWNER_BLOB *blob) |
| { |
| TPM_RESULT res; |
| TPM_SESSION_DATA *session; |
| TPM_FAMILY_TABLE_ENTRY *fr; |
| TPM_SECRET secret; |
| TPM_DELEGATE_SENSITIVE sensitive; |
| info("[TPM_Delegate_CreateOwnerDelegation]"); |
| /* verify authorization */ |
| session = tpm_get_auth(auth1->authHandle); |
| if (session == NULL) return TPM_FAIL; |
| if (session->type != TPM_ST_OSAP && session->type != TPM_ST_DSAP) { |
| debug("session is neither of type OSAP nor DSAP"); |
| return TPM_INVALID_AUTHHANDLE; |
| } |
| res = tpm_verify_auth(auth1, tpmData.permanent.data.ownerAuth, TPM_KH_OWNER); |
| if (res != TPM_SUCCESS) return res; |
| auth1->continueAuthSession = FALSE; |
| /* get specified family entry */ |
| fr = tpm_get_family_row(publicInfo->familyID); |
| if (fr == NULL) return TPM_BADINDEX; |
| /* check delegation type */ |
| if (publicInfo->permissions.delegateType != TPM_DEL_OWNER_BITS) { |
| debug("invalid delegation type: %d", publicInfo->permissions.delegateType); |
| return TPM_BAD_PARAMETER; |
| } |
| blob->tag = TPM_TAG_DELEGATE_OWNER_BLOB; |
| /* verify permissions if the access was delegated */ |
| if (session->type == TPM_ST_DSAP) { |
| if (!(fr->flags & TPM_FAMFLAG_ENABLED)) return TPM_DISABLED_CMD; |
| if (session->familyID != publicInfo->familyID) return TPM_DELEGATE_FAMILY; |
| if (((session->permissions.per1 | publicInfo->permissions.per1) |
| != session->permissions.per1) |
| || ((session->permissions.per2 | publicInfo->permissions.per2) |
| != session->permissions.per2)) return TPM_AUTHFAIL; |
| } |
| /* increment verification count if required */ |
| if (increment) { |
| UINT32 i; |
| fr->verificationCount++; |
| debug("incrementing verificationCount to %d", fr->verificationCount); |
| tpmData.stclear.data.ownerReference = TPM_KH_OWNER; |
| /* invalidate all but this session */ |
| for (i = 0; i < TPM_MAX_SESSIONS; i++) { |
| TPM_SESSION_DATA *s = &tpmData.stany.data.sessions[i]; |
| if (s->type != TPM_ST_TRANSPORT && s != session) memset(s, 0, sizeof(*s)); |
| } |
| } |
| /* decrypt delegation secret */ |
| tpm_decrypt_auth_secret(*delAuth, session->sharedSecret, |
| &session->lastNonceEven, secret); |
| /* create a delegate sensitive structure */ |
| sensitive.tag = TPM_TAG_DELEGATE_SENSITIVE; |
| memcpy(&sensitive.authValue, &secret, sizeof(TPM_SECRET)); |
| /* generate IV and encrypt sensitive area */ |
| blob->additionalSize = TPM_SYM_KEY_SIZE; |
| blob->additionalArea = tpm_malloc(blob->additionalSize); |
| if (blob->additionalArea == NULL) { |
| debug("tpm_malloc() failed."); |
| return TPM_NOSPACE; |
| } |
| tpm_get_random_bytes(blob->additionalArea, blob->additionalSize); |
| if (tpm_encrypt_sensitive(blob->additionalArea, blob->additionalSize, |
| &sensitive, &blob->sensitiveArea, &blob->sensitiveSize)) { |
| debug("tpm_encrypt_sensitive() failed."); |
| tpm_free(blob->additionalArea); |
| return TPM_ENCRYPT_ERROR; |
| } |
| /* copy public delegation information */ |
| memcpy(&blob->pub, publicInfo, sizeof(TPM_DELEGATE_PUBLIC)); |
| blob->pub.verificationCount = fr->verificationCount; |
| /* compute integrity digest */ |
| tpm_compute_owner_blob_digest(blob, &blob->integrityDigest); |
| return TPM_SUCCESS; |
| } |
| |
| TPM_RESULT TPM_Delegate_LoadOwnerDelegation(TPM_DELEGATE_INDEX index, |
| TPM_DELEGATE_OWNER_BLOB *blob, |
| TPM_AUTH *auth1) |
| { |
| TPM_RESULT res; |
| TPM_SESSION_DATA *session; |
| TPM_FAMILY_TABLE_ENTRY *fr; |
| TPM_DIGEST blobDigest; |
| TPM_DELEGATE_SENSITIVE sensitive; |
| TPM_DELEGATE_TABLE_ROW *dr; |
| BYTE *sens_buf; |
| UINT32 i; |
| info("TPM_Delegate_LoadOwnerDelegation()"); |
| /* get specified family entry */ |
| fr = tpm_get_family_row(blob->pub.familyID); |
| if (fr == NULL) return TPM_BADINDEX; |
| /* verify authorization */ |
| session = tpm_get_auth(auth1->authHandle); |
| if (session == NULL) return TPM_AUTHFAIL; |
| if (auth1->authHandle != TPM_INVALID_AUTHHANDLE) { |
| res = tpm_verify_auth(auth1, tpmData.permanent.data.ownerAuth, TPM_KH_OWNER); |
| if (res != TPM_SUCCESS) return res; |
| if (session->type == TPM_ST_DSAP) { |
| if (session->familyID != blob->pub.familyID) return TPM_DELEGATE_FAMILY; |
| auth1->continueAuthSession = FALSE; |
| } |
| } else { |
| if (tpmData.permanent.flags.owned) return TPM_AUTHFAIL; |
| /* check delegate admin lock */ |
| if (fr != NULL && (fr->flags & TPM_DELEGATE_ADMIN_LOCK)) { |
| debug("delegate admin lock is set"); |
| return TPM_DELEGATE_LOCK; |
| } |
| /* verify maximal number of writes without an owner */ |
| if (tpmData.permanent.data.noOwnerNVWrite >= TPM_MAX_NV_WRITE_NOOWNER) |
| return TPM_MAXNVWRITES; |
| tpmData.permanent.data.noOwnerNVWrite++; |
| } |
| /* verify the integrity of the blob and decode/decrypt the sensitive data */ |
| if (!(fr->flags & TPM_FAMFLAG_ENABLED)) return TPM_DISABLED_CMD; |
| if (tpmData.permanent.flags.owned) { |
| tpm_compute_owner_blob_digest(blob, &blobDigest); |
| if (memcmp(&blob->integrityDigest, &blobDigest, sizeof(TPM_DIGEST)) != 0) |
| return TPM_AUTHFAIL; |
| /* decrypt sensitive data */ |
| if (tpm_decrypt_sensitive(blob->additionalArea, blob->additionalSize, |
| blob->sensitiveArea, blob->sensitiveSize, &sensitive, &sens_buf)) { |
| debug("tpm_decrypt_sensitive() failed"); |
| return TPM_DECRYPT_ERROR; |
| } |
| } else { |
| BYTE *ptr = blob->sensitiveArea; |
| UINT32 length = blob->sensitiveSize; |
| if (tpm_unmarshal_TPM_DELEGATE_SENSITIVE(&ptr, &length, &sensitive) != 0) { |
| debug("tpm_unmarshal_TPM_DELEGATE_SENSITIVE()"); |
| return TPM_FAIL; |
| } |
| sens_buf = NULL; |
| } |
| if (sensitive.tag != TPM_TAG_DELEGATE_SENSITIVE) { |
| tpm_free(sens_buf); |
| return TPM_INVALID_STRUCTURE; |
| } |
| /* check that index is valid and copy data */ |
| debug("index = %d", index); |
| if (index >= TPM_NUM_DELEGATE_TABLE_ENTRY) { |
| tpm_free(sens_buf); |
| return TPM_BADINDEX; |
| } |
| dr = &tpmData.permanent.data.delegateTable.delRow[index]; |
| dr->valid = TRUE; |
| dr->tag = TPM_TAG_DELEGATE_TABLE_ROW; |
| memcpy(&dr->authValue, &sensitive.authValue, sizeof(TPM_SECRET)); |
| memcpy(&dr->pub, &blob->pub, sizeof(TPM_DELEGATE_PUBLIC)); |
| tpm_free(sens_buf); |
| /* invalidate all but this session */ |
| for (i = 0; i < TPM_MAX_SESSIONS; i++) { |
| TPM_SESSION_DATA *s = &tpmData.stany.data.sessions[i]; |
| if (s->type != TPM_ST_TRANSPORT && s != session) memset(s, 0, sizeof(*s)); |
| } |
| tpmData.stclear.data.ownerReference = TPM_KH_OWNER; |
| return TPM_SUCCESS; |
| } |
| |
| TPM_RESULT TPM_Delegate_ReadTable(UINT32 *familyTableSize, BYTE **familyTable, |
| UINT32 *delegateTableSize, |
| BYTE **delegateTable) |
| { |
| UINT32 i, length; |
| BYTE *ptr; |
| info("TPM_Delegate_ReadTable"); |
| /* compute the size of the family table */ |
| *familyTableSize = 0; |
| *familyTable = NULL; |
| for (i = 0; i < TPM_NUM_FAMILY_TABLE_ENTRY; i++) { |
| if (tpmData.permanent.data.familyTable.famRow[i].valid) { |
| *familyTableSize += sizeof_TPM_FAMILY_TABLE_ENTRY( |
| tpmData.permanent.data.familyTable.famRow[i]); |
| } |
| } |
| debug("family table size: %d", *familyTableSize); |
| /* allocate the table buffer and copy the family table */ |
| if (*familyTableSize > 0) { |
| length = *familyTableSize; |
| ptr = *familyTable = tpm_malloc(*familyTableSize); |
| if (*familyTable == NULL) return TPM_RESOURCES; |
| for (i = 0; i < TPM_NUM_FAMILY_TABLE_ENTRY; i++) { |
| if (tpmData.permanent.data.familyTable.famRow[i].valid) { |
| debug("writing table row %d", i); |
| if (tpm_marshal_TPM_FAMILY_TABLE_ENTRY(&ptr, &length, |
| &tpmData.permanent.data.familyTable.famRow[i])) { |
| debug("tpm_marshal_TPM_FAMILY_TABLE_ENTRY() failed."); |
| tpm_free(*familyTable); |
| return TPM_FAIL; |
| } |
| } |
| } |
| } |
| /* computing the size of the delegation table */ |
| *delegateTableSize = 0; |
| *delegateTable = NULL; |
| for (i = 0; i < TPM_NUM_DELEGATE_TABLE_ENTRY; i++) { |
| if (tpmData.permanent.data.delegateTable.delRow[i].valid) { |
| *delegateTableSize += sizeof_TPM_DELEGATE_PUBLIC( |
| tpmData.permanent.data.delegateTable.delRow[i].pub) + 4; |
| } |
| } |
| debug("delegation table size: %d", *delegateTableSize); |
| /* allocate the table buffer and copy the delegation table */ |
| if (*delegateTableSize > 0) { |
| length = *delegateTableSize; |
| ptr = *delegateTable = tpm_malloc(*delegateTableSize); |
| if (*delegateTable == NULL) { |
| tpm_free(*familyTable); |
| return TPM_RESOURCES; |
| } |
| for (i = 0; i < TPM_NUM_DELEGATE_TABLE_ENTRY; i++) { |
| if (tpmData.permanent.data.delegateTable.delRow[i].valid) { |
| debug("writing delegate row %d", i); |
| if (tpm_marshal_TPM_DELEGATE_INDEX(&ptr, &length, i) |
| || tpm_marshal_TPM_DELEGATE_PUBLIC(&ptr, &length, |
| &tpmData.permanent.data.delegateTable.delRow[i].pub)) { |
| debug("tpm_marshal_UINT32 or -TPM_DELEGATE_PUBLIC failed."); |
| tpm_free(*familyTable); |
| tpm_free(*delegateTable); |
| return TPM_FAIL; |
| } |
| } |
| } |
| } |
| return TPM_SUCCESS; |
| } |
| |
| TPM_RESULT TPM_Delegate_UpdateVerification(UINT32 inputSize, BYTE *inputData, |
| TPM_AUTH *auth1, UINT32 *outputSize, |
| BYTE **outputData) |
| { |
| TPM_RESULT res; |
| TPM_SESSION_DATA *session; |
| info("TPM_Delegate_UpdateVerification()"); |
| /* verify authorization */ |
| session = tpm_get_auth(auth1->authHandle); |
| if (session == NULL) return TPM_AUTHFAIL; |
| res = tpm_verify_auth(auth1, tpmData.permanent.data.ownerAuth, TPM_KH_OWNER); |
| if (res != TPM_SUCCESS) return res; |
| /* determine the type of the input data */ |
| if (inputSize == 4) { |
| TPM_DELEGATE_INDEX index; |
| TPM_DELEGATE_TABLE_ROW *dr; |
| TPM_FAMILY_TABLE_ENTRY *fr; |
| debug("TPM_DELEGATE_TABLE_ROW"); |
| /* unmarshal delegate index */ |
| if (tpm_unmarshal_TPM_DELEGATE_INDEX(&inputData, &inputSize, &index)) { |
| debug("tpm_unmarshal_TPM_DELEGATE_INDEX() failed."); |
| return TPM_FAIL; |
| } |
| /* get delegate and family row */ |
| dr = tpm_get_delegate_row(index); |
| if (dr == NULL) return TPM_BADINDEX; |
| fr = tpm_get_family_row(dr->pub.familyID); |
| if (fr == NULL) return TPM_BADINDEX; |
| /* verify permissions if the access was delegated */ |
| if (session->type == TPM_ST_DSAP) { |
| if (!(fr->flags & TPM_FAMFLAG_ENABLED)) return TPM_DISABLED_CMD; |
| if (session->familyID != fr->familyID) return TPM_DELEGATE_FAMILY; |
| } |
| /* update verification count */ |
| dr->pub.verificationCount = fr->verificationCount; |
| *outputSize = 0; |
| *outputData = NULL; |
| } else if (inputData[0] == (TPM_TAG_DELEGATE_OWNER_BLOB >> 8) |
| && inputData[1] == (TPM_TAG_DELEGATE_OWNER_BLOB & 0xff)) { |
| TPM_DELEGATE_OWNER_BLOB blob; |
| TPM_DIGEST blobDigest; |
| TPM_FAMILY_TABLE_ENTRY *fr; |
| UINT32 length; |
| BYTE *ptr; |
| debug("TPM_DELEGATE_OWNER_BLOB"); |
| /* unmarshal the blob */ |
| if (tpm_unmarshal_TPM_DELEGATE_OWNER_BLOB(&inputData, &inputSize, &blob)) { |
| debug("tpm_unmarshal_TPM_DELEGATE_OWNER_BLOB() failed."); |
| return TPM_FAIL; |
| } |
| /* validate the integrity of the blob */ |
| tpm_compute_owner_blob_digest(&blob, &blobDigest); |
| if (memcmp(&blob.integrityDigest, &blobDigest, sizeof(TPM_DIGEST)) != 0) |
| return TPM_AUTHFAIL; |
| /* get family row */ |
| fr = tpm_get_family_row(blob.pub.familyID); |
| if (fr == NULL) return TPM_BADINDEX; |
| /* verify permissions if the access was delegated */ |
| if (session->type == TPM_ST_DSAP) { |
| if (!(fr->flags & TPM_FAMFLAG_ENABLED)) return TPM_DISABLED_CMD; |
| if (session->familyID != fr->familyID) return TPM_DELEGATE_FAMILY; |
| } |
| /* update verification count */ |
| blob.pub.verificationCount = fr->verificationCount; |
| /* update the blob digest */ |
| tpm_compute_owner_blob_digest(&blob, &blobDigest); |
| /* marshal the blob */ |
| length = *outputSize = sizeof_TPM_DELEGATE_OWNER_BLOB(blob); |
| ptr = *outputData = tpm_malloc(*outputSize); |
| if (ptr == NULL) { |
| debug("tpm_malloc() failed."); |
| return TPM_NOSPACE; |
| } |
| if (tpm_marshal_TPM_DELEGATE_OWNER_BLOB(&ptr, &length, &blob) != 0) { |
| debug("tpm_marshal_TPM_DELEGATE_OWNER_BLOB() failed."); |
| tpm_free(*outputData); |
| return TPM_FAIL; |
| } |
| } else if (inputData[0] == (TPM_TAG_DELEGATE_KEY_BLOB >> 8) |
| && inputData[1] == (TPM_TAG_DELEGATE_KEY_BLOB & 0xff)) { |
| TPM_DELEGATE_KEY_BLOB blob; |
| TPM_DIGEST blobDigest; |
| TPM_FAMILY_TABLE_ENTRY *fr; |
| UINT32 length; |
| BYTE *ptr; |
| debug("TPM_DELEGATE_KEY_BLOB"); |
| /* unmarshal the blob */ |
| if (tpm_unmarshal_TPM_DELEGATE_KEY_BLOB(&inputData, &inputSize, &blob)) { |
| debug("tpm_unmarshal_TPM_DELEGATE_KEY_BLOB() failed."); |
| return TPM_FAIL; |
| } |
| /* validate the integrity of the blob */ |
| tpm_compute_key_blob_digest(&blob, &blobDigest); |
| if (memcmp(&blob.integrityDigest, &blobDigest, sizeof(TPM_DIGEST)) != 0) |
| return TPM_AUTHFAIL; |
| /* get family row */ |
| fr = tpm_get_family_row(blob.pub.familyID); |
| if (fr == NULL) return TPM_BADINDEX; |
| /* verify permissions if the access was delegated */ |
| if (session->type == TPM_ST_DSAP) { |
| if (!(fr->flags & TPM_FAMFLAG_ENABLED)) return TPM_DISABLED_CMD; |
| if (session->familyID != fr->familyID) return TPM_DELEGATE_FAMILY; |
| } |
| /* update verification count */ |
| blob.pub.verificationCount = fr->verificationCount; |
| /* update the blob digest */ |
| tpm_compute_key_blob_digest(&blob, &blobDigest); |
| /* marshal the blob */ |
| length = *outputSize = sizeof_TPM_DELEGATE_KEY_BLOB(blob); |
| ptr = *outputData = tpm_malloc(*outputSize); |
| if (ptr == NULL) { |
| debug("tpm_malloc() failed."); |
| return TPM_NOSPACE; |
| } |
| if (tpm_marshal_TPM_DELEGATE_KEY_BLOB(&ptr, &length, &blob) != 0) { |
| debug("tpm_marshal_TPM_DELEGATE_KEY_BLOB() failed."); |
| tpm_free(*outputData); |
| return TPM_FAIL; |
| } |
| } else { |
| debug("unsupported input structure: %02x%02x", inputData[0], inputData[1]); |
| return TPM_BAD_PARAMETER; |
| } |
| return TPM_SUCCESS; |
| } |
| |
| TPM_RESULT TPM_Delegate_VerifyDelegation(UINT32 delegateSize, BYTE *delegation) |
| { |
| info("TPM_Delegate_VerifyDelegation()"); |
| if (delegation[0] == (TPM_TAG_DELEGATE_OWNER_BLOB >> 8) |
| && delegation[1] == (TPM_TAG_DELEGATE_OWNER_BLOB & 0xff)) { |
| TPM_DELEGATE_OWNER_BLOB blob; |
| TPM_DIGEST blobDigest; |
| TPM_FAMILY_TABLE_ENTRY *fr; |
| TPM_DELEGATE_SENSITIVE sensitive; |
| BYTE *sens_buf; |
| debug("TPM_DELEGATE_OWNER_BLOB"); |
| /* unmarshal the blob */ |
| if (tpm_unmarshal_TPM_DELEGATE_OWNER_BLOB(&delegation, &delegateSize, &blob)) { |
| debug("tpm_unmarshal_TPM_DELEGATE_OWNER_BLOB() failed."); |
| return TPM_FAIL; |
| } |
| /* validate the integrity of the blob */ |
| tpm_compute_owner_blob_digest(&blob, &blobDigest); |
| if (memcmp(&blob.integrityDigest, &blobDigest, sizeof(TPM_DIGEST)) != 0) |
| return TPM_AUTHFAIL; |
| /* get family row */ |
| fr = tpm_get_family_row(blob.pub.familyID); |
| if (fr == NULL) return TPM_BADINDEX; |
| if (!(fr->flags & TPM_FAMFLAG_ENABLED)) return TPM_DISABLED_CMD; |
| /* verify verification count */ |
| if (blob.pub.verificationCount != fr->verificationCount) |
| return TPM_FAMILYCOUNT; |
| /* decrypt and verify sensitive area */ |
| if (tpm_decrypt_sensitive(blob.additionalArea, blob.additionalSize, |
| blob.sensitiveArea, blob.sensitiveSize, &sensitive, &sens_buf)) { |
| debug("tpm_decrypt_sensitive() failed"); |
| return TPM_DECRYPT_ERROR; |
| } |
| tpm_free(sens_buf); |
| if (sensitive.tag != TPM_TAG_DELEGATE_SENSITIVE) return TPM_BAD_PARAMETER; |
| } else if (delegation[0] == (TPM_TAG_DELEGATE_KEY_BLOB >> 8) |
| && delegation[1] == (TPM_TAG_DELEGATE_KEY_BLOB & 0xff)) { |
| TPM_DELEGATE_KEY_BLOB blob; |
| TPM_DIGEST blobDigest; |
| TPM_FAMILY_TABLE_ENTRY *fr; |
| TPM_DELEGATE_SENSITIVE sensitive; |
| BYTE *sens_buf; |
| debug("TPM_DELEGATE_KEY_BLOB"); |
| /* unmarshal the blob */ |
| if (tpm_unmarshal_TPM_DELEGATE_KEY_BLOB(&delegation, &delegateSize, &blob)) { |
| debug("tpm_unmarshal_TPM_DELEGATE_OWNER_BLOB() failed."); |
| return TPM_FAIL; |
| } |
| /* validate the integrity of the blob */ |
| tpm_compute_key_blob_digest(&blob, &blobDigest); |
| if (memcmp(&blob.integrityDigest, &blobDigest, sizeof(TPM_DIGEST)) != 0) |
| return TPM_AUTHFAIL; |
| /* get family row */ |
| fr = tpm_get_family_row(blob.pub.familyID); |
| if (fr == NULL) return TPM_BADINDEX; |
| if (!(fr->flags & TPM_FAMFLAG_ENABLED)) return TPM_DISABLED_CMD; |
| /* verify verification count */ |
| if (blob.pub.verificationCount != fr->verificationCount) |
| return TPM_FAMILYCOUNT; |
| /* decrypt and verify sensitive area */ |
| if (tpm_decrypt_sensitive(blob.additionalArea, blob.additionalSize, |
| blob.sensitiveArea, blob.sensitiveSize, &sensitive, &sens_buf)) { |
| debug("tpm_decrypt_sensitive() failed"); |
| return TPM_DECRYPT_ERROR; |
| } |
| tpm_free(sens_buf); |
| if (sensitive.tag != TPM_TAG_DELEGATE_SENSITIVE) return TPM_BAD_PARAMETER; |
| } else { |
| debug("unsupported input structure: %02x%02x", delegation[0], delegation[1]); |
| return TPM_BAD_PARAMETER; |
| } |
| return TPM_SUCCESS; |
| } |
| |
