| /* Software-based Trusted Platform Module (TPM) Emulator |
| * Copyright (C) 2004-2010 Mario Strasser <mast@gmx.net> |
| * 2005-2008 Heiko Stamer <stamer@gaos.org> |
| * |
| * 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_marshalling.c 372 2010-02-15 12:52:00Z mast $ |
| */ |
| |
| #include "tpm_marshalling.h" |
| #include "tpm_handles.h" |
| #include "crypto/rsa.h" |
| |
| int tpm_marshal_UINT32_ARRAY(BYTE **ptr, UINT32 *length, |
| UINT32 *v, UINT32 n) |
| { |
| UINT32 i; |
| for (i = 0; i < n; i++) { |
| if (tpm_marshal_UINT32(ptr, length, v[i])) return -1; |
| } |
| return 0; |
| } |
| |
| int tpm_unmarshal_UINT32_ARRAY(BYTE **ptr, UINT32 *length, |
| UINT32 *v, UINT32 n) |
| { |
| UINT32 i; |
| for (i = 0; i < n; i++) { |
| if (tpm_unmarshal_UINT32(ptr, length, &v[i])) return -1; |
| } |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_STRUCT_VER(BYTE **ptr, UINT32 *length, TPM_STRUCT_VER *v) |
| { |
| if (tpm_marshal_BYTE(ptr, length, v->major) |
| || tpm_marshal_BYTE(ptr, length, v->minor) |
| || tpm_marshal_BYTE(ptr, length, v->revMajor) |
| || tpm_marshal_BYTE(ptr, length, v->revMinor)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_STRUCT_VER(BYTE **ptr, UINT32 *length, TPM_STRUCT_VER *v) |
| { |
| if (tpm_unmarshal_BYTE(ptr, length, &v->major) |
| || tpm_unmarshal_BYTE(ptr, length, &v->minor) |
| || tpm_unmarshal_BYTE(ptr, length, &v->revMajor) |
| || tpm_unmarshal_BYTE(ptr, length, &v->revMinor)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_VERSION(BYTE **ptr, UINT32 *length, TPM_VERSION *v) |
| { |
| if (tpm_marshal_BYTE(ptr, length, v->major) |
| || tpm_marshal_BYTE(ptr, length, v->minor) |
| || tpm_marshal_BYTE(ptr, length, v->revMajor) |
| || tpm_marshal_BYTE(ptr, length, v->revMinor)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_VERSION(BYTE **ptr, UINT32 *length, TPM_VERSION *v) |
| { |
| if (tpm_unmarshal_BYTE(ptr, length, &v->major) |
| || tpm_unmarshal_BYTE(ptr, length, &v->minor) |
| || tpm_unmarshal_BYTE(ptr, length, &v->revMajor) |
| || tpm_unmarshal_BYTE(ptr, length, &v->revMinor)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_DIGEST(BYTE **ptr, UINT32 *length, TPM_DIGEST *v) |
| { |
| if (tpm_marshal_BYTE_ARRAY(ptr, length, v->digest, sizeof(v->digest))) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_DIGEST(BYTE **ptr, UINT32 *length, TPM_DIGEST *v) |
| { |
| if (tpm_unmarshal_BYTE_ARRAY(ptr, length, v->digest, sizeof(v->digest))) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_PCRVALUE_ARRAY(BYTE **ptr, UINT32 *length, |
| TPM_PCRVALUE *v, UINT32 n) |
| { |
| UINT32 i; |
| for (i = 0; i < n; i++) { |
| if (tpm_marshal_TPM_PCRVALUE(ptr, length, &v[i])) return -1; |
| } |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_PCRVALUE_ARRAY(BYTE **ptr, UINT32 *length, |
| TPM_PCRVALUE *v, UINT32 n) |
| { |
| UINT32 i; |
| for (i = 0; i < n; i++) { |
| if (tpm_unmarshal_TPM_PCRVALUE(ptr, length, &v[i])) return -1; |
| } |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_NONCE(BYTE **ptr, UINT32 *length, TPM_NONCE *v) |
| { |
| if (tpm_marshal_BYTE_ARRAY(ptr, length, v->nonce, sizeof(v->nonce))) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_NONCE(BYTE **ptr, UINT32 *length, TPM_NONCE *v) |
| { |
| if (tpm_unmarshal_BYTE_ARRAY(ptr, length, v->nonce, sizeof(v->nonce))) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_AUTHDATA(BYTE **ptr, UINT32 *length, TPM_AUTHDATA *v) |
| { |
| if (*length < sizeof(TPM_AUTHDATA)) return -1; |
| memcpy(*ptr, v, sizeof(TPM_AUTHDATA)); |
| *ptr += sizeof(TPM_AUTHDATA); *length -= sizeof(TPM_AUTHDATA); |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_AUTHDATA(BYTE **ptr, UINT32 *length, TPM_AUTHDATA *v) |
| { |
| if (*length < sizeof(TPM_AUTHDATA)) return -1; |
| memcpy(v, *ptr, sizeof(TPM_AUTHDATA)); |
| *ptr += sizeof(TPM_AUTHDATA); *length -= sizeof(TPM_AUTHDATA); |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_AUTH(BYTE **ptr, UINT32 *length, TPM_AUTH *v) |
| { |
| if (tpm_marshal_TPM_NONCE(ptr, length, &v->nonceEven) |
| || tpm_marshal_BOOL(ptr, length, v->continueAuthSession) |
| || tpm_marshal_TPM_AUTHDATA(ptr, length, &v->auth)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_AUTH(BYTE **ptr, UINT32 *length, TPM_AUTH *v) |
| { |
| if (tpm_unmarshal_TPM_AUTHHANDLE(ptr, length, &v->authHandle) |
| || tpm_unmarshal_TPM_NONCE(ptr, length, &v->nonceOdd) |
| || tpm_unmarshal_BOOL(ptr, length, &v->continueAuthSession) |
| || tpm_unmarshal_TPM_AUTHDATA(ptr, length, &v->auth)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_KEY_HANDLE_LIST(BYTE **ptr, UINT32 *length, TPM_KEY_HANDLE_LIST *v) |
| { |
| if (tpm_marshal_UINT16(ptr, length, v->loaded) |
| || tpm_marshal_UINT32_ARRAY(ptr, length, v->handle, v->loaded)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_CHANGEAUTH_VALIDATE(BYTE **ptr, UINT32 *length, TPM_CHANGEAUTH_VALIDATE *v) |
| { |
| if (tpm_marshal_TPM_SECRET(ptr, length, &v->newAuthSecret) |
| || tpm_marshal_TPM_NONCE(ptr, length, &v->n1)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_CHANGEAUTH_VALIDATE(BYTE **ptr, UINT32 *length, TPM_CHANGEAUTH_VALIDATE *v) |
| { |
| if (tpm_unmarshal_TPM_SECRET(ptr, length, &v->newAuthSecret) |
| || tpm_unmarshal_TPM_NONCE(ptr, length, &v->n1)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_COUNTER_VALUE(BYTE **ptr, UINT32 *length, TPM_COUNTER_VALUE *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_BYTE_ARRAY(ptr, length, v->label, sizeof(v->label)) |
| || tpm_marshal_TPM_ACTUAL_COUNT(ptr, length, v->counter)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_COUNTER_VALUE(BYTE **ptr, UINT32 *length, TPM_COUNTER_VALUE *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->label, sizeof(v->label)) |
| || tpm_unmarshal_TPM_ACTUAL_COUNT(ptr, length, &v->counter)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_PCR_SELECTION(BYTE **ptr, UINT32 *length, TPM_PCR_SELECTION *v) |
| { |
| if (tpm_marshal_UINT16(ptr, length, v->sizeOfSelect) |
| || v->sizeOfSelect > sizeof(v->pcrSelect) |
| || tpm_marshal_BYTE_ARRAY(ptr, length, v->pcrSelect, v->sizeOfSelect)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_PCR_SELECTION(BYTE **ptr, UINT32 *length, TPM_PCR_SELECTION *v) |
| { |
| if (tpm_unmarshal_UINT16(ptr, length, &v->sizeOfSelect) |
| || v->sizeOfSelect > sizeof(v->pcrSelect) |
| || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->pcrSelect, v->sizeOfSelect)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_PCR_COMPOSITE(BYTE **ptr, UINT32 *length, TPM_PCR_COMPOSITE *v) |
| { |
| if (tpm_marshal_TPM_PCR_SELECTION(ptr, length, &v->select) |
| || tpm_marshal_UINT32(ptr, length, v->valueSize) |
| || v->valueSize > sizeof(v->pcrValue) |
| || tpm_marshal_TPM_PCRVALUE_ARRAY(ptr, length, v->pcrValue, |
| v->valueSize / sizeof(TPM_PCRVALUE))) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_PCR_COMPOSITE(BYTE **ptr, UINT32 *length, TPM_PCR_COMPOSITE *v) |
| { |
| if (tpm_unmarshal_TPM_PCR_SELECTION(ptr, length, &v->select) |
| || tpm_unmarshal_UINT32(ptr, length, &v->valueSize) |
| || v->valueSize > sizeof(v->pcrValue) |
| || tpm_unmarshal_TPM_PCRVALUE_ARRAY(ptr, length, v->pcrValue, |
| v->valueSize / sizeof(TPM_PCRVALUE))) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_PCR_INFO(BYTE **ptr, UINT32 *length, TPM_PCR_INFO *v) |
| { |
| if (v->tag == TPM_TAG_PCR_INFO_LONG) { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_TPM_LOCALITY_SELECTION(ptr, length, v->localityAtCreation) |
| || tpm_marshal_TPM_LOCALITY_SELECTION(ptr, length, v->localityAtRelease) |
| || tpm_marshal_TPM_PCR_SELECTION(ptr, length, &v->creationPCRSelection) |
| || tpm_marshal_TPM_PCR_SELECTION(ptr, length, &v->releasePCRSelection) |
| || tpm_marshal_TPM_COMPOSITE_HASH(ptr, length, &v->digestAtCreation) |
| || tpm_marshal_TPM_COMPOSITE_HASH(ptr, length, &v->digestAtRelease)) return -1; |
| } else { |
| if (tpm_marshal_TPM_PCR_SELECTION(ptr, length, &v->creationPCRSelection) |
| || tpm_marshal_TPM_COMPOSITE_HASH(ptr, length, &v->digestAtRelease) |
| || tpm_marshal_TPM_COMPOSITE_HASH(ptr, length, &v->digestAtCreation)) return -1; |
| } |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_PCR_INFO(BYTE **ptr, UINT32 *length, TPM_PCR_INFO *v) |
| { |
| if ((((UINT16)(*ptr)[0] << 8) | (*ptr)[1]) == TPM_TAG_PCR_INFO_LONG) { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_TPM_LOCALITY_SELECTION(ptr, length, &v->localityAtCreation) |
| || tpm_unmarshal_TPM_LOCALITY_SELECTION(ptr, length, &v->localityAtRelease) |
| || tpm_unmarshal_TPM_PCR_SELECTION(ptr, length, &v->creationPCRSelection) |
| || tpm_unmarshal_TPM_PCR_SELECTION(ptr, length, &v->releasePCRSelection) |
| || tpm_unmarshal_TPM_COMPOSITE_HASH(ptr, length, &v->digestAtCreation) |
| || tpm_unmarshal_TPM_COMPOSITE_HASH(ptr, length, &v->digestAtRelease)) return -1; |
| } else { |
| if (tpm_unmarshal_TPM_PCR_SELECTION(ptr, length, &v->creationPCRSelection) |
| || tpm_unmarshal_TPM_COMPOSITE_HASH(ptr, length, &v->digestAtRelease) |
| || tpm_unmarshal_TPM_COMPOSITE_HASH(ptr, length, &v->digestAtCreation)) return -1; |
| memcpy(&v->releasePCRSelection, &v->creationPCRSelection, sizeof(TPM_PCR_SELECTION)); |
| v->tag = 0x0000; |
| v->localityAtCreation = 0; |
| v->localityAtRelease = 0; |
| } |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_PCR_INFO_SHORT(BYTE **ptr, UINT32 *length, TPM_PCR_INFO_SHORT *v) |
| { |
| if (tpm_marshal_TPM_PCR_SELECTION(ptr, length, &v->pcrSelection) |
| || tpm_marshal_TPM_LOCALITY_SELECTION(ptr, length, v->localityAtRelease) |
| || tpm_marshal_TPM_COMPOSITE_HASH(ptr, length, &v->digestAtRelease)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_PCR_INFO_SHORT(BYTE **ptr, UINT32 *length, TPM_PCR_INFO_SHORT *v) |
| { |
| if (tpm_unmarshal_TPM_PCR_SELECTION(ptr, length, &v->pcrSelection) |
| || tpm_unmarshal_TPM_LOCALITY_SELECTION(ptr, length, &v->localityAtRelease) |
| || tpm_unmarshal_TPM_COMPOSITE_HASH(ptr, length, &v->digestAtRelease)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_PCR_ATTRIBUTES(BYTE **ptr, UINT32 *length, TPM_PCR_ATTRIBUTES *v) |
| { |
| if (tpm_marshal_BOOL(ptr, length, v->pcrReset) |
| || tpm_marshal_TPM_LOCALITY_SELECTION(ptr, length, v->pcrResetLocal) |
| || tpm_marshal_TPM_LOCALITY_SELECTION(ptr, length, v->pcrExtendLocal)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_PCR_ATTRIBUTES(BYTE **ptr, UINT32 *length, TPM_PCR_ATTRIBUTES *v) |
| { |
| if (tpm_unmarshal_BOOL(ptr, length, &v->pcrReset) |
| || tpm_unmarshal_TPM_LOCALITY_SELECTION(ptr, length, &v->pcrResetLocal) |
| || tpm_unmarshal_TPM_LOCALITY_SELECTION(ptr, length, &v->pcrExtendLocal)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_STORED_DATA(BYTE **ptr, UINT32 *length, TPM_STORED_DATA *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_TPM_ENTITY_TYPE(ptr, length, v->et) |
| || tpm_marshal_UINT32(ptr, length, v->sealInfoSize) |
| || (v->sealInfoSize > 0 |
| && tpm_marshal_TPM_PCR_INFO(ptr, length, &v->sealInfo)) |
| || tpm_marshal_UINT32(ptr, length, v->encDataSize) |
| || tpm_marshal_BLOB(ptr, length, v->encData, v->encDataSize)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_STORED_DATA(BYTE **ptr, UINT32 *length, TPM_STORED_DATA *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_TPM_ENTITY_TYPE(ptr, length, &v->et) |
| || tpm_unmarshal_UINT32(ptr, length, &v->sealInfoSize) |
| || (v->sealInfoSize > 0 |
| && tpm_unmarshal_TPM_PCR_INFO(ptr, length, &v->sealInfo)) |
| || tpm_unmarshal_UINT32(ptr, length, &v->encDataSize) |
| || tpm_unmarshal_BLOB(ptr, length, &v->encData, v->encDataSize)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_SEALED_DATA(BYTE **ptr, UINT32 *length, TPM_SEALED_DATA *v) |
| { |
| if (tpm_marshal_TPM_PAYLOAD_TYPE(ptr, length, v->payload) |
| || tpm_marshal_TPM_SECRET(ptr, length, &v->authData) |
| || tpm_marshal_TPM_NONCE(ptr, length, &v->tpmProof) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->storedDigest) |
| || tpm_marshal_UINT32(ptr, length, v->dataSize) |
| || tpm_marshal_BLOB(ptr, length, v->data, v->dataSize)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_SEALED_DATA(BYTE **ptr, UINT32 *length, TPM_SEALED_DATA *v) |
| { |
| if (tpm_unmarshal_TPM_PAYLOAD_TYPE(ptr, length, &v->payload) |
| || tpm_unmarshal_TPM_SECRET(ptr, length, &v->authData) |
| || tpm_unmarshal_TPM_NONCE(ptr, length, &v->tpmProof) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->storedDigest) |
| || tpm_unmarshal_UINT32(ptr, length, &v->dataSize) |
| || tpm_unmarshal_BLOB(ptr, length, &v->data, v->dataSize)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_SYMMETRIC_KEY(BYTE **ptr, UINT32 *length, TPM_SYMMETRIC_KEY *v) |
| { |
| if (tpm_marshal_TPM_ALGORITHM_ID(ptr, length, v->algId) |
| || tpm_marshal_TPM_ENC_SCHEME(ptr, length, v->encScheme) |
| || tpm_marshal_UINT16(ptr, length, v->size) |
| || tpm_marshal_BLOB(ptr, length, v->data, v->size)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_SYMMETRIC_KEY(BYTE **ptr, UINT32 *length, TPM_SYMMETRIC_KEY *v) |
| { |
| if (tpm_unmarshal_TPM_ALGORITHM_ID(ptr, length, &v->algId) |
| || tpm_unmarshal_TPM_ENC_SCHEME(ptr, length, &v->encScheme) |
| || tpm_unmarshal_UINT16(ptr, length, &v->size) |
| || tpm_unmarshal_BLOB(ptr, length, &v->data, v->size)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_SYMMETRIC_KEY_PARMS(BYTE **ptr, UINT32 *length, TPM_SYMMETRIC_KEY_PARMS *v) |
| { |
| if (tpm_marshal_UINT32(ptr, length, v->keyLength) |
| || tpm_marshal_UINT32(ptr, length, v->blockSize) |
| || tpm_marshal_UINT32(ptr, length, v->ivSize) |
| || tpm_marshal_BLOB(ptr, length, v->IV, v->ivSize)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_SYMMETRIC_KEY_PARMS(BYTE **ptr, UINT32 *length, TPM_SYMMETRIC_KEY_PARMS *v) |
| { |
| if (tpm_unmarshal_UINT32(ptr, length, &v->keyLength) |
| || tpm_unmarshal_UINT32(ptr, length, &v->blockSize) |
| || tpm_unmarshal_UINT32(ptr, length, &v->ivSize) |
| || tpm_unmarshal_BLOB(ptr, length, &v->IV, v->ivSize)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_RSA_KEY_PARMS(BYTE **ptr, UINT32 *length, TPM_RSA_KEY_PARMS *v) |
| { |
| if (tpm_marshal_UINT32(ptr, length, v->keyLength) |
| || tpm_marshal_UINT32(ptr, length, v->numPrimes) |
| || tpm_marshal_UINT32(ptr, length, v->exponentSize) |
| || tpm_marshal_BLOB(ptr, length, v->exponent, v->exponentSize)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_RSA_KEY_PARMS(BYTE **ptr, UINT32 *length, TPM_RSA_KEY_PARMS *v) |
| { |
| if (tpm_unmarshal_UINT32(ptr, length, &v->keyLength) |
| || tpm_unmarshal_UINT32(ptr, length, &v->numPrimes) |
| || tpm_unmarshal_UINT32(ptr, length, &v->exponentSize) |
| || tpm_unmarshal_BLOB(ptr, length, &v->exponent, v->exponentSize)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_KEY_PARMS(BYTE **ptr, UINT32 *length, TPM_KEY_PARMS *v) |
| { |
| if (tpm_marshal_TPM_ALGORITHM_ID(ptr, length, v->algorithmID) |
| || tpm_marshal_TPM_ENC_SCHEME(ptr, length, v->encScheme) |
| || tpm_marshal_TPM_SIG_SCHEME(ptr, length, v->sigScheme) |
| || tpm_marshal_UINT32(ptr, length, v->parmSize)) return -1; |
| switch (v->algorithmID) { |
| case TPM_ALG_RSA: |
| if (tpm_marshal_TPM_RSA_KEY_PARMS(ptr, length, &v->parms.rsa)) return -1; |
| break; |
| case TPM_ALG_DES: case TPM_ALG_3DES: case TPM_ALG_AES192: case TPM_ALG_AES256: |
| if (tpm_marshal_TPM_SYMMETRIC_KEY_PARMS(ptr, length, &v->parms.skp)) return -1; |
| break; |
| default: |
| if (tpm_marshal_BLOB(ptr, length, v->parms.raw, v->parmSize)) return -1; |
| } |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_KEY_PARMS(BYTE **ptr, UINT32 *length, TPM_KEY_PARMS *v) |
| { |
| if (tpm_unmarshal_TPM_ALGORITHM_ID(ptr, length, &v->algorithmID) |
| || tpm_unmarshal_TPM_ENC_SCHEME(ptr, length, &v->encScheme) |
| || tpm_unmarshal_TPM_SIG_SCHEME(ptr, length, &v->sigScheme) |
| || tpm_unmarshal_UINT32(ptr, length, &v->parmSize)) return -1; |
| switch (v->algorithmID) { |
| case TPM_ALG_RSA: |
| if (tpm_unmarshal_TPM_RSA_KEY_PARMS(ptr, length, &v->parms.rsa)) return -1; |
| break; |
| case TPM_ALG_DES: case TPM_ALG_3DES: case TPM_ALG_AES192: case TPM_ALG_AES256: |
| if (tpm_unmarshal_TPM_SYMMETRIC_KEY_PARMS(ptr, length, &v->parms.skp)) return -1; |
| break; |
| default: |
| if (tpm_unmarshal_BLOB(ptr, length, &v->parms.raw, v->parmSize)) return -1; |
| } |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_STORE_PUBKEY(BYTE **ptr, UINT32 *length, TPM_STORE_PUBKEY *v) |
| { |
| if (tpm_marshal_UINT32(ptr, length, v->keyLength) |
| || tpm_marshal_BLOB(ptr, length, v->key, v->keyLength)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_STORE_PUBKEY(BYTE **ptr, UINT32 *length, TPM_STORE_PUBKEY *v) |
| { |
| if (tpm_unmarshal_UINT32(ptr, length, &v->keyLength) |
| || tpm_unmarshal_BLOB(ptr, length, &v->key, v->keyLength)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_KEY(BYTE **ptr, UINT32 *length, TPM_KEY *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_UINT16(ptr, length, v->fill) |
| || tpm_marshal_TPM_KEY_USAGE(ptr, length, v->keyUsage) |
| || tpm_marshal_TPM_KEY_FLAGS(ptr, length, v->keyFlags) |
| || tpm_marshal_TPM_AUTH_DATA_USAGE(ptr, length, v->authDataUsage) |
| || tpm_marshal_TPM_KEY_PARMS(ptr, length, &v->algorithmParms) |
| || tpm_marshal_UINT32(ptr, length, v->PCRInfoSize) |
| || (v->PCRInfoSize > 0 |
| && tpm_marshal_TPM_PCR_INFO(ptr, length, &v->PCRInfo)) |
| || tpm_marshal_TPM_STORE_PUBKEY(ptr, length, &v->pubKey) |
| || tpm_marshal_UINT32(ptr, length, v->encDataSize) |
| || tpm_marshal_BLOB(ptr, length, v->encData, v->encDataSize)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_KEY(BYTE **ptr, UINT32 *length, TPM_KEY *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_UINT16(ptr, length, &v->fill) |
| || tpm_unmarshal_TPM_KEY_USAGE(ptr, length, &v->keyUsage) |
| || tpm_unmarshal_TPM_KEY_FLAGS(ptr, length, &v->keyFlags) |
| || tpm_unmarshal_TPM_AUTH_DATA_USAGE(ptr, length, &v->authDataUsage) |
| || tpm_unmarshal_TPM_KEY_PARMS(ptr, length, &v->algorithmParms) |
| || tpm_unmarshal_UINT32(ptr, length, &v->PCRInfoSize) |
| || (v->PCRInfoSize > 0 |
| && tpm_unmarshal_TPM_PCR_INFO(ptr, length, &v->PCRInfo)) |
| || tpm_unmarshal_TPM_STORE_PUBKEY(ptr, length, &v->pubKey) |
| || tpm_unmarshal_UINT32(ptr, length, &v->encDataSize) |
| || tpm_unmarshal_BLOB(ptr, length, &v->encData, v->encDataSize)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_PUBKEY(BYTE **ptr, UINT32 *length, TPM_PUBKEY *v) |
| { |
| if (tpm_marshal_TPM_KEY_PARMS(ptr, length, &v->algorithmParms) |
| || tpm_marshal_TPM_STORE_PUBKEY(ptr, length, &v->pubKey)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_PUBKEY(BYTE **ptr, UINT32 *length, TPM_PUBKEY *v) |
| { |
| if (tpm_unmarshal_TPM_KEY_PARMS(ptr, length, &v->algorithmParms) |
| || tpm_unmarshal_TPM_STORE_PUBKEY(ptr, length, &v->pubKey)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_STORE_PRIVKEY(BYTE **ptr, UINT32 *length, TPM_STORE_PRIVKEY *v) |
| { |
| if (tpm_marshal_UINT32(ptr, length, v->keyLength) |
| || tpm_marshal_BLOB(ptr, length, v->key, v->keyLength)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_STORE_PRIVKEY(BYTE **ptr, UINT32 *length, TPM_STORE_PRIVKEY *v) |
| { |
| if (tpm_unmarshal_UINT32(ptr, length, &v->keyLength) |
| || tpm_unmarshal_BLOB(ptr, length, &v->key, v->keyLength)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_STORE_ASYMKEY(BYTE **ptr, UINT32 *length, TPM_STORE_ASYMKEY *v) |
| { |
| if (tpm_marshal_TPM_PAYLOAD_TYPE(ptr, length, v->payload) |
| || tpm_marshal_TPM_SECRET(ptr, length, &v->usageAuth) |
| || tpm_marshal_TPM_SECRET(ptr, length, &v->migrationAuth) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->pubDataDigest) |
| || tpm_marshal_TPM_STORE_PRIVKEY(ptr, length, &v->privKey)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_STORE_ASYMKEY(BYTE **ptr, UINT32 *length, TPM_STORE_ASYMKEY *v) |
| { |
| if (tpm_unmarshal_TPM_PAYLOAD_TYPE(ptr, length, &v->payload) |
| || tpm_unmarshal_TPM_SECRET(ptr, length, &v->usageAuth) |
| || tpm_unmarshal_TPM_SECRET(ptr, length, &v->migrationAuth) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->pubDataDigest) |
| || tpm_unmarshal_TPM_STORE_PRIVKEY(ptr, length, &v->privKey)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_MIGRATIONKEYAUTH(BYTE **ptr, UINT32 *length, TPM_MIGRATIONKEYAUTH *v) |
| { |
| if (tpm_marshal_TPM_PUBKEY(ptr, length, &v->migrationKey) |
| || tpm_marshal_TPM_MIGRATE_SCHEME(ptr, length, v->migrationScheme) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->digest)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_MIGRATIONKEYAUTH(BYTE **ptr, UINT32 *length, TPM_MIGRATIONKEYAUTH *v) |
| { |
| if (tpm_unmarshal_TPM_PUBKEY(ptr, length, &v->migrationKey) |
| || tpm_unmarshal_TPM_MIGRATE_SCHEME(ptr, length, &v->migrationScheme) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->digest)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_CERTIFY_INFO(BYTE **ptr, UINT32 *length, TPM_CERTIFY_INFO *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_BYTE(ptr, length, v->fill) |
| || tpm_marshal_TPM_PAYLOAD_TYPE(ptr, length, v->payloadType) |
| || tpm_marshal_TPM_KEY_USAGE(ptr, length, v->keyUsage) |
| || tpm_marshal_TPM_KEY_FLAGS(ptr, length, v->keyFlags) |
| || tpm_marshal_TPM_AUTH_DATA_USAGE(ptr, length, v->authDataUsage) |
| || tpm_marshal_TPM_KEY_PARMS(ptr, length, &v->algorithmParms) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->pubkeyDigest) |
| || tpm_marshal_TPM_NONCE(ptr, length, &v->data) |
| || tpm_marshal_BOOL(ptr, length, v->parentPCRStatus) |
| || tpm_marshal_UINT32(ptr, length, v->PCRInfoSize) |
| || (v->PCRInfoSize > 0 |
| && tpm_marshal_TPM_PCR_INFO(ptr, length, &v->PCRInfo)) |
| || (v->tag == TPM_TAG_CERTIFY_INFO2 |
| && tpm_marshal_UINT32(ptr, length, v->migrationAuthoritySize)) |
| || (v->tag == TPM_TAG_CERTIFY_INFO2 && v->migrationAuthoritySize > 0 |
| && tpm_marshal_BLOB(ptr, length, v->migrationAuthority, |
| v->migrationAuthoritySize))) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_CERTIFY_INFO(BYTE **ptr, UINT32 *length, TPM_CERTIFY_INFO *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_BYTE(ptr, length, &v->fill) |
| || tpm_unmarshal_TPM_PAYLOAD_TYPE(ptr, length, &v->payloadType) |
| || tpm_unmarshal_TPM_KEY_USAGE(ptr, length, &v->keyUsage) |
| || tpm_unmarshal_TPM_KEY_FLAGS(ptr, length, &v->keyFlags) |
| || tpm_unmarshal_TPM_AUTH_DATA_USAGE(ptr, length, &v->authDataUsage) |
| || tpm_unmarshal_TPM_KEY_PARMS(ptr, length, &v->algorithmParms) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->pubkeyDigest) |
| || tpm_unmarshal_TPM_NONCE(ptr, length, &v->data) |
| || tpm_unmarshal_BOOL(ptr, length, &v->parentPCRStatus) |
| || tpm_unmarshal_UINT32(ptr, length, &v->PCRInfoSize) |
| || (v->PCRInfoSize > 0 |
| && tpm_unmarshal_TPM_PCR_INFO(ptr, length, &v->PCRInfo)) |
| || (!(v->migrationAuthoritySize = 0) && v->tag == TPM_TAG_CERTIFY_INFO2 |
| && tpm_unmarshal_UINT32(ptr, length, &v->migrationAuthoritySize)) |
| || (v->tag == TPM_TAG_CERTIFY_INFO2 && v->migrationAuthoritySize > 0 |
| && tpm_unmarshal_BLOB(ptr, length, &v->migrationAuthority, |
| v->migrationAuthoritySize))) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_IDENTITY_CONTENTS(BYTE **ptr, UINT32 *length, TPM_IDENTITY_CONTENTS *v) |
| { |
| if (tpm_marshal_TPM_STRUCT_VER(ptr, length, &v->ver) |
| || tpm_marshal_UINT32(ptr, length, v->ordinal) |
| || tpm_marshal_TPM_CHOSENID_HASH(ptr, length, &v->labelPrivCADigest) |
| || tpm_marshal_TPM_PUBKEY(ptr, length, &v->identityPubKey)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_IDENTITY_CONTENTS(BYTE **ptr, UINT32 *length, TPM_IDENTITY_CONTENTS *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCT_VER(ptr, length, &v->ver) |
| || tpm_unmarshal_UINT32(ptr, length, &v->ordinal) |
| || tpm_unmarshal_TPM_CHOSENID_HASH(ptr, length, &v->labelPrivCADigest) |
| || tpm_unmarshal_TPM_PUBKEY(ptr, length, &v->identityPubKey)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_CURRENT_TICKS(BYTE **ptr, UINT32 *length, TPM_CURRENT_TICKS *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_UINT64(ptr, length, v->currentTicks) |
| || tpm_marshal_UINT16(ptr, length, v->tickRate) |
| || tpm_marshal_TPM_NONCE(ptr, length, &v->tickNonce)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_CURRENT_TICKS(BYTE **ptr, UINT32 *length, TPM_CURRENT_TICKS *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_UINT64(ptr, length, &v->currentTicks) |
| || tpm_unmarshal_UINT16(ptr, length, &v->tickRate) |
| || tpm_unmarshal_TPM_NONCE(ptr, length, &v->tickNonce)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_TRANSPORT_PUBLIC(BYTE **ptr, UINT32 *length, TPM_TRANSPORT_PUBLIC *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_TPM_TRANSPORT_ATTRIBUTES(ptr, length, v->transAttributes) |
| || tpm_marshal_TPM_ALGORITHM_ID(ptr, length, v->algID) |
| || tpm_marshal_TPM_ENC_SCHEME(ptr, length, v->encScheme)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_TRANSPORT_PUBLIC(BYTE **ptr, UINT32 *length, TPM_TRANSPORT_PUBLIC *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_TPM_TRANSPORT_ATTRIBUTES(ptr, length, &v->transAttributes) |
| || tpm_unmarshal_TPM_ALGORITHM_ID(ptr, length, &v->algID) |
| || tpm_unmarshal_TPM_ENC_SCHEME(ptr, length, &v->encScheme)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_TRANSPORT_INTERNAL(BYTE **ptr, UINT32 *length, TPM_TRANSPORT_INTERNAL *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_TPM_AUTHDATA(ptr, length, &v->authData) |
| || tpm_marshal_TPM_TRANSPORT_PUBLIC(ptr, length, &v->transPublic) |
| || tpm_marshal_TPM_TRANSHANDLE(ptr, length, v->transHandle) |
| || tpm_marshal_TPM_NONCE(ptr, length, &v->transNonceEven) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->transDigest)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_TRANSPORT_INTERNAL(BYTE **ptr, UINT32 *length, TPM_TRANSPORT_INTERNAL *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_TPM_AUTHDATA(ptr, length, &v->authData) |
| || tpm_unmarshal_TPM_TRANSPORT_PUBLIC(ptr, length, &v->transPublic) |
| || tpm_unmarshal_TPM_TRANSHANDLE(ptr, length, &v->transHandle) |
| || tpm_unmarshal_TPM_NONCE(ptr, length, &v->transNonceEven) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->transDigest)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_CONTEXT_BLOB(BYTE **ptr, UINT32 *length, TPM_CONTEXT_BLOB *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_TPM_RESOURCE_TYPE(ptr, length, v->resourceType) |
| || tpm_marshal_TPM_HANDLE(ptr, length, v->handle) |
| || tpm_marshal_BYTE_ARRAY(ptr, length, v->label, sizeof(v->label)) |
| || tpm_marshal_UINT32(ptr, length, v->contextCount) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->integrityDigest) |
| || tpm_marshal_UINT32(ptr, length, v->additionalSize) |
| || tpm_marshal_BLOB(ptr, length, v->additionalData, v->additionalSize) |
| || tpm_marshal_UINT32(ptr, length, v->sensitiveSize) |
| || tpm_marshal_BLOB(ptr, length, v->sensitiveData, v->sensitiveSize)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_CONTEXT_BLOB(BYTE **ptr, UINT32 *length, TPM_CONTEXT_BLOB *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_TPM_RESOURCE_TYPE(ptr, length, &v->resourceType) |
| || tpm_unmarshal_TPM_HANDLE(ptr, length, &v->handle) |
| || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->label, sizeof(v->label)) |
| || tpm_unmarshal_UINT32(ptr, length, &v->contextCount) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->integrityDigest) |
| || tpm_unmarshal_UINT32(ptr, length, &v->additionalSize) |
| || tpm_unmarshal_BLOB(ptr, length, &v->additionalData, v->additionalSize) |
| || tpm_unmarshal_UINT32(ptr, length, &v->sensitiveSize) |
| || tpm_unmarshal_BLOB(ptr, length, &v->sensitiveData, v->sensitiveSize)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_CONTEXT_SENSITIVE(BYTE **ptr, UINT32 *length, TPM_CONTEXT_SENSITIVE *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_TPM_NONCE(ptr, length, &v->contextNonce) |
| || tpm_marshal_UINT32(ptr, length, v->internalSize) |
| || tpm_marshal_TPM_RESOURCE_TYPE(ptr, length, v->resourceType)) |
| return -1; |
| switch (v->resourceType) { |
| case TPM_RT_KEY: |
| if (tpm_marshal_TPM_KEY_DATA(ptr, length, &v->internalData.key)) |
| return -1; |
| break; |
| case TPM_RT_AUTH: |
| case TPM_RT_TRANS: |
| if (tpm_marshal_TPM_SESSION_DATA(ptr, length, &v->internalData.session)) |
| return -1; |
| break; |
| case TPM_RT_DAA_TPM: |
| if (tpm_marshal_TPM_DAA_SESSION_DATA(ptr, length, &v->internalData.sessionDAA)) |
| return -1; |
| break; |
| default: |
| return -1; |
| } |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_CONTEXT_SENSITIVE(BYTE **ptr, UINT32 *length, TPM_CONTEXT_SENSITIVE *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_TPM_NONCE(ptr, length, &v->contextNonce) |
| || tpm_unmarshal_UINT32(ptr, length, &v->internalSize) |
| || tpm_unmarshal_TPM_RESOURCE_TYPE(ptr, length, &v->resourceType)) |
| return -1; |
| switch (v->resourceType) { |
| case TPM_RT_KEY: |
| if (tpm_unmarshal_TPM_KEY_DATA(ptr, length, &v->internalData.key)) |
| return -1; |
| break; |
| case TPM_RT_AUTH: |
| case TPM_RT_TRANS: |
| if (tpm_unmarshal_TPM_SESSION_DATA(ptr, length, &v->internalData.session)) |
| return -1; |
| break; |
| case TPM_RT_DAA_TPM: |
| if (tpm_unmarshal_TPM_DAA_SESSION_DATA(ptr, length, &v->internalData.sessionDAA)) |
| return -1; |
| break; |
| default: |
| return -1; |
| } |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_DAA_BLOB(BYTE **ptr, UINT32 *length, TPM_DAA_BLOB *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_TPM_RESOURCE_TYPE(ptr, length, v->resourceType) |
| || tpm_marshal_BYTE_ARRAY(ptr, length, v->label, sizeof(v->label)) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->blobIntegrity) |
| || tpm_marshal_UINT32(ptr, length, v->additionalSize) |
| || tpm_marshal_BLOB(ptr, length, v->additionalData, v->additionalSize) |
| || tpm_marshal_UINT32(ptr, length, v->sensitiveSize) |
| || tpm_marshal_BLOB(ptr, length, v->sensitiveData, v->sensitiveSize)) |
| return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_DAA_BLOB(BYTE **ptr, UINT32 *length, TPM_DAA_BLOB *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_TPM_RESOURCE_TYPE(ptr, length, &v->resourceType) |
| || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->label, sizeof(v->label)) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->blobIntegrity) |
| || tpm_unmarshal_UINT32(ptr, length, &v->additionalSize) |
| || tpm_unmarshal_BLOB(ptr, length, &v->additionalData, v->additionalSize) |
| || tpm_unmarshal_UINT32(ptr, length, &v->sensitiveSize) |
| || tpm_unmarshal_BLOB(ptr, length, &v->sensitiveData, v->sensitiveSize)) |
| return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_DAA_SENSITIVE(BYTE **ptr, UINT32 *length, TPM_DAA_SENSITIVE *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_UINT32(ptr, length, v->internalSize) |
| || tpm_marshal_BYTE_ARRAY(ptr, length, v->internalData, v->internalSize)) |
| return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_DAA_SENSITIVE(BYTE **ptr, UINT32 *length, TPM_DAA_SENSITIVE *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_UINT32(ptr, length, &v->internalSize) |
| || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->internalData, v->internalSize)) |
| return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_DAA_ISSUER(BYTE **ptr, UINT32 *length, TPM_DAA_ISSUER *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_digest_R0) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_digest_R1) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_digest_S0) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_digest_S1) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_digest_n) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_digest_gamma) |
| || tpm_marshal_BYTE_ARRAY(ptr, length, v->DAA_generic_q, sizeof(v->DAA_generic_q))) |
| return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_DAA_ISSUER(BYTE **ptr, UINT32 *length, TPM_DAA_ISSUER *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_digest_R0) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_digest_R1) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_digest_S0) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_digest_S1) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_digest_n) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_digest_gamma) |
| || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->DAA_generic_q, sizeof(v->DAA_generic_q))) |
| return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_DAA_TPM(BYTE **ptr, UINT32 *length, TPM_DAA_TPM *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_digestIssuer) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_digest_v0) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_digest_v1) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_rekey) |
| || tpm_marshal_UINT32(ptr, length, v->DAA_count)) |
| return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_DAA_TPM(BYTE **ptr, UINT32 *length, TPM_DAA_TPM *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_digestIssuer) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_digest_v0) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_digest_v1) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_rekey) |
| || tpm_unmarshal_UINT32(ptr, length, &v->DAA_count)) |
| return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_DAA_CONTEXT(BYTE **ptr, UINT32 *length, TPM_DAA_CONTEXT *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_digestContext) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_digest) |
| || tpm_marshal_TPM_NONCE(ptr, length, &v->DAA_contextSeed) |
| || tpm_marshal_BYTE_ARRAY(ptr, length, v->DAA_scratch, sizeof(v->DAA_scratch)) |
| || tpm_marshal_BYTE(ptr, length, v->DAA_stage)) |
| return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_DAA_CONTEXT(BYTE **ptr, UINT32 *length, TPM_DAA_CONTEXT *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_digestContext) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_digest) |
| || tpm_unmarshal_TPM_NONCE(ptr, length, &v->DAA_contextSeed) |
| || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->DAA_scratch, sizeof(v->DAA_scratch)) |
| || tpm_unmarshal_BYTE(ptr, length, &v->DAA_stage)) |
| return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_DAA_JOINDATA(BYTE **ptr, UINT32 *length, TPM_DAA_JOINDATA *v) |
| { |
| if (tpm_marshal_BYTE_ARRAY(ptr, length, v->DAA_join_u0, sizeof(v->DAA_join_u0)) |
| || tpm_marshal_BYTE_ARRAY(ptr, length, v->DAA_join_u1, sizeof(v->DAA_join_u1)) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->DAA_digest_n0)) |
| return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_DAA_JOINDATA(BYTE **ptr, UINT32 *length, TPM_DAA_JOINDATA *v) |
| { |
| if (tpm_unmarshal_BYTE_ARRAY(ptr, length, v->DAA_join_u0, sizeof(v->DAA_join_u0)) |
| || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->DAA_join_u1, sizeof(v->DAA_join_u1)) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->DAA_digest_n0)) |
| return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_DAA_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_DAA_SESSION_DATA *v) |
| { |
| if (tpm_marshal_BYTE(ptr, length, v->type) |
| || tpm_marshal_TPM_DAA_ISSUER(ptr, length, &v->DAA_issuerSettings) |
| || tpm_marshal_TPM_DAA_TPM(ptr, length, &v->DAA_tpmSpecific) |
| || tpm_marshal_TPM_DAA_CONTEXT(ptr, length, &v->DAA_session) |
| || tpm_marshal_TPM_DAA_JOINDATA(ptr, length, &v->DAA_joinSession) |
| || tpm_marshal_TPM_HANDLE(ptr, length, v->handle)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_DAA_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_DAA_SESSION_DATA *v) |
| { |
| if (tpm_unmarshal_BYTE(ptr, length, &v->type) |
| || tpm_unmarshal_TPM_DAA_ISSUER(ptr, length, &v->DAA_issuerSettings) |
| || tpm_unmarshal_TPM_DAA_TPM(ptr, length, &v->DAA_tpmSpecific) |
| || tpm_unmarshal_TPM_DAA_CONTEXT(ptr, length, &v->DAA_session) |
| || tpm_unmarshal_TPM_DAA_JOINDATA(ptr, length, &v->DAA_joinSession) |
| || tpm_unmarshal_TPM_HANDLE(ptr, length, &v->handle)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_MSA_COMPOSITE(BYTE **ptr, UINT32 *length, TPM_MSA_COMPOSITE *v) |
| { |
| UINT32 i; |
| if (tpm_marshal_UINT32(ptr, length, v->MSAlist)) |
| return -1; |
| for (i = 0; i < v->MSAlist; i++) { |
| if (tpm_marshal_TPM_DIGEST(ptr, length, &v->migAuthDigest[i])) return -1; |
| } |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_MSA_COMPOSITE(BYTE **ptr, UINT32 *length, TPM_MSA_COMPOSITE *v) |
| { |
| UINT32 i; |
| if (tpm_unmarshal_UINT32(ptr, length, &v->MSAlist)) |
| return -1; |
| if (v->MSAlist > MAX_MSA_COMPOSITE_ENTRIES) return -1; |
| for (i = 0; i < v->MSAlist; i++) { |
| if (tpm_unmarshal_TPM_DIGEST(ptr, length, &v->migAuthDigest[i])) return -1; |
| } |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_CMK_AUTH(BYTE **ptr, UINT32 *length, TPM_CMK_AUTH *v) |
| { |
| if (tpm_marshal_TPM_DIGEST(ptr, length, &v->migrationAuthorityDigest) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->destinationKeyDigest) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->sourceKeyDigest)) |
| return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_CMK_AUTH(BYTE **ptr, UINT32 *length, TPM_CMK_AUTH *v) |
| { |
| if (tpm_unmarshal_TPM_DIGEST(ptr, length, &v->migrationAuthorityDigest) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->destinationKeyDigest) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->sourceKeyDigest)) |
| return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_SELECT_SIZE(BYTE **ptr, UINT32 *length, TPM_SELECT_SIZE *v) |
| { |
| if (tpm_marshal_BYTE(ptr, length, v->major) |
| || tpm_marshal_BYTE(ptr, length, v->minor) |
| || tpm_marshal_UINT16(ptr, length, v->reqSize)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_SELECT_SIZE(BYTE **ptr, UINT32 *length, TPM_SELECT_SIZE *v) |
| { |
| if (tpm_unmarshal_BYTE(ptr, length, &v->major) |
| || tpm_unmarshal_BYTE(ptr, length, &v->minor) |
| || tpm_unmarshal_UINT16(ptr, length, &v->reqSize)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_CAP_VERSION_INFO(BYTE **ptr, UINT32 *length, TPM_CAP_VERSION_INFO *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_TPM_VERSION(ptr, length, &v->version) |
| || tpm_marshal_UINT16(ptr, length, v->specLevel) |
| || tpm_marshal_BYTE(ptr, length, v->errataRev) |
| || tpm_marshal_BYTE(ptr, length, v->tpmVendorID[0]) |
| || tpm_marshal_BYTE(ptr, length, v->tpmVendorID[1]) |
| || tpm_marshal_BYTE(ptr, length, v->tpmVendorID[2]) |
| || tpm_marshal_BYTE(ptr, length, v->tpmVendorID[3]) |
| || tpm_marshal_UINT16(ptr, length, v->vendorSpecificSize) |
| || tpm_marshal_BLOB(ptr, length, v->vendorSpecific, v->vendorSpecificSize)) |
| return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_CAP_VERSION_INFO(BYTE **ptr, UINT32 *length, TPM_CAP_VERSION_INFO *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_TPM_VERSION(ptr, length, &v->version) |
| || tpm_unmarshal_UINT16(ptr, length, &v->specLevel) |
| || tpm_unmarshal_BYTE(ptr, length, &v->errataRev) |
| || tpm_unmarshal_BYTE(ptr, length, &v->tpmVendorID[0]) |
| || tpm_unmarshal_BYTE(ptr, length, &v->tpmVendorID[1]) |
| || tpm_unmarshal_BYTE(ptr, length, &v->tpmVendorID[2]) |
| || tpm_unmarshal_BYTE(ptr, length, &v->tpmVendorID[3]) |
| || tpm_unmarshal_UINT16(ptr, length, &v->vendorSpecificSize) |
| || tpm_unmarshal_BLOB(ptr, length, &v->vendorSpecific, v->vendorSpecificSize)) |
| return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_ASYM_CA_CONTENTS(BYTE **ptr, UINT32 *length, TPM_ASYM_CA_CONTENTS *v) |
| { |
| if (tpm_marshal_TPM_SYMMETRIC_KEY(ptr, length, &v->sessionKey) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->idDigest)) |
| return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_ASYM_CA_CONTENTS(BYTE **ptr, UINT32 *length, TPM_ASYM_CA_CONTENTS *v) |
| { |
| if (tpm_unmarshal_TPM_SYMMETRIC_KEY(ptr, length, &v->sessionKey) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->idDigest)) |
| return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_QUOTE_INFO2(BYTE **ptr, UINT32 *length, TPM_QUOTE_INFO2 *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_BYTE(ptr, length, v->fixed[0]) |
| || tpm_marshal_BYTE(ptr, length, v->fixed[1]) |
| || tpm_marshal_BYTE(ptr, length, v->fixed[2]) |
| || tpm_marshal_BYTE(ptr, length, v->fixed[3]) |
| || tpm_marshal_TPM_NONCE(ptr, length, &v->externalData) |
| || tpm_marshal_TPM_PCR_INFO_SHORT(ptr, length, &v->infoShort)) |
| return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_QUOTE_INFO2(BYTE **ptr, UINT32 *length, TPM_QUOTE_INFO2 *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_BYTE(ptr, length, &v->fixed[0]) |
| || tpm_unmarshal_BYTE(ptr, length, &v->fixed[1]) |
| || tpm_unmarshal_BYTE(ptr, length, &v->fixed[2]) |
| || tpm_unmarshal_BYTE(ptr, length, &v->fixed[3]) |
| || tpm_unmarshal_TPM_NONCE(ptr, length, &v->externalData) |
| || tpm_unmarshal_TPM_PCR_INFO_SHORT(ptr, length, &v->infoShort)) |
| return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_EK_BLOB(BYTE **ptr, UINT32 *length, TPM_EK_BLOB *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_TPM_EK_TYPE(ptr, length, v->ekType) |
| || tpm_marshal_UINT32(ptr, length, v->blobSize) |
| || tpm_marshal_BLOB(ptr, length, v->blob, v->blobSize)) |
| return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_EK_BLOB(BYTE **ptr, UINT32 *length, TPM_EK_BLOB *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_TPM_EK_TYPE(ptr, length, &v->ekType) |
| || tpm_unmarshal_UINT32(ptr, length, &v->blobSize) |
| || tpm_unmarshal_BLOB(ptr, length, &v->blob, v->blobSize)) |
| return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_EK_BLOB_ACTIVATE(BYTE **ptr, UINT32 *length, TPM_EK_BLOB_ACTIVATE *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_TPM_SYMMETRIC_KEY(ptr, length, &v->sessionKey) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->idDigest) |
| || tpm_marshal_TPM_PCR_INFO_SHORT(ptr, length, &v->pcrInfo)) |
| return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_EK_BLOB_ACTIVATE(BYTE **ptr, UINT32 *length, TPM_EK_BLOB_ACTIVATE *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_TPM_SYMMETRIC_KEY(ptr, length, &v->sessionKey) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->idDigest) |
| || tpm_unmarshal_TPM_PCR_INFO_SHORT(ptr, length, &v->pcrInfo)) |
| return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_NV_ATTRIBUTES(BYTE **ptr, UINT32 *length, TPM_NV_ATTRIBUTES *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_UINT32(ptr, length, v->attributes)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_NV_ATTRIBUTES(BYTE **ptr, UINT32 *length, TPM_NV_ATTRIBUTES *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_UINT32(ptr, length, &v->attributes)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_NV_DATA_PUBLIC(BYTE **ptr, UINT32 *length, TPM_NV_DATA_PUBLIC *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_TPM_NV_INDEX(ptr, length, v->nvIndex) |
| || tpm_marshal_TPM_PCR_INFO_SHORT(ptr, length, &v->pcrInfoRead) |
| || tpm_marshal_TPM_PCR_INFO_SHORT(ptr, length, &v->pcrInfoWrite) |
| || tpm_marshal_TPM_NV_ATTRIBUTES(ptr, length, &v->permission) |
| || tpm_marshal_BOOL(ptr, length, v->bReadSTClear) |
| || tpm_marshal_BOOL(ptr, length, v->bWriteSTClear) |
| || tpm_marshal_BOOL(ptr, length, v->bWriteDefine) |
| || tpm_marshal_UINT32(ptr, length, v->dataSize)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_NV_DATA_PUBLIC(BYTE **ptr, UINT32 *length, TPM_NV_DATA_PUBLIC *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_TPM_NV_INDEX(ptr, length, &v->nvIndex) |
| || tpm_unmarshal_TPM_PCR_INFO_SHORT(ptr, length, &v->pcrInfoRead) |
| || tpm_unmarshal_TPM_PCR_INFO_SHORT(ptr, length, &v->pcrInfoWrite) |
| || tpm_unmarshal_TPM_NV_ATTRIBUTES(ptr, length, &v->permission) |
| || tpm_unmarshal_BOOL(ptr, length, &v->bReadSTClear) |
| || tpm_unmarshal_BOOL(ptr, length, &v->bWriteSTClear) |
| || tpm_unmarshal_BOOL(ptr, length, &v->bWriteDefine) |
| || tpm_unmarshal_UINT32(ptr, length, &v->dataSize)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_NV_DATA_SENSITIVE(BYTE **ptr, UINT32 *length, TPM_NV_DATA_SENSITIVE *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_TPM_NV_DATA_PUBLIC(ptr, length, &v->pubInfo) |
| || tpm_marshal_TPM_AUTHDATA(ptr, length, &v->authValue) |
| || tpm_marshal_UINT32(ptr, length, v->dataIndex)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_NV_DATA_SENSITIVE(BYTE **ptr, UINT32 *length, TPM_NV_DATA_SENSITIVE *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_TPM_NV_DATA_PUBLIC(ptr, length, &v->pubInfo) |
| || tpm_unmarshal_TPM_AUTHDATA(ptr, length, &v->authValue) |
| || tpm_unmarshal_UINT32(ptr, length, &v->dataIndex)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_DELEGATIONS(BYTE **ptr, UINT32 *length, TPM_DELEGATIONS *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_UINT32(ptr, length, v->delegateType) |
| || tpm_marshal_UINT32(ptr, length, v->per1) |
| || tpm_marshal_UINT32(ptr, length, v->per2)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_DELEGATIONS(BYTE **ptr, UINT32 *length, TPM_DELEGATIONS *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_UINT32(ptr, length, &v->delegateType) |
| || tpm_unmarshal_UINT32(ptr, length, &v->per1) |
| || tpm_unmarshal_UINT32(ptr, length, &v->per2)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_FAMILY_LABEL(BYTE **ptr, UINT32 *length, TPM_FAMILY_LABEL *v) |
| { |
| if (tpm_marshal_BYTE(ptr, length, v->label)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_FAMILY_LABEL(BYTE **ptr, UINT32 *length, TPM_FAMILY_LABEL *v) |
| { |
| if (tpm_unmarshal_BYTE(ptr, length, &v->label)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_FAMILY_TABLE_ENTRY(BYTE **ptr, UINT32 *length, TPM_FAMILY_TABLE_ENTRY *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_TPM_FAMILY_LABEL(ptr, length, &v->familyLabel) |
| || tpm_marshal_TPM_FAMILY_ID(ptr, length, v->familyID) |
| || tpm_marshal_TPM_FAMILY_VERIFICATION(ptr, length, v->verificationCount) |
| || tpm_marshal_TPM_FAMILY_FLAGS(ptr, length, v->flags)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_FAMILY_TABLE_ENTRY(BYTE **ptr, UINT32 *length, TPM_FAMILY_TABLE_ENTRY *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_TPM_FAMILY_LABEL(ptr, length, &v->familyLabel) |
| || tpm_unmarshal_TPM_FAMILY_ID(ptr, length, &v->familyID) |
| || tpm_unmarshal_TPM_FAMILY_VERIFICATION(ptr, length, &v->verificationCount) |
| || tpm_unmarshal_TPM_FAMILY_FLAGS(ptr, length, &v->flags)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_DELEGATE_LABEL(BYTE **ptr, UINT32 *length, TPM_DELEGATE_LABEL *v) |
| { |
| if (tpm_marshal_BYTE(ptr, length, v->label)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_DELEGATE_LABEL(BYTE **ptr, UINT32 *length, TPM_DELEGATE_LABEL *v) |
| { |
| if (tpm_unmarshal_BYTE(ptr, length, &v->label)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_DELEGATE_PUBLIC(BYTE **ptr, UINT32 *length, TPM_DELEGATE_PUBLIC *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_TPM_DELEGATE_LABEL(ptr, length, &v->rowLabel) |
| || tpm_marshal_TPM_PCR_INFO_SHORT(ptr, length, &v->pcrInfo) |
| || tpm_marshal_TPM_DELEGATIONS(ptr, length, &v->permissions) |
| || tpm_marshal_TPM_FAMILY_ID(ptr, length, v->familyID) |
| || tpm_marshal_TPM_FAMILY_VERIFICATION(ptr, length, v->verificationCount)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_DELEGATE_PUBLIC(BYTE **ptr, UINT32 *length, TPM_DELEGATE_PUBLIC *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_TPM_DELEGATE_LABEL(ptr, length, &v->rowLabel) |
| || tpm_unmarshal_TPM_PCR_INFO_SHORT(ptr, length, &v->pcrInfo) |
| || tpm_unmarshal_TPM_DELEGATIONS(ptr, length, &v->permissions) |
| || tpm_unmarshal_TPM_FAMILY_ID(ptr, length, &v->familyID) |
| || tpm_unmarshal_TPM_FAMILY_VERIFICATION(ptr, length, &v->verificationCount)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_DELEGATE_PUBLIC_ARRAY(BYTE **ptr, UINT32 *length, |
| TPM_DELEGATE_PUBLIC *v, UINT32 n) |
| { |
| UINT32 i; |
| for (i = 0; i < n; i++) { |
| if (tpm_marshal_TPM_DELEGATE_PUBLIC(ptr, length, &v[i])) return -1; |
| } |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_DELEGATE_PUBLIC_ARRAY(BYTE **ptr, UINT32 *length, |
| TPM_DELEGATE_PUBLIC *v, UINT32 n) |
| { |
| UINT32 i; |
| for (i = 0; i < n; i++) { |
| if (tpm_unmarshal_TPM_DELEGATE_PUBLIC(ptr, length, &v[i])) return -1; |
| } |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_DELEGATE_TABLE_ROW(BYTE **ptr, UINT32 *length, TPM_DELEGATE_TABLE_ROW *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_TPM_DELEGATE_PUBLIC(ptr, length, &v->pub) |
| || tpm_marshal_TPM_SECRET(ptr, length, &v->authValue)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_DELEGATE_TABLE_ROW(BYTE **ptr, UINT32 *length, TPM_DELEGATE_TABLE_ROW *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_TPM_DELEGATE_PUBLIC(ptr, length, &v->pub) |
| || tpm_unmarshal_TPM_SECRET(ptr, length, &v->authValue)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_DELEGATE_SENSITIVE(BYTE **ptr, UINT32 *length, TPM_DELEGATE_SENSITIVE *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_TPM_SECRET(ptr, length, &v->authValue)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_DELEGATE_SENSITIVE(BYTE **ptr, UINT32 *length, TPM_DELEGATE_SENSITIVE *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_TPM_SECRET(ptr, length, &v->authValue)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_DELEGATE_OWNER_BLOB(BYTE **ptr, UINT32 *length, TPM_DELEGATE_OWNER_BLOB *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_TPM_DELEGATE_PUBLIC(ptr, length, &v->pub) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->integrityDigest) |
| || tpm_marshal_UINT32(ptr, length, v->additionalSize) |
| || tpm_marshal_BLOB(ptr, length, v->additionalArea, v->additionalSize) |
| || tpm_marshal_UINT32(ptr, length, v->sensitiveSize) |
| || tpm_marshal_BLOB(ptr, length, v->sensitiveArea, v->sensitiveSize)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_DELEGATE_OWNER_BLOB(BYTE **ptr, UINT32 *length, TPM_DELEGATE_OWNER_BLOB *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_TPM_DELEGATE_PUBLIC(ptr, length, &v->pub) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->integrityDigest) |
| || tpm_unmarshal_UINT32(ptr, length, &v->additionalSize) |
| || tpm_unmarshal_BLOB(ptr, length, &v->additionalArea, v->additionalSize) |
| || tpm_unmarshal_UINT32(ptr, length, &v->sensitiveSize) |
| || tpm_unmarshal_BLOB(ptr, length, &v->sensitiveArea, v->sensitiveSize)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_DELEGATE_KEY_BLOB(BYTE **ptr, UINT32 *length, TPM_DELEGATE_KEY_BLOB *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_TPM_DELEGATE_PUBLIC(ptr, length, &v->pub) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->integrityDigest) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->pubKeyDigest) |
| || tpm_marshal_UINT32(ptr, length, v->additionalSize) |
| || tpm_marshal_BLOB(ptr, length, v->additionalArea, v->additionalSize) |
| || tpm_marshal_UINT32(ptr, length, v->sensitiveSize) |
| || tpm_marshal_BLOB(ptr, length, v->sensitiveArea, v->sensitiveSize)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_DELEGATE_KEY_BLOB(BYTE **ptr, UINT32 *length, TPM_DELEGATE_KEY_BLOB *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_TPM_DELEGATE_PUBLIC(ptr, length, &v->pub) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->integrityDigest) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->pubKeyDigest) |
| || tpm_unmarshal_UINT32(ptr, length, &v->additionalSize) |
| || tpm_unmarshal_BLOB(ptr, length, &v->additionalArea, v->additionalSize) |
| || tpm_unmarshal_UINT32(ptr, length, &v->sensitiveSize) |
| || tpm_unmarshal_BLOB(ptr, length, &v->sensitiveArea, v->sensitiveSize)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_PERMANENT_FLAGS(BYTE **ptr, UINT32 *length, TPM_PERMANENT_FLAGS *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_BOOL(ptr, length, v->disable) |
| || tpm_marshal_BOOL(ptr, length, v->ownership) |
| || tpm_marshal_BOOL(ptr, length, v->deactivated) |
| || tpm_marshal_BOOL(ptr, length, v->readPubek) |
| || tpm_marshal_BOOL(ptr, length, v->disableOwnerClear) |
| || tpm_marshal_BOOL(ptr, length, v->allowMaintenance) |
| || tpm_marshal_BOOL(ptr, length, v->physicalPresenceLifetimeLock) |
| || tpm_marshal_BOOL(ptr, length, v->physicalPresenceHWEnable) |
| || tpm_marshal_BOOL(ptr, length, v->physicalPresenceCMDEnable) |
| || tpm_marshal_BOOL(ptr, length, v->CEKPUsed) |
| || tpm_marshal_BOOL(ptr, length, v->TPMpost) |
| || tpm_marshal_BOOL(ptr, length, v->TPMpostLock) |
| || tpm_marshal_BOOL(ptr, length, v->FIPS) |
| || tpm_marshal_BOOL(ptr, length, v->operator) |
| || tpm_marshal_BOOL(ptr, length, v->enableRevokeEK) |
| || tpm_marshal_BOOL(ptr, length, v->nvLocked) |
| || tpm_marshal_BOOL(ptr, length, v->readSRKPub) |
| || tpm_marshal_BOOL(ptr, length, v->tpmEstablished) |
| || tpm_marshal_BOOL(ptr, length, v->maintenanceDone) |
| || tpm_marshal_BOOL(ptr, length, v->disableFullDALogicInfo)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_PERMANENT_FLAGS(BYTE **ptr, UINT32 *length, TPM_PERMANENT_FLAGS *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_BOOL(ptr, length, &v->disable) |
| || tpm_unmarshal_BOOL(ptr, length, &v->ownership) |
| || tpm_unmarshal_BOOL(ptr, length, &v->deactivated) |
| || tpm_unmarshal_BOOL(ptr, length, &v->readPubek) |
| || tpm_unmarshal_BOOL(ptr, length, &v->disableOwnerClear) |
| || tpm_unmarshal_BOOL(ptr, length, &v->allowMaintenance) |
| || tpm_unmarshal_BOOL(ptr, length, &v->physicalPresenceLifetimeLock) |
| || tpm_unmarshal_BOOL(ptr, length, &v->physicalPresenceHWEnable) |
| || tpm_unmarshal_BOOL(ptr, length, &v->physicalPresenceCMDEnable) |
| || tpm_unmarshal_BOOL(ptr, length, &v->CEKPUsed) |
| || tpm_unmarshal_BOOL(ptr, length, &v->TPMpost) |
| || tpm_unmarshal_BOOL(ptr, length, &v->TPMpostLock) |
| || tpm_unmarshal_BOOL(ptr, length, &v->FIPS) |
| || tpm_unmarshal_BOOL(ptr, length, &v->operator) |
| || tpm_unmarshal_BOOL(ptr, length, &v->enableRevokeEK) |
| || tpm_unmarshal_BOOL(ptr, length, &v->nvLocked) |
| || tpm_unmarshal_BOOL(ptr, length, &v->readSRKPub) |
| || tpm_unmarshal_BOOL(ptr, length, &v->tpmEstablished) |
| || tpm_unmarshal_BOOL(ptr, length, &v->maintenanceDone) |
| || tpm_unmarshal_BOOL(ptr, length, &v->disableFullDALogicInfo)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_STCLEAR_FLAGS(BYTE **ptr, UINT32 *length, TPM_STCLEAR_FLAGS *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_BOOL(ptr, length, v->deactivated) |
| || tpm_marshal_BOOL(ptr, length, v->disableForceClear) |
| || tpm_marshal_BOOL(ptr, length, v->physicalPresence) |
| || tpm_marshal_BOOL(ptr, length, v->physicalPresenceLock) |
| || tpm_marshal_BOOL(ptr, length, v->bGlobalLock)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_STCLEAR_FLAGS(BYTE **ptr, UINT32 *length, TPM_STCLEAR_FLAGS *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_BOOL(ptr, length, &v->deactivated) |
| || tpm_unmarshal_BOOL(ptr, length, &v->disableForceClear) |
| || tpm_unmarshal_BOOL(ptr, length, &v->physicalPresence) |
| || tpm_unmarshal_BOOL(ptr, length, &v->physicalPresenceLock) |
| || tpm_unmarshal_BOOL(ptr, length, &v->bGlobalLock)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_STANY_FLAGS(BYTE **ptr, UINT32 *length, TPM_STANY_FLAGS *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_BOOL(ptr, length, v->postInitialise) |
| || tpm_marshal_UINT32(ptr, length, v->localityModifier) |
| || tpm_marshal_BOOL(ptr, length, v->transportExclusive) |
| || tpm_marshal_BOOL(ptr, length, v->TOSPresent)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_STANY_FLAGS(BYTE **ptr, UINT32 *length, TPM_STANY_FLAGS *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_BOOL(ptr, length, &v->postInitialise) |
| || tpm_unmarshal_UINT32(ptr, length, &v->localityModifier) |
| || tpm_unmarshal_BOOL(ptr, length, &v->transportExclusive) |
| || tpm_unmarshal_BOOL(ptr, length, &v->TOSPresent)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_RSA(BYTE **ptr, UINT32 *length, tpm_rsa_private_key_t *v) |
| { |
| size_t m_len, e_len, q_len; |
| if (*length < (UINT32)sizeof_RSA((*v))) return -1; |
| if (v->size > 0) { |
| tpm_rsa_export_modulus(v, &(*ptr)[6], &m_len); |
| tpm_rsa_export_exponent(v, &(*ptr)[6+m_len], &e_len); |
| tpm_rsa_export_prime1(v, &(*ptr)[6+m_len+e_len], &q_len); |
| tpm_marshal_UINT16(ptr, length, m_len); |
| tpm_marshal_UINT16(ptr, length, e_len); |
| tpm_marshal_UINT16(ptr, length, q_len); |
| *ptr += m_len + e_len + q_len; |
| *length -= m_len + e_len + q_len; |
| } else { |
| tpm_marshal_UINT16(ptr, length, 0); |
| tpm_marshal_UINT16(ptr, length, 0); |
| tpm_marshal_UINT16(ptr, length, 0); |
| } |
| return 0; |
| } |
| |
| int tpm_unmarshal_RSA(BYTE **ptr, UINT32 *length, tpm_rsa_private_key_t *v) |
| { |
| UINT16 m_len, e_len, q_len; |
| if (tpm_unmarshal_UINT16(ptr, length, &m_len) |
| || tpm_unmarshal_UINT16(ptr, length, &e_len) |
| || tpm_unmarshal_UINT16(ptr, length, &q_len)) return -1; |
| if (m_len == 0) { |
| v->size = 0; |
| return 0; |
| } |
| if (*length < (UINT32)m_len + (UINT32)e_len + (UINT32)q_len |
| || q_len != m_len/2 |
| || tpm_rsa_import_key(v, RSA_MSB_FIRST, |
| &(*ptr)[0], m_len, |
| &(*ptr)[m_len], e_len, |
| &(*ptr)[m_len+e_len], NULL)) return -1; |
| *ptr += m_len + e_len + q_len; |
| *length -= m_len + e_len + q_len; |
| return 0; |
| } |
| |
| int tpm_marshal_RSAPub(BYTE **ptr, UINT32 *length, tpm_rsa_public_key_t *v) |
| { |
| size_t m_len, e_len; |
| if (*length < (UINT32)sizeof_RSAPub((*v))) return -1; |
| if (v->size > 0) { |
| tpm_rsa_export_public_modulus(v, &(*ptr)[4], &m_len); |
| tpm_rsa_export_public_exponent(v, &(*ptr)[4+m_len], &e_len); |
| tpm_marshal_UINT16(ptr, length, m_len); |
| tpm_marshal_UINT16(ptr, length, e_len); |
| *ptr += m_len + e_len; |
| *length -= m_len + e_len; |
| } else { |
| tpm_marshal_UINT16(ptr, length, 0); |
| tpm_marshal_UINT16(ptr, length, 0); |
| } |
| return 0; |
| } |
| |
| int tpm_unmarshal_RSAPub(BYTE **ptr, UINT32 *length, tpm_rsa_public_key_t *v) |
| { |
| UINT16 m_len, e_len; |
| if (tpm_unmarshal_UINT16(ptr, length, &m_len) |
| || tpm_unmarshal_UINT16(ptr, length, &e_len)) return -1; |
| if (m_len == 0) { |
| v->size = 0; |
| return 0; |
| } |
| if (*length < (UINT32)m_len + (UINT32)e_len |
| || tpm_rsa_import_public_key(v, RSA_MSB_FIRST, &(*ptr)[0], m_len, |
| &(*ptr)[m_len], e_len)) return -1; |
| *ptr += m_len + e_len; |
| *length -= m_len + e_len; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_KEY_DATA(BYTE **ptr, UINT32 *length, TPM_KEY_DATA *v) |
| { |
| if (tpm_marshal_TPM_PAYLOAD_TYPE(ptr, length, v->payload)) return -1; |
| if (v->payload) { |
| if (tpm_marshal_TPM_KEY_USAGE(ptr, length, v->keyUsage) |
| || tpm_marshal_TPM_KEY_FLAGS(ptr, length, v->keyFlags) |
| || tpm_marshal_TPM_KEY_CONTROL(ptr, length, v->keyControl) |
| || tpm_marshal_TPM_AUTH_DATA_USAGE(ptr, length, v->authDataUsage) |
| || tpm_marshal_TPM_ENC_SCHEME(ptr, length, v->encScheme) |
| || tpm_marshal_TPM_SIG_SCHEME(ptr, length, v->sigScheme) |
| || tpm_marshal_TPM_SECRET(ptr, length, &v->usageAuth) |
| || tpm_marshal_TPM_SECRET(ptr, length, &v->migrationAuth) |
| || (v->keyFlags & TPM_KEY_FLAG_HAS_PCR |
| && tpm_marshal_TPM_PCR_INFO(ptr, length, &v->pcrInfo)) |
| || tpm_marshal_BOOL(ptr, length, v->parentPCRStatus) |
| || tpm_marshal_RSA(ptr, length, &v->key)) return -1; |
| } |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_KEY_DATA(BYTE **ptr, UINT32 *length, TPM_KEY_DATA *v) |
| { |
| if (tpm_unmarshal_TPM_PAYLOAD_TYPE(ptr, length, &v->payload)) return -1; |
| if (v->payload) { |
| if (tpm_unmarshal_TPM_KEY_USAGE(ptr, length, &v->keyUsage) |
| || tpm_unmarshal_TPM_KEY_FLAGS(ptr, length, &v->keyFlags) |
| || tpm_unmarshal_TPM_KEY_CONTROL(ptr, length, &v->keyControl) |
| || tpm_unmarshal_TPM_AUTH_DATA_USAGE(ptr, length, &v->authDataUsage) |
| || tpm_unmarshal_TPM_ENC_SCHEME(ptr, length, &v->encScheme) |
| || tpm_unmarshal_TPM_SIG_SCHEME(ptr, length, &v->sigScheme) |
| || tpm_unmarshal_TPM_SECRET(ptr, length, &v->usageAuth) |
| || tpm_unmarshal_TPM_SECRET(ptr, length, &v->migrationAuth) |
| || (v->keyFlags & TPM_KEY_FLAG_HAS_PCR |
| && tpm_unmarshal_TPM_PCR_INFO(ptr, length, &v->pcrInfo)) |
| || tpm_unmarshal_BOOL(ptr, length, &v->parentPCRStatus) |
| || tpm_unmarshal_RSA(ptr, length, &v->key)) return -1; |
| } |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_PUBKEY_DATA(BYTE **ptr, UINT32 *length, TPM_PUBKEY_DATA *v) |
| { |
| if (tpm_marshal_BOOL(ptr, length, v->valid)) return -1; |
| if (v->valid) { |
| if (tpm_marshal_TPM_ENC_SCHEME(ptr, length, v->encScheme) |
| || tpm_marshal_TPM_SIG_SCHEME(ptr, length, v->sigScheme) |
| || tpm_marshal_RSAPub(ptr, length, &v->key)) return -1; |
| } |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_PUBKEY_DATA(BYTE **ptr, UINT32 *length, TPM_PUBKEY_DATA *v) |
| { |
| if (tpm_unmarshal_BOOL(ptr, length, &v->valid)) return -1; |
| if (v->valid) { |
| if (tpm_unmarshal_TPM_ENC_SCHEME(ptr, length, &v->encScheme) |
| || tpm_unmarshal_TPM_SIG_SCHEME(ptr, length, &v->sigScheme) |
| || tpm_unmarshal_RSAPub(ptr, length, &v->key)) return -1; |
| } |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_PERMANENT_DATA(BYTE **ptr, UINT32 *length, TPM_PERMANENT_DATA *v) |
| { |
| UINT32 i; |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_TPM_VERSION(ptr, length, &v->version) |
| || tpm_marshal_TPM_NONCE(ptr, length, &v->tpmProof) |
| || tpm_marshal_TPM_NONCE(ptr, length, &v->ekReset) |
| || tpm_marshal_TPM_SECRET(ptr, length, &v->ownerAuth) |
| || tpm_marshal_TPM_SECRET(ptr, length, &v->operatorAuth) |
| || tpm_marshal_TPM_NONCE(ptr, length, &v->tpmDAASeed) |
| || tpm_marshal_TPM_NONCE(ptr, length, &v->daaProof) |
| || tpm_marshal_TPM_PUBKEY_DATA(ptr, length, &v->manuMaintPub) |
| || tpm_marshal_RSA(ptr, length, &v->endorsementKey) |
| || tpm_marshal_TPM_KEY_DATA(ptr, length, &v->srk) |
| || tpm_marshal_BYTE_ARRAY(ptr, length, v->contextKey, sizeof(v->contextKey)) |
| || tpm_marshal_BYTE_ARRAY(ptr, length, v->delegateKey, sizeof(v->contextKey)) |
| || tpm_marshal_BYTE_ARRAY(ptr, length, v->daaKey, sizeof(v->contextKey)) |
| || tpm_marshal_TPM_ACTUAL_COUNT(ptr, length, v->auditMonotonicCounter)) return -1; |
| for (i = 0; i < TPM_MAX_COUNTERS; i++) { |
| if (tpm_marshal_TPM_COUNTER_VALUE(ptr, length, &v->counters[i]) |
| || tpm_marshal_TPM_SECRET(ptr, length, &v->counters[i].usageAuth) |
| || tpm_marshal_BOOL(ptr, length, v->counters[i].valid)) return -1; |
| } |
| for (i = 0; i < TPM_NUM_PCR; i++) { |
| if (tpm_marshal_TPM_PCR_ATTRIBUTES(ptr, length, &v->pcrAttrib[i])) return -1; |
| } |
| for (i = 0; i < TPM_NUM_PCR; i++) { |
| if (tpm_marshal_TPM_PCRVALUE(ptr, length, &v->pcrValue[i])) return -1; |
| } |
| if (tpm_marshal_BYTE_ARRAY(ptr, length, v->ordinalAuditStatus, sizeof(v->ordinalAuditStatus)) |
| || tpm_marshal_BYTE_ARRAY(ptr, length, v->rngState, sizeof(v->rngState))) return -1; |
| for (i = 0; i < TPM_NUM_FAMILY_TABLE_ENTRY; i++) { |
| if (tpm_marshal_BOOL(ptr, length, v->familyTable.famRow[i].valid)) return -1; |
| if (v->familyTable.famRow[i].valid) { |
| if (tpm_marshal_TPM_FAMILY_TABLE_ENTRY(ptr, length, &v->familyTable.famRow[i])) return -1; |
| } |
| } |
| for (i = 0; i < TPM_NUM_DELEGATE_TABLE_ENTRY; i++) { |
| if (tpm_marshal_BOOL(ptr, length, v->delegateTable.delRow[i].valid)) return -1; |
| if (v->delegateTable.delRow[i].valid) { |
| if (tpm_marshal_TPM_DELEGATE_TABLE_ROW(ptr, length, &v->delegateTable.delRow[i])) return -1; |
| } |
| } |
| if (tpm_marshal_UINT32(ptr, length, v->lastFamilyID) |
| || tpm_marshal_TPM_CMK_DELEGATE(ptr, length, v->restrictDelegate) |
| || tpm_marshal_UINT32(ptr, length, v->maxNVBufSize) |
| || tpm_marshal_UINT32(ptr, length, v->noOwnerNVWrite) |
| || tpm_marshal_UINT32(ptr, length, v->nvDataSize) |
| || tpm_marshal_BYTE_ARRAY(ptr, length, v->nvData, sizeof(v->nvData))) return -1; |
| for (i = 0; i < TPM_MAX_NVS; i++) { |
| if (tpm_marshal_BOOL(ptr, length, v->nvStorage[i].valid)) return -1; |
| if (v->nvStorage[i].valid) { |
| if (tpm_marshal_TPM_NV_DATA_SENSITIVE(ptr, length, &v->nvStorage[i])) return -1; |
| } |
| } |
| for (i = 0; i < TPM_MAX_KEYS; i++) { |
| if (tpm_marshal_TPM_KEY_DATA(ptr, length, &v->keys[i])) return -1; |
| } |
| if (tpm_marshal_UINT32_ARRAY(ptr, length, v->tis_timeouts, TPM_NUM_TIS_TIMEOUTS) |
| || tpm_marshal_UINT32_ARRAY(ptr, length, v->cmd_durations, TPM_NUM_CMD_DURATIONS)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_PERMANENT_DATA(BYTE **ptr, UINT32 *length, TPM_PERMANENT_DATA *v) |
| { |
| UINT32 i; |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_TPM_VERSION(ptr, length, &v->version) |
| || tpm_unmarshal_TPM_NONCE(ptr, length, &v->tpmProof) |
| || tpm_unmarshal_TPM_NONCE(ptr, length, &v->ekReset) |
| || tpm_unmarshal_TPM_SECRET(ptr, length, &v->ownerAuth) |
| || tpm_unmarshal_TPM_SECRET(ptr, length, &v->operatorAuth) |
| || tpm_unmarshal_TPM_NONCE(ptr, length, &v->tpmDAASeed) |
| || tpm_unmarshal_TPM_NONCE(ptr, length, &v->daaProof) |
| || tpm_unmarshal_TPM_PUBKEY_DATA(ptr, length, &v->manuMaintPub) |
| || tpm_unmarshal_RSA(ptr, length, &v->endorsementKey) |
| || tpm_unmarshal_TPM_KEY_DATA(ptr, length, &v->srk) |
| || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->contextKey, sizeof(v->contextKey)) |
| || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->delegateKey, sizeof(v->contextKey)) |
| || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->daaKey, sizeof(v->contextKey)) |
| || tpm_unmarshal_TPM_ACTUAL_COUNT(ptr, length, &v->auditMonotonicCounter)) return -1; |
| for (i = 0; i < TPM_MAX_COUNTERS; i++) { |
| if (tpm_unmarshal_TPM_COUNTER_VALUE(ptr, length, &v->counters[i]) |
| || tpm_unmarshal_TPM_SECRET(ptr, length, &v->counters[i].usageAuth) |
| || tpm_unmarshal_BOOL(ptr, length, &v->counters[i].valid)) return -1; |
| } |
| for (i = 0; i < TPM_NUM_PCR; i++) { |
| if (tpm_unmarshal_TPM_PCR_ATTRIBUTES(ptr, length, &v->pcrAttrib[i])) return -1; |
| } |
| for (i = 0; i < TPM_NUM_PCR; i++) { |
| if (tpm_unmarshal_TPM_PCRVALUE(ptr, length, &v->pcrValue[i])) return -1; |
| } |
| if (tpm_unmarshal_BYTE_ARRAY(ptr, length, v->ordinalAuditStatus, sizeof(v->ordinalAuditStatus)) |
| || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->rngState, sizeof(v->rngState))) return -1; |
| for (i = 0; i < TPM_NUM_FAMILY_TABLE_ENTRY; i++) { |
| if (tpm_unmarshal_BOOL(ptr, length, &v->familyTable.famRow[i].valid)) return -1; |
| if (v->familyTable.famRow[i].valid) { |
| if (tpm_unmarshal_TPM_FAMILY_TABLE_ENTRY(ptr, length, &v->familyTable.famRow[i])) return -1; |
| } |
| } |
| for (i = 0; i < TPM_NUM_DELEGATE_TABLE_ENTRY; i++) { |
| if (tpm_unmarshal_BOOL(ptr, length, &v->delegateTable.delRow[i].valid)) return -1; |
| if (v->delegateTable.delRow[i].valid) { |
| if (tpm_unmarshal_TPM_DELEGATE_TABLE_ROW(ptr, length, &v->delegateTable.delRow[i])) return -1; |
| } |
| } |
| if (tpm_unmarshal_UINT32(ptr, length, &v->lastFamilyID) |
| || tpm_unmarshal_TPM_CMK_DELEGATE(ptr, length, &v->restrictDelegate) |
| || tpm_unmarshal_UINT32(ptr, length, &v->maxNVBufSize) |
| || tpm_unmarshal_UINT32(ptr, length, &v->noOwnerNVWrite) |
| || tpm_unmarshal_UINT32(ptr, length, &v->nvDataSize) |
| || tpm_unmarshal_BYTE_ARRAY(ptr, length, v->nvData, sizeof(v->nvData))) return -1; |
| for (i = 0; i < TPM_MAX_NVS; i++) { |
| if (tpm_unmarshal_BOOL(ptr, length, &v->nvStorage[i].valid)) return -1; |
| if (v->nvStorage[i].valid) { |
| if (tpm_unmarshal_TPM_NV_DATA_SENSITIVE(ptr, length, &v->nvStorage[i])) return -1; |
| } |
| } |
| for (i = 0; i < TPM_MAX_KEYS; i++) { |
| if (tpm_unmarshal_TPM_KEY_DATA(ptr, length, &v->keys[i])) return -1; |
| } |
| if (tpm_unmarshal_UINT32_ARRAY(ptr, length, v->tis_timeouts, TPM_NUM_TIS_TIMEOUTS) |
| || tpm_unmarshal_UINT32_ARRAY(ptr, length, v->cmd_durations, TPM_NUM_CMD_DURATIONS)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v) |
| { |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_TPM_NONCE(ptr, length, &v->contextNonceKey) |
| || tpm_marshal_TPM_COUNT_ID(ptr, length, v->countID) |
| || tpm_marshal_UINT32(ptr, length, v->ownerReference) |
| || tpm_marshal_BOOL(ptr, length, v->disableResetLock) |
| || tpm_marshal_UINT32(ptr, length, v->deferredPhysicalPresence)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v) |
| { |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_TPM_NONCE(ptr, length, &v->contextNonceKey) |
| || tpm_unmarshal_TPM_COUNT_ID(ptr, length, &v->countID) |
| || tpm_unmarshal_UINT32(ptr, length, &v->ownerReference) |
| || tpm_unmarshal_BOOL(ptr, length, &v->disableResetLock) |
| || tpm_unmarshal_UINT32(ptr, length, &v->deferredPhysicalPresence)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_SESSION_DATA *v) |
| { |
| if (tpm_marshal_BYTE(ptr, length, v->type) |
| || tpm_marshal_TPM_NONCE(ptr, length, &v->nonceEven) |
| || tpm_marshal_TPM_NONCE(ptr, length, &v->lastNonceEven) |
| || tpm_marshal_TPM_SECRET(ptr, length, &v->sharedSecret) |
| || tpm_marshal_TPM_HANDLE(ptr, length, v->handle) |
| || tpm_marshal_TPM_ENTITY_TYPE(ptr, length, v->entityType) |
| || (v->type == TPM_ST_DSAP |
| && (tpm_marshal_TPM_DELEGATIONS(ptr, length, &v->permissions) |
| || tpm_marshal_TPM_FAMILY_ID(ptr, length, v->familyID))) |
| || (v->type == TPM_ST_TRANSPORT |
| && tpm_marshal_TPM_TRANSPORT_INTERNAL(ptr, length, &v->transInternal))) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_SESSION_DATA *v) |
| { |
| if (tpm_unmarshal_BYTE(ptr, length, &v->type) |
| || tpm_unmarshal_TPM_NONCE(ptr, length, &v->nonceEven) |
| || tpm_unmarshal_TPM_NONCE(ptr, length, &v->lastNonceEven) |
| || tpm_unmarshal_TPM_SECRET(ptr, length, &v->sharedSecret) |
| || tpm_unmarshal_TPM_HANDLE(ptr, length, &v->handle) |
| || tpm_unmarshal_TPM_ENTITY_TYPE(ptr, length, &v->entityType) |
| || (v->type == TPM_ST_DSAP |
| && (tpm_unmarshal_TPM_DELEGATIONS(ptr, length, &v->permissions) |
| || tpm_unmarshal_TPM_FAMILY_ID(ptr, length, &v->familyID))) |
| || (v->type == TPM_ST_TRANSPORT |
| && tpm_unmarshal_TPM_TRANSPORT_INTERNAL(ptr, length, &v->transInternal))) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v) |
| { |
| UINT32 i; |
| if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag) |
| || tpm_marshal_TPM_NONCE(ptr, length, &v->contextNonceSession) |
| || tpm_marshal_TPM_DIGEST(ptr, length, &v->auditDigest) |
| || tpm_marshal_BOOL(ptr, length, v->auditSession) |
| || tpm_marshal_TPM_CURRENT_TICKS(ptr, length, &v->currentTicks) |
| || tpm_marshal_UINT32(ptr, length, v->contextCount) |
| || tpm_marshal_UINT32_ARRAY(ptr, length, v->contextList, TPM_MAX_SESSION_LIST)) return -1; |
| for (i = 0; i < TPM_MAX_SESSIONS; i++) { |
| if (tpm_marshal_TPM_SESSION_DATA(ptr, length, &v->sessions[i])) return -1; |
| } |
| for (i = 0; i < TPM_MAX_SESSIONS_DAA; i++) { |
| if (tpm_marshal_TPM_DAA_SESSION_DATA(ptr, length, &v->sessionsDAA[i])) return -1; |
| } |
| if (tpm_marshal_DAAHANDLE(ptr, length, v->currentDAA) |
| || tpm_marshal_TPM_TRANSHANDLE(ptr, length, v->transExclusive)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_STANY_DATA(BYTE **ptr, UINT32 *length, TPM_STANY_DATA *v) |
| { |
| UINT32 i; |
| if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_TPM_NONCE(ptr, length, &v->contextNonceSession) |
| || tpm_unmarshal_TPM_DIGEST(ptr, length, &v->auditDigest) |
| || tpm_unmarshal_BOOL(ptr, length, &v->auditSession) |
| || tpm_unmarshal_TPM_CURRENT_TICKS(ptr, length, &v->currentTicks) |
| || tpm_unmarshal_UINT32(ptr, length, &v->contextCount) |
| || tpm_unmarshal_UINT32_ARRAY(ptr, length, v->contextList, TPM_MAX_SESSION_LIST)) return -1; |
| for (i = 0; i < TPM_MAX_SESSIONS; i++) { |
| if (tpm_unmarshal_TPM_SESSION_DATA(ptr, length, &v->sessions[i])) return -1; |
| } |
| for (i = 0; i < TPM_MAX_SESSIONS_DAA; i++) { |
| if (tpm_unmarshal_TPM_DAA_SESSION_DATA(ptr, length, &v->sessionsDAA[i])) return -1; |
| } |
| if (tpm_unmarshal_DAAHANDLE(ptr, length, &v->currentDAA) |
| || tpm_unmarshal_TPM_TRANSHANDLE(ptr, length, &v->transExclusive)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_DATA(BYTE **ptr, UINT32 *length, TPM_DATA *v) |
| { |
| if (tpm_marshal_TPM_PERMANENT_FLAGS(ptr, length, &v->permanent.flags) |
| || tpm_marshal_BOOL(ptr, length, v->permanent.flags.selfTestSucceeded) |
| || tpm_marshal_BOOL(ptr, length, v->permanent.flags.owned) |
| || tpm_marshal_TPM_PERMANENT_DATA(ptr, length, &v->permanent.data) |
| || tpm_marshal_TPM_STCLEAR_FLAGS(ptr, length, &v->stclear.flags) |
| || tpm_marshal_TPM_STCLEAR_DATA(ptr, length, &v->stclear.data) |
| || tpm_marshal_TPM_STANY_DATA(ptr, length, &v->stany.data)) return -1; |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_DATA(BYTE **ptr, UINT32 *length, TPM_DATA *v) |
| { |
| if (tpm_unmarshal_TPM_PERMANENT_FLAGS(ptr, length, &v->permanent.flags) |
| || tpm_unmarshal_BOOL(ptr, length, &v->permanent.flags.selfTestSucceeded) |
| || tpm_unmarshal_BOOL(ptr, length, &v->permanent.flags.owned) |
| || tpm_unmarshal_TPM_PERMANENT_DATA(ptr, length, &v->permanent.data) |
| || tpm_unmarshal_TPM_STCLEAR_FLAGS(ptr, length, &v->stclear.flags) |
| || tpm_unmarshal_TPM_STCLEAR_DATA(ptr, length, &v->stclear.data) |
| || tpm_unmarshal_TPM_STANY_DATA(ptr, length, &v->stany.data)) return -1; |
| return 0; |
| } |
| |
| int tpm_marshal_TPM_RESPONSE(BYTE **ptr, UINT32 *length, TPM_RESPONSE *v) |
| { |
| if (tpm_marshal_TPM_TAG(ptr, length, v->tag) |
| || tpm_marshal_UINT32(ptr, length, v->size) |
| || tpm_marshal_TPM_RESULT(ptr, length, v->result) |
| || tpm_marshal_BLOB(ptr, length, v->param, v->paramSize)) return -1; |
| if (v->tag == TPM_TAG_RSP_AUTH2_COMMAND) { |
| if (tpm_marshal_TPM_AUTH(ptr, length, v->auth1) |
| || tpm_marshal_TPM_AUTH(ptr, length, v->auth2)) return -1; |
| } else if (v->tag == TPM_TAG_RSP_AUTH1_COMMAND) { |
| if (tpm_marshal_TPM_AUTH(ptr, length, v->auth1)) return -1; |
| } |
| return 0; |
| } |
| |
| int tpm_unmarshal_TPM_REQUEST(BYTE **ptr, UINT32 *length, TPM_REQUEST *v) |
| { |
| if (tpm_unmarshal_TPM_TAG(ptr, length, &v->tag) |
| || tpm_unmarshal_UINT32(ptr, length, &v->size) |
| || tpm_unmarshal_TPM_COMMAND_CODE(ptr, length, &v->ordinal)) return -1; |
| v->param = *ptr; |
| v->paramSize = *length; |
| if (v->tag == TPM_TAG_RQU_AUTH2_COMMAND) { |
| if (*length < 2 * 45) return -1; |
| v->paramSize = *length - 2 * 45; |
| if (tpm_unmarshal_BLOB(ptr, length, &v->param, v->paramSize) |
| || tpm_unmarshal_TPM_AUTH(ptr, length, &v->auth1) |
| || tpm_unmarshal_TPM_AUTH(ptr, length, &v->auth2)) return -1; |
| v->auth1.ordinal = v->ordinal; |
| v->auth2.ordinal = v->ordinal; |
| } else if (v->tag == TPM_TAG_RQU_AUTH1_COMMAND) { |
| if (*length < 45) return -1; |
| v->paramSize = *length - 45; |
| if (tpm_unmarshal_BLOB(ptr, length, &v->param, v->paramSize) |
| || tpm_unmarshal_TPM_AUTH(ptr, length, &v->auth1)) return -1; |
| v->auth1.ordinal = v->ordinal; |
| v->auth2.authHandle = TPM_INVALID_HANDLE; |
| } else { |
| v->auth1.authHandle = TPM_INVALID_HANDLE; |
| v->auth2.authHandle = TPM_INVALID_HANDLE; |
| } |
| return 0; |
| } |