Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
home:olh:xen-4.9
xen
xen.c4ba064d53ef89cc06466349c1e987d8e91020b3.patch
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File xen.c4ba064d53ef89cc06466349c1e987d8e91020b3.patch of Package xen
From: Olaf Hering <olaf@aepfle.de> Date: Fri, 23 Jun 2017 19:35:04 +0200 Subject: c4ba064d53ef89cc06466349c1e987d8e91020b3 vtpmmgr: make inline functions static gcc7 is more strict with functions marked as inline. They are not automatically inlined. Instead a function call is generated, but the actual code is not visible by the linker. Do a mechanical change and mark every 'inline' as 'static inline'. For simpler review the static goes into an extra line. Signed-off-by: Olaf Hering <olaf@aepfle.de> Tested-by: Wei Liu <wei.liu2@citrix.com> Acked-by: Wei Liu <wei.liu2@citrix.com> --- stubdom/vtpmmgr/marshal.h | 76 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ stubdom/vtpmmgr/tcg.h | 14 ++++++++++++++ stubdom/vtpmmgr/tpm2_marshal.h | 58 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ stubdom/vtpmmgr/tpmrsa.h | 1 + 4 files changed, 149 insertions(+) --- a/stubdom/vtpmmgr/marshal.h +++ b/stubdom/vtpmmgr/marshal.h @@ -38,82 +38,91 @@ #define MARSHAL_H #include <stdlib.h> #include <mini-os/byteorder.h> #include <mini-os/endian.h> #include "tcg.h" typedef enum UnpackPtr { UNPACK_ALIAS, UNPACK_ALLOC } UnpackPtr; +static inline BYTE* pack_BYTE(BYTE* ptr, BYTE t) { ptr[0] = t; return ++ptr; } +static inline BYTE* unpack_BYTE(BYTE* ptr, BYTE* t) { t[0] = ptr[0]; return ++ptr; } +static inline int unpack3_BYTE(BYTE* ptr, UINT32* pos, UINT32 max, BYTE *t) { if (*pos + 1 > max) return TPM_SIZE; unpack_BYTE(ptr + *pos, t); *pos += 1; return 0; } #define pack_BOOL(p, t) pack_BYTE(p, t) #define unpack_BOOL(p, t) unpack_BYTE(p, t) #define unpack3_BOOL(p, x, m, t) unpack3_BYTE(p, x, m, t) #define sizeof_BOOL(t) 1 +static inline BYTE* pack_UINT16(void* ptr, UINT16 t) { UINT16* p = ptr; *p = cpu_to_be16(t); return ptr + sizeof(UINT16); } +static inline BYTE* unpack_UINT16(void* ptr, UINT16* t) { UINT16* p = ptr; *t = be16_to_cpu(*p); return ptr + sizeof(UINT16); } +static inline int unpack3_UINT16(BYTE* ptr, UINT32* pos, UINT32 max, UINT16 *t) { if (*pos + 2 > max) return TPM_SIZE; unpack_UINT16(ptr + *pos, t); *pos += 2; return 0; } +static inline BYTE* pack_UINT32(void* ptr, UINT32 t) { UINT32* p = ptr; *p = cpu_to_be32(t); return ptr + sizeof(UINT32); } +static inline BYTE* unpack_UINT32(void* ptr, UINT32* t) { UINT32* p = ptr; *t = be32_to_cpu(*p); return ptr + sizeof(UINT32); } +static inline int unpack3_UINT32(BYTE* ptr, UINT32* pos, UINT32 max, UINT32 *t) { if (*pos + 4 > max) return TPM_SIZE; unpack_UINT32(ptr + *pos, t); *pos += 4; return 0; } #define sizeof_BYTE(x) 1 #define sizeof_UINT16(x) 2 #define sizeof_UINT32(x) 4 @@ -227,88 +236,98 @@ inline int unpack3_UINT32(BYTE* ptr, UINT32* pos, UINT32 max, UINT32 *t) #define pack_TCS_CONTEXT_HANDLE(p, t) pack_UINT32(p, t) #define pack_TCS_KEY_HANDLE(p, t) pack_UINT32(p, t) #define unpack_TPM_AUTH_HANDLE(p, t) unpack_UINT32(p, t) #define unpack_TCS_CONTEXT_HANDLE(p, t) unpack_UINT32(p, t) #define unpack_TCS_KEY_HANDLE(p, t) unpack_UINT32(p, t) #define sizeof_TPM_AUTH_HANDLE(t) sizeof_UINT32(t) #define sizeof_TCS_CONTEXT_HANDLE(t) sizeof_UINT32(t) #define sizeof_TCS_KEY_HANDLE(t) sizeof_UINT32(t) +static inline BYTE* pack_BUFFER(BYTE* ptr, const BYTE* buf, UINT32 size) { memcpy(ptr, buf, size); return ptr + size; } +static inline BYTE* unpack_BUFFER(BYTE* ptr, BYTE* buf, UINT32 size) { memcpy(buf, ptr, size); return ptr + size; } +static inline int unpack3_BUFFER(BYTE* ptr, UINT32* pos, UINT32 max, BYTE* buf, UINT32 size) { if (*pos + size > max) return TPM_SIZE; memcpy(buf, ptr + *pos, size); *pos += size; return 0; } #define sizeof_BUFFER(b, s) s +static inline BYTE* unpack_ALIAS(BYTE* ptr, BYTE** buf, UINT32 size) { *buf = ptr; return ptr + size; } +static inline BYTE* unpack_ALLOC(BYTE* ptr, BYTE** buf, UINT32 size) { if(size) { *buf = malloc(size); memcpy(*buf, ptr, size); } else { *buf = NULL; } return ptr + size; } +static inline BYTE* unpack_PTR(BYTE* ptr, BYTE** buf, UINT32 size, UnpackPtr alloc) { if(alloc == UNPACK_ALLOC) { return unpack_ALLOC(ptr, buf, size); } else { return unpack_ALIAS(ptr, buf, size); } } +static inline int unpack3_PTR(BYTE* ptr, UINT32* pos, UINT32 max, BYTE** buf, UINT32 size, UnpackPtr alloc) { if (size > max || *pos + size > max) return TPM_SIZE; if (alloc == UNPACK_ALLOC) { unpack_ALLOC(ptr + *pos, buf, size); } else { unpack_ALIAS(ptr + *pos, buf, size); } *pos += size; return 0; } #define unpack3_VPTR(ptr, pos, max, buf, size, alloc) unpack3_PTR(ptr, pos, max, (void*)(buf), size, alloc) +static inline BYTE* pack_TPM_AUTHDATA(BYTE* ptr, const TPM_AUTHDATA* d) { return pack_BUFFER(ptr, *d, TPM_DIGEST_SIZE); } +static inline BYTE* unpack_TPM_AUTHDATA(BYTE* ptr, TPM_AUTHDATA* d) { return unpack_BUFFER(ptr, *d, TPM_DIGEST_SIZE); } +static inline int unpack3_TPM_AUTHDATA(BYTE* ptr, UINT32* pos, UINT32 len, TPM_AUTHDATA* d) { return unpack3_BUFFER(ptr, pos, len, *d, TPM_DIGEST_SIZE); } #define sizeof_TPM_AUTHDATA(d) TPM_DIGEST_SIZE #define pack_TPM_SECRET(p, t) pack_TPM_AUTHDATA(p, t) #define pack_TPM_ENCAUTH(p, t) pack_TPM_AUTHDATA(p, t) #define pack_TPM_PAYLOAD_TYPE(p, t) pack_BYTE(p, t) #define pack_TPM_TAG(p, t) pack_UINT16(p, t) #define pack_TPM_STRUCTURE_TAG(p, t) pack_UINT16(p, t) @@ -316,535 +335,592 @@ inline int unpack3_TPM_AUTHDATA(BYTE* ptr, UINT32* pos, UINT32 len, TPM_AUTHDATA #define unpack_TPM_ENCAUTH(p, t) unpack_TPM_AUTHDATA(p, t) #define unpack_TPM_PAYLOAD_TYPE(p, t) unpack_BYTE(p, t) #define unpack_TPM_TAG(p, t) unpack_UINT16(p, t) #define unpack_TPM_STRUCTURE_TAG(p, t) unpack_UINT16(p, t) #define unpack3_TPM_STRUCTURE_TAG(p, l, m, t) unpack3_UINT16(p, l, m, t) #define sizeof_TPM_SECRET(t) sizeof_TPM_AUTHDATA(t) #define sizeof_TPM_ENCAUTH(t) sizeof_TPM_AUTHDATA(t) #define sizeof_TPM_PAYLOAD_TYPE(t) sizeof_BYTE(t) #define sizeof_TPM_TAG(t) sizeof_UINT16(t) #define sizeof_TPM_STRUCTURE_TAG(t) sizeof_UINT16(t) +static inline BYTE* pack_TPM_VERSION(BYTE* ptr, const TPM_VERSION* t) { ptr[0] = t->major; ptr[1] = t->minor; ptr[2] = t->revMajor; ptr[3] = t->revMinor; return ptr + 4; } +static inline BYTE* unpack_TPM_VERSION(BYTE* ptr, TPM_VERSION* t) { t->major = ptr[0]; t->minor = ptr[1]; t->revMajor = ptr[2]; t->revMinor = ptr[3]; return ptr + 4; } +static inline int unpack3_TPM_VERSION(BYTE* ptr, UINT32 *pos, UINT32 max, TPM_VERSION* t) { if (*pos + 4 > max) return TPM_SIZE; ptr += *pos; t->major = ptr[0]; t->minor = ptr[1]; t->revMajor = ptr[2]; t->revMinor = ptr[3]; *pos += 4; return 0; } #define sizeof_TPM_VERSION(x) 4 +static inline BYTE* pack_TPM_CAP_VERSION_INFO(BYTE* ptr, const TPM_CAP_VERSION_INFO* v) { ptr = pack_TPM_STRUCTURE_TAG(ptr, v->tag); ptr = pack_TPM_VERSION(ptr, &v->version); ptr = pack_UINT16(ptr, v->specLevel); ptr = pack_BYTE(ptr, v->errataRev); ptr = pack_BUFFER(ptr, v->tpmVendorID, sizeof(v->tpmVendorID)); ptr = pack_UINT16(ptr, v->vendorSpecificSize); ptr = pack_BUFFER(ptr, v->vendorSpecific, v->vendorSpecificSize); return ptr; } +static inline BYTE* unpack_TPM_CAP_VERSION_INFO(BYTE* ptr, TPM_CAP_VERSION_INFO* v, UnpackPtr alloc) { ptr = unpack_TPM_STRUCTURE_TAG(ptr, &v->tag); ptr = unpack_TPM_VERSION(ptr, &v->version); ptr = unpack_UINT16(ptr, &v->specLevel); ptr = unpack_BYTE(ptr, &v->errataRev); ptr = unpack_BUFFER(ptr, v->tpmVendorID, sizeof(v->tpmVendorID)); ptr = unpack_UINT16(ptr, &v->vendorSpecificSize); ptr = unpack_PTR(ptr, &v->vendorSpecific, v->vendorSpecificSize, alloc); return ptr; } +static inline BYTE* pack_TPM_DIGEST(BYTE* ptr, const TPM_DIGEST* d) { return pack_BUFFER(ptr, d->digest, TPM_DIGEST_SIZE); } +static inline BYTE* unpack_TPM_DIGEST(BYTE* ptr, TPM_DIGEST* d) { return unpack_BUFFER(ptr, d->digest, TPM_DIGEST_SIZE); } +static inline int unpack3_TPM_DIGEST(BYTE* ptr, UINT32* pos, UINT32 max, TPM_DIGEST* d) { return unpack3_BUFFER(ptr, pos, max, d->digest, TPM_DIGEST_SIZE); } #define sizeof_TPM_DIGEST(d) TPM_DIGEST_SIZE #define pack_TPM_PCRVALUE(ptr, d) pack_TPM_DIGEST(ptr, d) #define unpack_TPM_PCRVALUE(ptr, d) unpack_TPM_DIGEST(ptr, d) #define unpack3_TPM_PCRVALUE(p...) unpack3_TPM_DIGEST(p) #define pack_TPM_COMPOSITE_HASH(ptr, d) pack_TPM_DIGEST(ptr, d) #define unpack_TPM_COMPOSITE_HASH(ptr, d) unpack_TPM_DIGEST(ptr, d) #define unpack3_TPM_COMPOSITE_HASH(ptr, p, m, d) unpack3_TPM_DIGEST(ptr, p, m, d) #define sizeof_TPM_COMPOSITE_HASH(d) TPM_DIGEST_SIZE #define pack_TPM_DIRVALUE(ptr, d) pack_TPM_DIGEST(ptr, d) #define unpack_TPM_DIRVALUE(ptr, d) unpack_TPM_DIGEST(ptr, d) #define pack_TPM_HMAC(ptr, d) pack_TPM_DIGEST(ptr, d) #define unpack_TPM_HMAC(ptr, d) unpack_TPM_DIGEST(ptr, d) #define pack_TPM_CHOSENID_HASH(ptr, d) pack_TPM_DIGEST(ptr, d) #define unpack_TPM_CHOSENID_HASH(ptr, d) unpack_TPM_DIGEST(ptr, d) +static inline BYTE* pack_TPM_NONCE(BYTE* ptr, const TPM_NONCE* n) { return pack_BUFFER(ptr, n->nonce, TPM_DIGEST_SIZE); } +static inline BYTE* unpack_TPM_NONCE(BYTE* ptr, TPM_NONCE* n) { return unpack_BUFFER(ptr, n->nonce, TPM_DIGEST_SIZE); } #define sizeof_TPM_NONCE(x) TPM_DIGEST_SIZE +static inline int unpack3_TPM_NONCE(BYTE* ptr, UINT32* pos, UINT32 max, TPM_NONCE* n) { return unpack3_BUFFER(ptr, pos, max, n->nonce, TPM_DIGEST_SIZE); } +static inline BYTE* pack_TPM_SYMMETRIC_KEY_PARMS(BYTE* ptr, const TPM_SYMMETRIC_KEY_PARMS* k) { ptr = pack_UINT32(ptr, k->keyLength); ptr = pack_UINT32(ptr, k->blockSize); ptr = pack_UINT32(ptr, k->ivSize); return pack_BUFFER(ptr, k->IV, k->ivSize); } +static inline BYTE* pack_TPM_SYMMETRIC_KEY(BYTE* ptr, const TPM_SYMMETRIC_KEY* k) { ptr = pack_UINT32(ptr, k->algId); ptr = pack_UINT16(ptr, k->encScheme); ptr = pack_UINT16(ptr, k->size); return pack_BUFFER(ptr, k->data, k->size); } +static inline int unpack3_TPM_SYMMETRIC_KEY_PARMS(BYTE* ptr, UINT32* pos, UINT32 max, TPM_SYMMETRIC_KEY_PARMS* k, UnpackPtr alloc) { return unpack3_UINT32(ptr, pos, max, &k->keyLength) || unpack3_UINT32(ptr, pos, max, &k->blockSize) || unpack3_UINT32(ptr, pos, max, &k->ivSize) || unpack3_PTR(ptr, pos, max, &k->IV, k->ivSize, alloc); } +static inline int sizeof_TPM_SYMMETRIC_KEY_PARMS(const TPM_SYMMETRIC_KEY_PARMS* k) { return 12 + k->ivSize; } +static inline int unpack3_TPM_SYMMETRIC_KEY(BYTE* ptr, UINT32* pos, UINT32 max, TPM_SYMMETRIC_KEY* k, UnpackPtr alloc) { return unpack3_UINT32(ptr, pos, max, &k->algId) || unpack3_UINT16(ptr, pos, max, &k->encScheme) || unpack3_UINT16(ptr, pos, max, &k->size) || unpack3_PTR(ptr, pos, max, &k->data, k->size, alloc); } +static inline BYTE* pack_TPM_RSA_KEY_PARMS(BYTE* ptr, const TPM_RSA_KEY_PARMS* k) { ptr = pack_UINT32(ptr, k->keyLength); ptr = pack_UINT32(ptr, k->numPrimes); ptr = pack_UINT32(ptr, k->exponentSize); return pack_BUFFER(ptr, k->exponent, k->exponentSize); } +static inline int unpack3_TPM_RSA_KEY_PARMS(BYTE* ptr, UINT32* pos, UINT32 max, TPM_RSA_KEY_PARMS* k, UnpackPtr alloc) { return unpack3_UINT32(ptr, pos, max, &k->keyLength) || unpack3_UINT32(ptr, pos, max, &k->numPrimes) || unpack3_UINT32(ptr, pos, max, &k->exponentSize) || unpack3_PTR(ptr, pos, max, &k->exponent, k->exponentSize, alloc); } +static inline int sizeof_TPM_RSA_KEY_PARMS(const TPM_RSA_KEY_PARMS* k) { return 12 + k->exponentSize; } +static inline BYTE* pack_TPM_KEY_PARMS(BYTE* ptr, const TPM_KEY_PARMS* k) { ptr = pack_TPM_ALGORITHM_ID(ptr, k->algorithmID); ptr = pack_TPM_ENC_SCHEME(ptr, k->encScheme); ptr = pack_TPM_SIG_SCHEME(ptr, k->sigScheme); ptr = pack_UINT32(ptr, k->parmSize); if(k->parmSize) { switch(k->algorithmID) { case TPM_ALG_RSA: return pack_TPM_RSA_KEY_PARMS(ptr, &k->parms.rsa); case TPM_ALG_AES128: case TPM_ALG_AES192: case TPM_ALG_AES256: return pack_TPM_SYMMETRIC_KEY_PARMS(ptr, &k->parms.sym); } } return ptr; } +static inline int unpack3_TPM_KEY_PARMS(BYTE* ptr, UINT32* pos, UINT32 len, TPM_KEY_PARMS* k, UnpackPtr alloc) { int rc = unpack3_TPM_ALGORITHM_ID(ptr, pos, len, &k->algorithmID) || unpack3_TPM_ENC_SCHEME(ptr, pos, len, &k->encScheme) || unpack3_TPM_SIG_SCHEME(ptr, pos, len, &k->sigScheme) || unpack3_UINT32(ptr, pos, len, &k->parmSize); if (rc || k->parmSize == 0) return rc; switch(k->algorithmID) { case TPM_ALG_RSA: return unpack3_TPM_RSA_KEY_PARMS(ptr, pos, len, &k->parms.rsa, alloc); case TPM_ALG_AES128: case TPM_ALG_AES192: case TPM_ALG_AES256: return unpack3_TPM_SYMMETRIC_KEY_PARMS(ptr, pos, len, &k->parms.sym, alloc); } return TPM_FAIL; } +static inline int sizeof_TPM_KEY_PARMS(const TPM_KEY_PARMS* k) { int rc = 0; rc += sizeof_TPM_ALGORITHM_ID(&k->algorithmID); rc += sizeof_TPM_ENC_SCHEME(&k->encScheme); rc += sizeof_TPM_SIG_SCHEME(&k->sigScheme); rc += sizeof_UINT32(&k->parmSize); if (!k->parmSize) return rc; switch(k->algorithmID) { case TPM_ALG_RSA: rc += sizeof_TPM_RSA_KEY_PARMS(&k->parms.rsa); break; case TPM_ALG_AES128: case TPM_ALG_AES192: case TPM_ALG_AES256: rc += sizeof_TPM_SYMMETRIC_KEY_PARMS(&k->parms.sym); break; } return rc; } +static inline BYTE* pack_TPM_STORE_PUBKEY(BYTE* ptr, const TPM_STORE_PUBKEY* k) { ptr = pack_UINT32(ptr, k->keyLength); ptr = pack_BUFFER(ptr, k->key, k->keyLength); return ptr; } +static inline int unpack3_TPM_STORE_PUBKEY(BYTE* ptr, UINT32* pos, UINT32 max, TPM_STORE_PUBKEY* k, UnpackPtr alloc) { return unpack3_UINT32(ptr, pos, max, &k->keyLength) || unpack3_PTR(ptr, pos, max, &k->key, k->keyLength, alloc); } +static inline int sizeof_TPM_STORE_PUBKEY(const TPM_STORE_PUBKEY* k) { return 4 + k->keyLength; } +static inline BYTE* pack_TPM_PUBKEY(BYTE* ptr, const TPM_PUBKEY* k) { ptr = pack_TPM_KEY_PARMS(ptr, &k->algorithmParms); return pack_TPM_STORE_PUBKEY(ptr, &k->pubKey); } +static inline int unpack3_TPM_PUBKEY(BYTE* ptr, UINT32* pos, UINT32 len, TPM_PUBKEY* k, UnpackPtr alloc) { return unpack3_TPM_KEY_PARMS(ptr, pos, len, &k->algorithmParms, alloc) || unpack3_TPM_STORE_PUBKEY(ptr, pos, len, &k->pubKey, alloc); } +static inline BYTE* pack_TPM_PCR_SELECTION(BYTE* ptr, const TPM_PCR_SELECTION* p) { ptr = pack_UINT16(ptr, p->sizeOfSelect); ptr = pack_BUFFER(ptr, p->pcrSelect, p->sizeOfSelect); return ptr; } +static inline BYTE* unpack_TPM_PCR_SELECTION(BYTE* ptr, TPM_PCR_SELECTION* p, UnpackPtr alloc) { ptr = unpack_UINT16(ptr, &p->sizeOfSelect); ptr = unpack_PTR(ptr, &p->pcrSelect, p->sizeOfSelect, alloc); return ptr; } +static inline int unpack3_TPM_PCR_SELECTION(BYTE* ptr, UINT32* pos, UINT32 max, TPM_PCR_SELECTION* p, UnpackPtr alloc) { return unpack3_UINT16(ptr, pos, max, &p->sizeOfSelect) || unpack3_PTR(ptr, pos, max, &p->pcrSelect, p->sizeOfSelect, alloc); } +static inline int sizeof_TPM_PCR_SELECTION(const TPM_PCR_SELECTION* p) { return 2 + p->sizeOfSelect; } +static inline BYTE* pack_TPM_PCR_INFO(BYTE* ptr, const TPM_PCR_INFO* p) { ptr = pack_TPM_PCR_SELECTION(ptr, &p->pcrSelection); ptr = pack_TPM_COMPOSITE_HASH(ptr, &p->digestAtRelease); ptr = pack_TPM_COMPOSITE_HASH(ptr, &p->digestAtCreation); return ptr; } +static inline int unpack3_TPM_PCR_INFO(BYTE* ptr, UINT32* pos, UINT32 max, TPM_PCR_INFO* p, UnpackPtr alloc) { return unpack3_TPM_PCR_SELECTION(ptr, pos, max, &p->pcrSelection, alloc) || unpack3_TPM_COMPOSITE_HASH(ptr, pos, max, &p->digestAtRelease) || unpack3_TPM_COMPOSITE_HASH(ptr, pos, max, &p->digestAtCreation); } +static inline int sizeof_TPM_PCR_INFO(const TPM_PCR_INFO* p) { int rc = 0; rc += sizeof_TPM_PCR_SELECTION(&p->pcrSelection); rc += sizeof_TPM_COMPOSITE_HASH(&p->digestAtRelease); rc += sizeof_TPM_COMPOSITE_HASH(&p->digestAtCreation); return rc; } +static inline BYTE* pack_TPM_PCR_INFO_LONG(BYTE* ptr, const TPM_PCR_INFO_LONG* p) { ptr = pack_TPM_STRUCTURE_TAG(ptr, p->tag); ptr = pack_TPM_LOCALITY_SELECTION(ptr, p->localityAtCreation); ptr = pack_TPM_LOCALITY_SELECTION(ptr, p->localityAtRelease); ptr = pack_TPM_PCR_SELECTION(ptr, &p->creationPCRSelection); ptr = pack_TPM_PCR_SELECTION(ptr, &p->releasePCRSelection); ptr = pack_TPM_COMPOSITE_HASH(ptr, &p->digestAtCreation); ptr = pack_TPM_COMPOSITE_HASH(ptr, &p->digestAtRelease); return ptr; } +static inline int sizeof_TPM_PCR_INFO_LONG(const TPM_PCR_INFO_LONG* p) { int rc = 0; rc += sizeof_TPM_STRUCTURE_TAG(p->tag); rc += sizeof_TPM_LOCALITY_SELECTION(p->localityAtCreation); rc += sizeof_TPM_LOCALITY_SELECTION(p->localityAtRelease); rc += sizeof_TPM_PCR_SELECTION(&p->creationPCRSelection); rc += sizeof_TPM_PCR_SELECTION(&p->releasePCRSelection); rc += sizeof_TPM_COMPOSITE_HASH(&p->digestAtCreation); rc += sizeof_TPM_COMPOSITE_HASH(&p->digestAtRelease); return rc; } +static inline int unpack3_TPM_PCR_INFO_LONG(BYTE* ptr, UINT32* pos, UINT32 max, TPM_PCR_INFO_LONG* p, UnpackPtr alloc) { return unpack3_TPM_STRUCTURE_TAG(ptr, pos, max, &p->tag) || unpack3_TPM_LOCALITY_SELECTION(ptr, pos, max, &p->localityAtCreation) || unpack3_TPM_LOCALITY_SELECTION(ptr, pos, max, &p->localityAtRelease) || unpack3_TPM_PCR_SELECTION(ptr, pos, max, &p->creationPCRSelection, alloc) || unpack3_TPM_PCR_SELECTION(ptr, pos, max, &p->releasePCRSelection, alloc) || unpack3_TPM_COMPOSITE_HASH(ptr, pos, max, &p->digestAtCreation) || unpack3_TPM_COMPOSITE_HASH(ptr, pos, max, &p->digestAtRelease); } +static inline BYTE* pack_TPM_PCR_COMPOSITE(BYTE* ptr, const TPM_PCR_COMPOSITE* p) { ptr = pack_TPM_PCR_SELECTION(ptr, &p->select); ptr = pack_UINT32(ptr, p->valueSize); ptr = pack_BUFFER(ptr, (const BYTE*)p->pcrValue, p->valueSize); return ptr; } +static inline int unpack3_TPM_PCR_COMPOSITE(BYTE* ptr, UINT32* pos, UINT32 max, TPM_PCR_COMPOSITE* p, UnpackPtr alloc) { return unpack3_TPM_PCR_SELECTION(ptr, pos, max, &p->select, alloc) || unpack3_UINT32(ptr, pos, max, &p->valueSize) || unpack3_PTR(ptr, pos, max, (BYTE**)&p->pcrValue, p->valueSize, alloc); } +static inline BYTE* pack_TPM_KEY(BYTE* ptr, const TPM_KEY* k) { ptr = pack_TPM_VERSION(ptr, &k->ver); ptr = pack_TPM_KEY_USAGE(ptr, k->keyUsage); ptr = pack_TPM_KEY_FLAGS(ptr, k->keyFlags); ptr = pack_TPM_AUTH_DATA_USAGE(ptr, k->authDataUsage); ptr = pack_TPM_KEY_PARMS(ptr, &k->algorithmParms); ptr = pack_UINT32(ptr, k->PCRInfoSize); if(k->PCRInfoSize) { ptr = pack_TPM_PCR_INFO(ptr, &k->PCRInfo); } ptr = pack_TPM_STORE_PUBKEY(ptr, &k->pubKey); ptr = pack_UINT32(ptr, k->encDataSize); return pack_BUFFER(ptr, k->encData, k->encDataSize); } +static inline int unpack3_TPM_KEY(BYTE* ptr, UINT32* pos, UINT32 max, TPM_KEY* k, UnpackPtr alloc) { int rc = unpack3_TPM_VERSION(ptr, pos, max, &k->ver) || unpack3_TPM_KEY_USAGE(ptr, pos, max, &k->keyUsage) || unpack3_TPM_KEY_FLAGS(ptr, pos, max, &k->keyFlags) || unpack3_TPM_AUTH_DATA_USAGE(ptr, pos, max, &k->authDataUsage) || unpack3_TPM_KEY_PARMS(ptr, pos, max, &k->algorithmParms, alloc) || unpack3_UINT32(ptr, pos, max, &k->PCRInfoSize); if (rc) return rc; if(k->PCRInfoSize) { rc = unpack3_TPM_PCR_INFO(ptr, pos, max, &k->PCRInfo, alloc); } if (rc) return rc; return unpack3_TPM_STORE_PUBKEY(ptr, pos, max, &k->pubKey, alloc) || unpack3_UINT32(ptr, pos, max, &k->encDataSize) || unpack3_PTR(ptr, pos, max, &k->encData, k->encDataSize, alloc); } +static inline int sizeof_TPM_KEY(const TPM_KEY* k) { int rc = 0; rc += sizeof_TPM_VERSION(&k->ver); rc += sizeof_TPM_KEY_USAGE(k->keyUsage); rc += sizeof_TPM_KEY_FLAGS(k->keyFlags); rc += sizeof_TPM_AUTH_DATA_USAGE(k->authDataUsage); rc += sizeof_TPM_KEY_PARMS(&k->algorithmParms); rc += sizeof_UINT32(k->PCRInfoSize); if(k->PCRInfoSize) { rc += sizeof_TPM_PCR_INFO(&k->PCRInfo); } rc += sizeof_TPM_STORE_PUBKEY(&k->pubKey); rc += sizeof_UINT32(k->encDataSize); rc += k->encDataSize; return rc; } +static inline BYTE* pack_TPM_BOUND_DATA(BYTE* ptr, const TPM_BOUND_DATA* b, UINT32 payloadSize) { ptr = pack_TPM_VERSION(ptr, &b->ver); ptr = pack_TPM_PAYLOAD_TYPE(ptr, b->payload); return pack_BUFFER(ptr, b->payloadData, payloadSize); } +static inline BYTE* unpack_TPM_BOUND_DATA(BYTE* ptr, TPM_BOUND_DATA* b, UINT32 payloadSize, UnpackPtr alloc) { ptr = unpack_TPM_VERSION(ptr, &b->ver); ptr = unpack_TPM_PAYLOAD_TYPE(ptr, &b->payload); return unpack_PTR(ptr, &b->payloadData, payloadSize, alloc); } +static inline BYTE* pack_TPM_STORED_DATA(BYTE* ptr, const TPM_STORED_DATA* d) { ptr = pack_TPM_VERSION(ptr, &d->ver); ptr = pack_UINT32(ptr, d->sealInfoSize); if(d->sealInfoSize) { ptr = pack_TPM_PCR_INFO(ptr, &d->sealInfo); } ptr = pack_UINT32(ptr, d->encDataSize); ptr = pack_BUFFER(ptr, d->encData, d->encDataSize); return ptr; } +static inline int sizeof_TPM_STORED_DATA(const TPM_STORED_DATA* d) { int rv = sizeof_TPM_VERSION(&d->ver) + sizeof_UINT32(d->sealInfoSize); if (d->sealInfoSize) { rv += sizeof_TPM_PCR_INFO(&d->sealInfo); } rv += sizeof_UINT32(d->encDataSize); rv += sizeof_BUFFER(d->encData, d->encDataSize); return rv; } +static inline int unpack3_TPM_STORED_DATA(BYTE* ptr, UINT32* pos, UINT32 len, TPM_STORED_DATA* d, UnpackPtr alloc) { int rc = unpack3_TPM_VERSION(ptr, pos, len, &d->ver) || unpack3_UINT32(ptr, pos, len, &d->sealInfoSize); if (rc) return rc; if (d->sealInfoSize) rc = unpack3_TPM_PCR_INFO(ptr, pos, len, &d->sealInfo, alloc); if (rc) return rc; rc = unpack3_UINT32(ptr, pos, len, &d->encDataSize) || unpack3_PTR(ptr, pos, len, &d->encData, d->encDataSize, alloc); return rc; } +static inline BYTE* pack_TPM_STORED_DATA12(BYTE* ptr, const TPM_STORED_DATA12* d) { ptr = pack_TPM_STRUCTURE_TAG(ptr, d->tag); ptr = pack_TPM_ENTITY_TYPE(ptr, d->et); ptr = pack_UINT32(ptr, d->sealInfoLongSize); if(d->sealInfoLongSize) { ptr = pack_TPM_PCR_INFO_LONG(ptr, &d->sealInfoLong); } ptr = pack_UINT32(ptr, d->encDataSize); ptr = pack_BUFFER(ptr, d->encData, d->encDataSize); return ptr; } +static inline int sizeof_TPM_STORED_DATA12(const TPM_STORED_DATA12* d) { int rv = sizeof_TPM_STRUCTURE_TAG(&d->ver) + sizeof_TPM_ENTITY_TYPE(&d->et) + sizeof_UINT32(d->sealInfoLongSize); if (d->sealInfoLongSize) { rv += sizeof_TPM_PCR_INFO_LONG(&d->sealInfoLong); } rv += sizeof_UINT32(d->encDataSize); rv += sizeof_BUFFER(d->encData, d->encDataSize); return rv; } +static inline int unpack3_TPM_STORED_DATA12(BYTE* ptr, UINT32* pos, UINT32 len, TPM_STORED_DATA12* d, UnpackPtr alloc) { int rc = unpack3_TPM_STRUCTURE_TAG(ptr, pos, len, &d->tag) || unpack3_TPM_ENTITY_TYPE(ptr, pos, len, &d->et) || unpack3_UINT32(ptr, pos, len, &d->sealInfoLongSize); if (rc) return rc; if (d->sealInfoLongSize) rc = unpack3_TPM_PCR_INFO_LONG(ptr, pos, len, &d->sealInfoLong, alloc); if (rc) return rc; rc = unpack3_UINT32(ptr, pos, len, &d->encDataSize) || unpack3_PTR(ptr, pos, len, &d->encData, d->encDataSize, alloc); return rc; } +static inline BYTE* pack_TPM_AUTH_SESSION(BYTE* ptr, const TPM_AUTH_SESSION* auth) { ptr = pack_TPM_AUTH_HANDLE(ptr, auth->AuthHandle); ptr = pack_TPM_NONCE(ptr, &auth->NonceOdd); ptr = pack_BOOL(ptr, auth->fContinueAuthSession); ptr = pack_TPM_AUTHDATA(ptr, &auth->HMAC); return ptr; } +static inline BYTE* unpack_TPM_AUTH_SESSION(BYTE* ptr, TPM_AUTH_SESSION* auth) { ptr = unpack_TPM_NONCE(ptr, &auth->NonceEven); ptr = unpack_BOOL(ptr, &auth->fContinueAuthSession); ptr = unpack_TPM_AUTHDATA(ptr, &auth->HMAC); return ptr; } +static inline int unpack3_TPM_AUTH_SESSION(BYTE* ptr, UINT32* pos, UINT32 len, TPM_AUTH_SESSION* auth) { return unpack3_TPM_NONCE(ptr, pos, len, &auth->NonceEven) || unpack3_BOOL(ptr, pos, len, &auth->fContinueAuthSession) || unpack3_TPM_AUTHDATA(ptr, pos, len, &auth->HMAC); } +static inline int sizeof_TPM_AUTH_SESSION(const TPM_AUTH_SESSION* auth) { int rv = 0; rv += sizeof_TPM_AUTH_HANDLE(auth->AuthHandle); rv += sizeof_TPM_NONCE(&auth->NonceOdd); rv += sizeof_BOOL(auth->fContinueAuthSession); rv += sizeof_TPM_AUTHDATA(&auth->HMAC); return rv; } +static inline BYTE* pack_TPM_RQU_HEADER(BYTE* ptr, TPM_TAG tag, UINT32 size, TPM_COMMAND_CODE ord) { ptr = pack_UINT16(ptr, tag); ptr = pack_UINT32(ptr, size); return pack_UINT32(ptr, ord); } +static inline BYTE* unpack_TPM_RQU_HEADER(BYTE* ptr, TPM_TAG* tag, UINT32* size, TPM_COMMAND_CODE* ord) { ptr = unpack_UINT16(ptr, tag); ptr = unpack_UINT32(ptr, size); ptr = unpack_UINT32(ptr, ord); return ptr; } +static inline int unpack3_TPM_RQU_HEADER(BYTE* ptr, UINT32* pos, UINT32 max, TPM_TAG* tag, UINT32* size, TPM_COMMAND_CODE* ord) { return unpack3_UINT16(ptr, pos, max, tag) || unpack3_UINT32(ptr, pos, max, size) || unpack3_UINT32(ptr, pos, max, ord); } #define pack_TPM_RSP_HEADER(p, t, s, r) pack_TPM_RQU_HEADER(p, t, s, r) #define unpack_TPM_RSP_HEADER(p, t, s, r) unpack_TPM_RQU_HEADER(p, t, s, r) #define unpack3_TPM_RSP_HEADER(p, l, m, t, s, r) unpack3_TPM_RQU_HEADER(p, l, m, t, s, r) --- a/stubdom/vtpmmgr/tcg.h +++ b/stubdom/vtpmmgr/tcg.h @@ -452,24 +452,25 @@ typedef struct TPM_VERSION { static const TPM_VERSION TPM_STRUCT_VER_1_1 = { 1,1,0,0 }; typedef struct TPM_CAP_VERSION_INFO { TPM_STRUCTURE_TAG tag; TPM_VERSION version; UINT16 specLevel; BYTE errataRev; BYTE tpmVendorID[4]; UINT16 vendorSpecificSize; BYTE* vendorSpecific; } TPM_CAP_VERSION_INFO; +static inline void free_TPM_CAP_VERSION_INFO(TPM_CAP_VERSION_INFO* v) { free(v->vendorSpecific); v->vendorSpecific = NULL; } typedef struct TPM_DIGEST { BYTE digest[TPM_DIGEST_SIZE]; } TPM_DIGEST; typedef TPM_DIGEST TPM_PCRVALUE; typedef TPM_DIGEST TPM_COMPOSITE_HASH; typedef TPM_DIGEST TPM_DIRVALUE; @@ -485,226 +486,239 @@ typedef struct TPM_SYMMETRIC_KEY_PARMS { UINT32 blockSize; UINT32 ivSize; BYTE* IV; } TPM_SYMMETRIC_KEY_PARMS; typedef struct TPM_SYMMETRIC_KEY { UINT32 algId; UINT16 encScheme; UINT16 size; BYTE* data; } TPM_SYMMETRIC_KEY; +static inline void free_TPM_SYMMETRIC_KEY_PARMS(TPM_SYMMETRIC_KEY_PARMS* p) { free(p->IV); p->IV = NULL; } #define TPM_SYMMETRIC_KEY_PARMS_INIT { 0, 0, 0, NULL } typedef struct TPM_RSA_KEY_PARMS { UINT32 keyLength; UINT32 numPrimes; UINT32 exponentSize; BYTE* exponent; } TPM_RSA_KEY_PARMS; #define TPM_RSA_KEY_PARMS_INIT { 0, 0, 0, NULL } +static inline void free_TPM_RSA_KEY_PARMS(TPM_RSA_KEY_PARMS* p) { free(p->exponent); p->exponent = NULL; } typedef struct TPM_KEY_PARMS { TPM_ALGORITHM_ID algorithmID; TPM_ENC_SCHEME encScheme; TPM_SIG_SCHEME sigScheme; UINT32 parmSize; union { TPM_SYMMETRIC_KEY_PARMS sym; TPM_RSA_KEY_PARMS rsa; } parms; } TPM_KEY_PARMS; #define TPM_KEY_PARMS_INIT { 0, 0, 0, 0 } +static inline void free_TPM_KEY_PARMS(TPM_KEY_PARMS* p) { if(p->parmSize) { switch(p->algorithmID) { case TPM_ALG_RSA: free_TPM_RSA_KEY_PARMS(&p->parms.rsa); break; case TPM_ALG_AES128: case TPM_ALG_AES192: case TPM_ALG_AES256: free_TPM_SYMMETRIC_KEY_PARMS(&p->parms.sym); break; } } } typedef struct TPM_STORE_PUBKEY { UINT32 keyLength; BYTE* key; } TPM_STORE_PUBKEY; #define TPM_STORE_PUBKEY_INIT { 0, NULL } +static inline void free_TPM_STORE_PUBKEY(TPM_STORE_PUBKEY* p) { free(p->key); p->key = NULL; } typedef struct TPM_PUBKEY { TPM_KEY_PARMS algorithmParms; TPM_STORE_PUBKEY pubKey; } TPM_PUBKEY; #define TPM_PUBKEY_INIT { TPM_KEY_PARMS_INIT, TPM_STORE_PUBKEY_INIT } +static inline void free_TPM_PUBKEY(TPM_PUBKEY* k) { free_TPM_KEY_PARMS(&k->algorithmParms); free_TPM_STORE_PUBKEY(&k->pubKey); } typedef struct TPM_PCR_SELECTION { UINT16 sizeOfSelect; BYTE* pcrSelect; } TPM_PCR_SELECTION; #define TPM_PCR_SELECTION_INIT { 0, NULL } +static inline void free_TPM_PCR_SELECTION(TPM_PCR_SELECTION* p) { free(p->pcrSelect); p->pcrSelect = NULL; } #define TPM_LOCALITY_SELECTION BYTE typedef struct TPM_PCR_INFO_LONG { TPM_STRUCTURE_TAG tag; TPM_LOCALITY_SELECTION localityAtCreation; TPM_LOCALITY_SELECTION localityAtRelease; TPM_PCR_SELECTION creationPCRSelection; TPM_PCR_SELECTION releasePCRSelection; TPM_COMPOSITE_HASH digestAtCreation; TPM_COMPOSITE_HASH digestAtRelease; } TPM_PCR_INFO_LONG; #define TPM_PCR_INFO_LONG_INIT { 0, 0, 0, TPM_PCR_SELECTION_INIT, \ TPM_PCR_SELECTION_INIT } +static inline void free_TPM_PCR_INFO_LONG(TPM_PCR_INFO_LONG* p) { free_TPM_PCR_SELECTION(&p->creationPCRSelection); free_TPM_PCR_SELECTION(&p->releasePCRSelection); } typedef struct TPM_PCR_INFO { TPM_PCR_SELECTION pcrSelection; TPM_COMPOSITE_HASH digestAtRelease; TPM_COMPOSITE_HASH digestAtCreation; } TPM_PCR_INFO; #define TPM_PCR_INFO_INIT { TPM_PCR_SELECTION_INIT } +static inline void free_TPM_PCR_INFO(TPM_PCR_INFO* p) { free_TPM_PCR_SELECTION(&p->pcrSelection); } typedef struct TPM_PCR_COMPOSITE { TPM_PCR_SELECTION select; UINT32 valueSize; TPM_PCRVALUE* pcrValue; } TPM_PCR_COMPOSITE; #define TPM_PCR_COMPOSITE_INIT { TPM_PCR_SELECTION_INIT, 0, NULL } +static inline void free_TPM_PCR_COMPOSITE(TPM_PCR_COMPOSITE* p) { free_TPM_PCR_SELECTION(&p->select); free(p->pcrValue); p->pcrValue = NULL; } typedef struct TPM_KEY { TPM_VERSION ver; TPM_KEY_USAGE keyUsage; TPM_KEY_FLAGS keyFlags; TPM_AUTH_DATA_USAGE authDataUsage; TPM_KEY_PARMS algorithmParms; UINT32 PCRInfoSize; TPM_PCR_INFO PCRInfo; TPM_STORE_PUBKEY pubKey; UINT32 encDataSize; BYTE* encData; } TPM_KEY; #define TPM_KEY_INIT { .algorithmParms = TPM_KEY_PARMS_INIT,\ .PCRInfoSize = 0, .PCRInfo = TPM_PCR_INFO_INIT, \ .pubKey = TPM_STORE_PUBKEY_INIT, \ .encDataSize = 0, .encData = NULL } +static inline void free_TPM_KEY(TPM_KEY* k) { if(k->PCRInfoSize) { free_TPM_PCR_INFO(&k->PCRInfo); } free_TPM_STORE_PUBKEY(&k->pubKey); free(k->encData); k->encData = NULL; } typedef struct TPM_BOUND_DATA { TPM_VERSION ver; TPM_PAYLOAD_TYPE payload; BYTE* payloadData; } TPM_BOUND_DATA; #define TPM_BOUND_DATA_INIT { .payloadData = NULL } +static inline void free_TPM_BOUND_DATA(TPM_BOUND_DATA* d) { free(d->payloadData); d->payloadData = NULL; } typedef struct TPM_STORED_DATA { TPM_VERSION ver; UINT32 sealInfoSize; TPM_PCR_INFO sealInfo; UINT32 encDataSize; BYTE* encData; } TPM_STORED_DATA; #define TPM_STORED_DATA_INIT { .sealInfoSize = 0, sealInfo = TPM_PCR_INFO_INIT,\ .encDataSize = 0, .encData = NULL } +static inline void free_TPM_STORED_DATA(TPM_STORED_DATA* d) { if(d->sealInfoSize) { free_TPM_PCR_INFO(&d->sealInfo); } free(d->encData); d->encData = NULL; } typedef struct TPM_STORED_DATA12 { TPM_STRUCTURE_TAG tag; TPM_ENTITY_TYPE et; UINT32 sealInfoLongSize; TPM_PCR_INFO_LONG sealInfoLong; UINT32 encDataSize; BYTE* encData; } TPM_STORED_DATA12; #define TPM_STORED_DATA12_INIT { .sealInfoLongSize = 0, \ sealInfoLong = TPM_PCR_INFO_INIT, .encDataSize = 0, .encData = NULL } +static inline void free_TPM_STORED_DATA12(TPM_STORED_DATA12* d) { if(d->sealInfoLongSize) { free_TPM_PCR_INFO_LONG(&d->sealInfoLong); } free(d->encData); d->encData = NULL; } typedef struct TPM_AUTH_SESSION { TPM_AUTHHANDLE AuthHandle; TPM_NONCE NonceOdd; // system TPM_NONCE NonceEven; // TPM --- a/stubdom/vtpmmgr/tpm2_marshal.h +++ b/stubdom/vtpmmgr/tpm2_marshal.h @@ -43,47 +43,52 @@ #define TPM2_MARSHAL_H #include <stdlib.h> #include <mini-os/byteorder.h> #include <mini-os/endian.h> #include "tcg.h" #include "tpm2_types.h" #include <assert.h> #define pack_TPM_BUFFER(ptr, buf, size) pack_BUFFER(ptr, buf, size) #define unpack_TPM_BUFFER(ptr, buf, size) unpack_BUFFER(ptr, buf, size) +static inline BYTE* pack_BYTE_ARRAY(BYTE* ptr, const BYTE* array, UINT32 size) { int i; for (i = 0; i < size; i++) ptr = pack_BYTE(ptr, array[i]); return ptr; } +static inline BYTE* pack_TPMA_SESSION(BYTE* ptr, const TPMA_SESSION *attr) { return pack_BYTE(ptr, (BYTE)(*attr)); } +static inline BYTE* unpack_TPMA_SESSION(BYTE* ptr, TPMA_SESSION *attr) { return unpack_BYTE(ptr, (BYTE *)attr); } +static inline BYTE* pack_TPMI_ALG_HASH(BYTE* ptr, const TPMI_ALG_HASH *hash) { return pack_UINT16(ptr, *hash); } +static inline BYTE* unpack_TPMI_ALG_HASH(BYTE *ptr, TPMI_ALG_HASH *hash) { return unpack_UINT16(ptr, hash); } #define pack_TPMA_OBJECT(ptr, t) pack_UINT32(ptr, (UINT32)(*t)) #define unpack_TPMA_OBJECT(ptr, t) unpack_UINT32(ptr, (UINT32 *)(t)) #define pack_TPM_RH(ptr, t) pack_UINT32(ptr, (UINT32)(*t)) #define unpack_TPM_RH(ptr, t) unpack_UINT32(ptr, (UINT32 *)(t)) #define pack_TPMA_LOCALITY(ptr, locality) pack_BYTE(ptr, (BYTE)*locality) #define unpack_TPMA_LOCALITY(ptr, locality) unpack_BYTE(ptr, (BYTE *)locality) #define pack_TPM_ST(ptr, tag) pack_UINT16(ptr, *tag) @@ -116,558 +121,611 @@ inline BYTE* unpack_TPMI_ALG_HASH(BYTE *ptr, TPMI_ALG_HASH *hash) #define unpack_TPMI_DH_OBJECT(PTR, O) unpack_TPM2_HANDLE(ptr, o) #define pack_TPMI_RH_HIERACHY(ptr, h) pack_TPM2_HANDLE(ptr, h) #define unpack_TPMI_RH_HIERACHY(ptr, h) unpack_TPM2_HANDLE(ptr, h) #define pack_TPMI_RH_PLATFORM(ptr, p) pack_TPM2_HANDLE(ptr, p) #define unpack_TPMI_RH_PLATFORM(ptr, p) unpack_TPM2_HANDLE(ptr, p) #define pack_TPMI_RH_OWNER(ptr, o) pack_TPM2_HANDLE(ptr, o) #define unpack_TPMI_RH_OWNER(ptr, o) unpack_TPM2_HANDLE(ptr, o) #define pack_TPMI_RH_ENDORSEMENT(ptr, e) pack_TPM2_HANDLE(ptr, e) #define unpack_TPMI_RH_ENDORSEMENT(ptr, e) unpack_TPM2_HANDLE(ptr, e) #define pack_TPMI_RH_LOCKOUT(ptr, l) pack_TPM2_HANDLE(ptr, l) #define unpack_TPMI_RH_LOCKOUT(ptr, l) unpack_TPM2_HANDLE(ptr, l) +static inline BYTE* pack_TPM2B_DIGEST(BYTE* ptr, const TPM2B_DIGEST *digest) { ptr = pack_UINT16(ptr, digest->size); ptr = pack_BUFFER(ptr, digest->buffer, digest->size); return ptr; } +static inline BYTE* unpack_TPM2B_DIGEST(BYTE* ptr, TPM2B_DIGEST *digest) { ptr = unpack_UINT16(ptr, &digest->size); ptr = unpack_BUFFER(ptr, digest->buffer, digest->size); return ptr; } +static inline BYTE* pack_TPMT_TK_CREATION(BYTE* ptr,const TPMT_TK_CREATION *ticket ) { ptr = pack_TPM_ST(ptr , &ticket->tag); ptr = pack_TPMI_RH_HIERACHY(ptr , &ticket->hierarchy); ptr = pack_TPM2B_DIGEST(ptr, &ticket->digest); return ptr; } +static inline BYTE* unpack_TPMT_TK_CREATION(BYTE* ptr, TPMT_TK_CREATION *ticket ) { ptr = unpack_TPM_ST(ptr, &ticket->tag); ptr = unpack_TPMI_RH_HIERACHY(ptr, &ticket->hierarchy); ptr = unpack_TPM2B_DIGEST(ptr, &ticket->digest); return ptr; } +static inline BYTE* pack_TPM2B_NAME(BYTE* ptr,const TPM2B_NAME *name ) { ptr = pack_UINT16(ptr, name->size); ptr = pack_TPM_BUFFER(ptr, name->name, name->size); return ptr; } +static inline BYTE* unpack_TPM2B_NAME(BYTE* ptr, TPM2B_NAME *name) { ptr = unpack_UINT16(ptr, &name->size); ptr = unpack_TPM_BUFFER(ptr, name->name, name->size); return ptr; } +static inline BYTE* pack_TPM2B_NONCE(BYTE* ptr, const TPM2B_NONCE *nonce) { return pack_TPM2B_DIGEST(ptr, (const TPM2B_DIGEST*)nonce); } #define unpack_TPM2B_NONCE(ptr, nonce) unpack_TPM2B_DIGEST(ptr, (TPM2B_DIGEST*)nonce) +static inline BYTE* pack_TPM2B_AUTH(BYTE* ptr, const TPM2B_AUTH *auth) { return pack_TPM2B_DIGEST(ptr, (const TPM2B_DIGEST*)auth); } #define unpack_TPM2B_AUTH(ptr, auth) unpack_TPM2B_DIGEST(ptr, (TPM2B_DIGEST*)auth) +static inline BYTE* pack_TPM2B_DATA(BYTE* ptr, const TPM2B_DATA *data) { return pack_TPM2B_DIGEST(ptr, (const TPM2B_DIGEST*)data); } #define unpack_TPM2B_DATA(ptr, data) unpack_TPM2B_DIGEST(ptr, (TPM2B_DIGEST*)data) +static inline BYTE* pack_TPM2B_SENSITIVE_DATA(BYTE* ptr, const TPM2B_SENSITIVE_DATA *data) { return pack_TPM2B_DIGEST(ptr, (const TPM2B_DIGEST*)data); } #define unpack_TPM2B_SENSITIVE_DATA(ptr, data) unpack_TPM2B_DIGEST(ptr, (TPM2B_DIGEST*)data) +static inline BYTE* pack_TPM2B_PUBLIC_KEY_RSA(BYTE* ptr, const TPM2B_PUBLIC_KEY_RSA *rsa) { return pack_TPM2B_DIGEST(ptr, (const TPM2B_DIGEST*)rsa); } #define unpack_TPM2B_PUBLIC_KEY_RSA(ptr, rsa) unpack_TPM2B_DIGEST(ptr, (TPM2B_DIGEST*)rsa) +static inline BYTE* pack_TPM2B_PRIVATE(BYTE* ptr, const TPM2B_PRIVATE *Private) { ptr = pack_UINT16(ptr, Private->size); ptr = pack_TPM_BUFFER(ptr, Private->buffer, Private->size); return ptr; } +static inline BYTE* unpack_TPM2B_PRIVATE(BYTE* ptr, TPM2B_PRIVATE *Private) { ptr = unpack_UINT16(ptr, &Private->size); ptr = unpack_BUFFER(ptr, Private->buffer, Private->size); return ptr; } +static inline BYTE* pack_TPMS_PCR_SELECTION_ARRAY(BYTE* ptr, const TPMS_PCR_SELECTION *sel, UINT32 count) { int i; for (i = 0; i < count; i++) { ptr = pack_TPMI_ALG_HASH(ptr, &sel[i].hash); ptr = pack_BYTE(ptr, sel[i].sizeofSelect); ptr = pack_BUFFER(ptr, sel[i].pcrSelect, sel[i].sizeofSelect); } return ptr; } +static inline BYTE* unpack_TPMS_PCR_SELECTION_ARRAY(BYTE* ptr, TPMS_PCR_SELECTION *sel, UINT32 count) { int i; for (i = 0; i < count; i++) { ptr = unpack_TPMI_ALG_HASH(ptr, &sel[i].hash); ptr = unpack_BYTE(ptr, &sel[i].sizeofSelect); ptr = unpack_BUFFER(ptr, sel[i].pcrSelect, sel[i].sizeofSelect); } return ptr; } +static inline BYTE* pack_TPML_PCR_SELECTION(BYTE* ptr, const TPML_PCR_SELECTION *sel) { ptr = pack_UINT32(ptr, sel->count); ptr = pack_TPMS_PCR_SELECTION_ARRAY(ptr, sel->pcrSelections, sel->count); return ptr; } +static inline BYTE* unpack_TPML_PCR_SELECTION(BYTE* ptr, TPML_PCR_SELECTION *sel) { ptr = unpack_UINT32(ptr, &sel->count); ptr = unpack_TPMS_PCR_SELECTION_ARRAY(ptr, sel->pcrSelections, sel->count); return ptr; } +static inline BYTE* unpack_TPML_DIGEST(BYTE* ptr,TPML_DIGEST *digest) { int i; ptr = unpack_UINT32(ptr, &digest->count); for (i=0;i<digest->count;i++) { ptr = unpack_TPM2B_DIGEST(ptr, &digest->digests[i]); } return ptr; } +static inline BYTE* pack_TPMS_CREATION_DATA(BYTE* ptr,const TPMS_CREATION_DATA *data) { ptr = pack_TPML_PCR_SELECTION(ptr, &data->pcrSelect); ptr = pack_TPM2B_DIGEST(ptr, &data->pcrDigest); ptr = pack_TPMA_LOCALITY(ptr, &data->locality); ptr = pack_TPM_ALG_ID(ptr, &data->parentNameAlg); ptr = pack_TPM2B_NAME(ptr, &data->parentQualifiedName); ptr = pack_TPM2B_DATA(ptr, &data->outsideInfo); return ptr; } +static inline BYTE* unpack_TPMS_CREATION_DATA(BYTE* ptr, TPMS_CREATION_DATA *data) { ptr = unpack_TPML_PCR_SELECTION(ptr, &data->pcrSelect); ptr = unpack_TPM2B_DIGEST(ptr, &data->pcrDigest); ptr = unpack_TPMA_LOCALITY(ptr, &data->locality); ptr = unpack_TPM_ALG_ID(ptr, &data->parentNameAlg); ptr = unpack_TPM2B_NAME(ptr, &data->parentName); ptr = unpack_TPM2B_NAME(ptr, &data->parentQualifiedName); ptr = unpack_TPM2B_DATA(ptr, &data->outsideInfo); return ptr; } +static inline BYTE* pack_TPM2B_CREATION_DATA(BYTE* ptr, const TPM2B_CREATION_DATA *data ) { ptr = pack_UINT16(ptr, data->size); ptr = pack_TPMS_CREATION_DATA(ptr, &data->creationData); return ptr; } +static inline BYTE* unpack_TPM2B_CREATION_DATA(BYTE* ptr, TPM2B_CREATION_DATA * data) { ptr = unpack_UINT16(ptr, &data->size); ptr = unpack_TPMS_CREATION_DATA(ptr, &data->creationData); return ptr; } +static inline BYTE* pack_TPMS_SENSITIVE_CREATE(BYTE* ptr, const TPMS_SENSITIVE_CREATE *create) { ptr = pack_TPM2B_AUTH(ptr, &create->userAuth); ptr = pack_TPM2B_SENSITIVE_DATA(ptr, &create->data); return ptr; } +static inline BYTE* pack_TPM2B_SENSITIVE_CREATE(BYTE* ptr, const TPM2B_SENSITIVE_CREATE *create) { BYTE* sizePtr = ptr; ptr += 2; ptr = pack_TPMS_SENSITIVE_CREATE(ptr, &create->sensitive); pack_UINT16(sizePtr, (UINT16)(ptr - sizePtr - 2)); return ptr; } +static inline BYTE* pack_TPMU_SYM_MODE(BYTE* ptr, const TPMU_SYM_MODE *p, const TPMI_ALG_SYM_OBJECT *sel) { switch(*sel) { case TPM2_ALG_AES: ptr = pack_TPMI_ALG_SYM_MODE(ptr, &p->aes); break; case TPM2_ALG_SM4: assert(false); break; case TPM2_ALG_NULL: case TPM2_ALG_XOR: break; default: ptr = pack_TPMI_ALG_SYM_MODE(ptr, &p->sym); } return ptr; } +static inline BYTE* unpack_TPMU_SYM_MODE(BYTE* ptr, TPMU_SYM_MODE *p, const TPMI_ALG_SYM_OBJECT *sel) { switch(*sel) { case TPM2_ALG_AES: ptr = unpack_TPMI_ALG_SYM_MODE(ptr, &p->aes); break; case TPM2_ALG_SM4: assert(false); break; case TPM2_ALG_NULL: case TPM2_ALG_XOR: break; default: ptr = unpack_TPMI_ALG_SYM_MODE(ptr, &p->sym); } return ptr; } +static inline BYTE* pack_TPMU_SYM_KEY_BITS(BYTE* ptr, const TPMU_SYM_KEY_BITS *p, const TPMI_ALG_SYM_OBJECT *sel) { switch(*sel) { case TPM2_ALG_AES: ptr = pack_TPMI_AES_KEY_BITS(ptr, &p->aes); break; case TPM2_ALG_SM4: assert(false); break; case TPM2_ALG_XOR: assert(false); break; case TPM2_ALG_NULL: break; default: ptr = pack_TPM_KEY_BITS(ptr, &p->sym); } return ptr; } +static inline BYTE* unpack_TPMU_SYM_KEY_BITS(BYTE* ptr, TPMU_SYM_KEY_BITS *p, const TPMI_ALG_SYM_OBJECT *sel) { switch(*sel) { case TPM2_ALG_AES: ptr = unpack_TPMI_AES_KEY_BITS(ptr, &p->aes); break; case TPM2_ALG_SM4: assert(false); break; case TPM2_ALG_XOR: assert(false); break; case TPM2_ALG_NULL: break; default: ptr = unpack_TPM_KEY_BITS(ptr, &p->sym); } return ptr; } +static inline BYTE* pack_TPMT_SYM_DEF_OBJECT(BYTE* ptr, const TPMT_SYM_DEF_OBJECT *p) { ptr = pack_TPMI_ALG_SYM_OBJECT(ptr, &p->algorithm); ptr = pack_TPMU_SYM_KEY_BITS(ptr, &p->keyBits, &p->algorithm); ptr = pack_TPMU_SYM_MODE(ptr, &p->mode, &p->algorithm); return ptr; } +static inline BYTE* unpack_TPMT_SYM_DEF_OBJECT(BYTE *ptr, TPMT_SYM_DEF_OBJECT *p) { ptr = unpack_TPMI_ALG_SYM_OBJECT(ptr, &p->algorithm); ptr = unpack_TPMU_SYM_KEY_BITS(ptr, &p->keyBits, &p->algorithm); ptr = unpack_TPMU_SYM_MODE(ptr, &p->mode, &p->algorithm); return ptr; } #define pack_TPMS_SCHEME_OAEP(p, t) pack_TPMI_ALG_HASH(p, &((t)->hashAlg)) #define unpack_TPMS_SCHEME_OAEP(p, t) unpack_TPMI_ALG_HASH(p, &((t)->hashAlg)) +static inline BYTE* pack_TPMU_ASYM_SCHEME(BYTE *ptr, const TPMU_ASYM_SCHEME *p, const TPMI_ALG_RSA_SCHEME *s) { switch(*s) { #ifdef TPM2_ALG_RSASSA case TPM2_ALG_RSASSA: assert(false || "TPM2_ALG_RSASSA"); break; #endif #ifdef TPM2_ALG_OAEP case TPM2_ALG_OAEP: ptr = pack_TPMS_SCHEME_OAEP(ptr, &p->oaep); break; #endif case TPM2_ALG_NULL: break; default: assert(false || "DEFAULT"); } return ptr; } +static inline BYTE* unpack_TPMU_ASYM_SCHEME(BYTE *ptr, TPMU_ASYM_SCHEME *p, const TPMI_ALG_RSA_SCHEME *s) { switch(*s) { #ifdef TPM2_ALG_RSASSA case TPM2_ALG_RSASSA: printf("not support TPM_ALG_RSASSA\n"); assert(false); break; #endif #ifdef TPM2_ALG_OAEP case TPM2_ALG_OAEP: ptr = unpack_TPMS_SCHEME_OAEP(ptr, &p->oaep); break; #endif case TPM2_ALG_NULL: break; default: printf("default TPMI_ALG_RSA_SCHEME 0x%X\n", (UINT32)*s); ptr = unpack_TPMI_ALG_HASH(ptr, &p->anySig.hashAlg); } return ptr; } +static inline BYTE* pack_TPMT_RSA_SCHEME(BYTE* ptr, const TPMT_RSA_SCHEME *p) { ptr = pack_TPMI_ALG_RSA_SCHEME(ptr, &p->scheme); ptr = pack_TPMU_ASYM_SCHEME(ptr, &p->details, &p->scheme); return ptr; } +static inline BYTE* unpack_TPMT_RSA_SCHEME(BYTE* ptr, TPMT_RSA_SCHEME *p) { ptr = unpack_TPMI_ALG_RSA_SCHEME(ptr, &p->scheme); ptr = unpack_TPMU_ASYM_SCHEME(ptr, &p->details, &p->scheme); return ptr; } +static inline BYTE* pack_TPMT_RSA_DECRYPT(BYTE* ptr, const TPMT_RSA_DECRYPT *p) { ptr = pack_TPMI_ALG_RSA_SCHEME(ptr, &p->scheme); ptr = pack_TPMU_ASYM_SCHEME(ptr, &p->details, &p->scheme); return ptr; } +static inline BYTE* pack_TPMS_RSA_PARMS(BYTE* ptr, const TPMS_RSA_PARMS *p) { ptr = pack_TPMT_SYM_DEF_OBJECT(ptr, &p->symmetric); ptr = pack_TPMT_RSA_SCHEME(ptr, &p->scheme); ptr = pack_TPMI_RSA_KEY_BITS(ptr, &p->keyBits); ptr = pack_UINT32(ptr, p->exponent); return ptr; } +static inline BYTE* unpack_TPMS_RSA_PARMS(BYTE *ptr, TPMS_RSA_PARMS *p) { ptr = unpack_TPMT_SYM_DEF_OBJECT(ptr, &p->symmetric); ptr = unpack_TPMT_RSA_SCHEME(ptr, &p->scheme); ptr = unpack_TPMI_RSA_KEY_BITS(ptr, &p->keyBits); ptr = unpack_UINT32(ptr, &p->exponent); return ptr; } +static inline BYTE* pack_TPMU_PUBLIC_PARMS(BYTE* ptr, const TPMU_PUBLIC_PARMS *param, const TPMI_ALG_PUBLIC *selector) { switch(*selector) { case TPM2_ALG_KEYEDHASH: assert(false); case TPM2_ALG_SYMCIPHER: assert(false); case TPM2_ALG_RSA: return pack_TPMS_RSA_PARMS(ptr, ¶m->rsaDetail); case TPM2_ALG_ECC: assert(false); } assert(false); return NULL; } +static inline BYTE* unpack_TPMU_PUBLIC_PARMS(BYTE* ptr, TPMU_PUBLIC_PARMS *param, const TPMI_ALG_PUBLIC *selector) { switch(*selector) { case TPM2_ALG_KEYEDHASH: assert(false); case TPM2_ALG_SYMCIPHER: assert(false); case TPM2_ALG_RSA: return unpack_TPMS_RSA_PARMS(ptr, ¶m->rsaDetail); case TPM2_ALG_ECC: assert(false); } assert(false); return NULL; } +static inline BYTE* pack_TPMS_ECC_POINT(BYTE* ptr, const TPMS_ECC_POINT *point) { assert(false); return ptr; } +static inline BYTE* unpack_TPMS_ECC_POINT(BYTE* ptr, TPMS_ECC_POINT *point) { assert(false); return ptr; } +static inline BYTE* pack_TPMU_PUBLIC_ID(BYTE* ptr, const TPMU_PUBLIC_ID *id, const TPMI_ALG_PUBLIC *selector) { switch (*selector) { case TPM2_ALG_KEYEDHASH: return pack_TPM2B_DIGEST(ptr, &id->keyedHash); case TPM2_ALG_SYMCIPHER: return pack_TPM2B_DIGEST(ptr, &id->sym); case TPM2_ALG_RSA: return pack_TPM2B_PUBLIC_KEY_RSA(ptr, &id->rsa); case TPM2_ALG_ECC: return pack_TPMS_ECC_POINT(ptr, &id->ecc); } assert(false); return NULL; } +static inline BYTE* unpack_TPMU_PUBLIC_ID(BYTE* ptr, TPMU_PUBLIC_ID *id, TPMI_ALG_PUBLIC *selector) { switch (*selector) { case TPM2_ALG_KEYEDHASH: return unpack_TPM2B_DIGEST(ptr, &id->keyedHash); case TPM2_ALG_SYMCIPHER: return unpack_TPM2B_DIGEST(ptr, &id->sym); case TPM2_ALG_RSA: return unpack_TPM2B_PUBLIC_KEY_RSA(ptr, &id->rsa); case TPM2_ALG_ECC: return unpack_TPMS_ECC_POINT(ptr, &id->ecc); } assert(false); return NULL; } +static inline BYTE* pack_TPMT_PUBLIC(BYTE* ptr, const TPMT_PUBLIC *public) { ptr = pack_TPMI_ALG_PUBLIC(ptr, &public->type); ptr = pack_TPMI_ALG_HASH(ptr, &public->nameAlg); ptr = pack_TPMA_OBJECT(ptr, &public->objectAttributes); ptr = pack_TPM2B_DIGEST(ptr, &public->authPolicy); ptr = pack_TPMU_PUBLIC_PARMS(ptr, &public->parameters, &public->type); ptr = pack_TPMU_PUBLIC_ID(ptr, &public->unique, &public->type); return ptr; } +static inline BYTE* unpack_TPMT_PUBLIC(BYTE* ptr, TPMT_PUBLIC *public) { ptr = unpack_TPMI_ALG_PUBLIC(ptr, &public->type); ptr = unpack_TPMI_ALG_HASH(ptr, &public->nameAlg); ptr = unpack_TPMA_OBJECT(ptr, &public->objectAttributes); ptr = unpack_TPM2B_DIGEST(ptr, &public->authPolicy); ptr = unpack_TPMU_PUBLIC_PARMS(ptr, &public->parameters, &public->type); ptr = unpack_TPMU_PUBLIC_ID(ptr, &public->unique, &public->type); return ptr; } +static inline BYTE* pack_TPM2B_PUBLIC(BYTE* ptr, const TPM2B_PUBLIC *public) { BYTE *sizePtr = ptr; ptr += 2; ptr = pack_TPMT_PUBLIC(ptr, &public->publicArea); pack_UINT16(sizePtr, (UINT16)(ptr - sizePtr - 2)); return ptr; } +static inline BYTE* unpack_TPM2B_PUBLIC(BYTE* ptr, TPM2B_PUBLIC *public) { ptr = unpack_UINT16(ptr, &public->size); ptr = unpack_TPMT_PUBLIC(ptr, &public->publicArea); return ptr; } +static inline BYTE* pack_TPMS_PCR_SELECTION(BYTE* ptr, const TPMS_PCR_SELECTION *selection) { ptr = pack_TPMI_ALG_HASH(ptr, &selection->hash); ptr = pack_BYTE(ptr, selection->sizeofSelect); ptr = pack_BYTE_ARRAY(ptr, selection->pcrSelect, selection->sizeofSelect); return ptr; } +static inline BYTE* pack_TPMS_PCR_SELECTION_Array(BYTE* ptr, const TPMS_PCR_SELECTION *selections, const UINT32 cnt) { int i; for (i = 0; i < cnt; i++) ptr = pack_TPMS_PCR_SELECTION(ptr, selections + i); return ptr; } +static inline BYTE* pack_TPM_AuthArea(BYTE* ptr, const TPM_AuthArea *auth) { BYTE* sizePtr = ptr; ptr += sizeof(UINT32); ptr = pack_TPM_RH(ptr, &auth->sessionHandle); ptr = pack_TPM2B_NONCE(ptr, &auth->nonce); ptr = pack_TPMA_SESSION(ptr, &auth->sessionAttributes); ptr = pack_TPM2B_AUTH(ptr, &auth->auth); pack_UINT32(sizePtr, ptr - sizePtr - sizeof(UINT32)); return ptr; } +static inline BYTE* unpack_TPM_AuthArea(BYTE* ptr, TPM_AuthArea *auth) { ptr = unpack_UINT32(ptr, &auth->size); ptr = unpack_TPM_RH(ptr, &auth->sessionHandle); ptr = unpack_TPM2B_NONCE(ptr, &auth->nonce); ptr = unpack_TPMA_SESSION(ptr, &auth->sessionAttributes); ptr = unpack_TPM2B_AUTH(ptr, &auth->auth); return ptr; } +static inline BYTE* pack_TPM2_RSA_KEY(BYTE* ptr, const TPM2_RSA_KEY *key) { ptr = pack_TPM2B_PRIVATE(ptr, &key->Private); ptr = pack_TPM2B_PUBLIC(ptr, &key->Public); return ptr; } +static inline BYTE* unpack_TPM2_RSA_KEY(BYTE* ptr, TPM2_RSA_KEY *key) { ptr = unpack_TPM2B_PRIVATE(ptr, &key->Private); ptr = unpack_TPM2B_PUBLIC(ptr, &key->Public); return ptr; } #endif --- a/stubdom/vtpmmgr/tpmrsa.h +++ b/stubdom/vtpmmgr/tpmrsa.h @@ -53,17 +53,18 @@ void tpmrsa_set_pubkey(tpmrsa_context* ctx, /* Check an RSA signature */ TPM_RESULT tpmrsa_sigcheck(tpmrsa_context *ctx, const unsigned char *input, const unsigned char *sha1); /* Do rsa public crypto */ TPM_RESULT tpmrsa_pub_encrypt_oaep( tpmrsa_context *ctx, int (*f_rng)(void *, unsigned char *, size_t), void *p_rng, size_t ilen, const unsigned char *input, unsigned char *output ); /* free tpmrsa key */ +static inline void tpmrsa_free( tpmrsa_context *ctx ) { mpi_free( &ctx->RN ); mpi_free( &ctx->E ); mpi_free( &ctx->N ); } #endif /* tpmrsa.h */
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
