vtpmmgr: Convert TPM_Seal to use TPM_PCR_INFO_LONG

Infineon 1.2 TPMs fail TPM_Seal commands with TPM_BAD_PARAMETER when
PCRS are specified by a TPM_PCR_INFO structure.  Using a
TPM_PCR_INFO_LONG structure to specify PCRs succeeds, so update to use
that.  This also requires changes to use TPM_STORED_DATA12 for the
result.

Signed-off-by: Jason Andryuk <andryuk@aero.org>
Acked-by: Daniel De Graaf <dgdegra@tycho.nsa.gov>

diff --git a/vtpmmgr/disk_tpm.c b/vtpmmgr/disk_tpm.c
index 6f5d5565c76b3cedbb3e685278ad8012212fb002..a9f455255a350e8a6ee5ceaa3b539a60fad5d1bb 100644 (file)
--- a/vtpmmgr/disk_tpm.c
+++ b/vtpmmgr/disk_tpm.c
@@ -74,12 +74,15 @@ void TPM_pcr_digest(struct hash160 *buf, le32_t selection)
 int TPM_disk_seal(struct disk_seal_entry *dst, const void* src, size_t size)
 {
        uint32_t rc;
-       TPM_PCR_INFO info;
-       TPM_STORED_DATA out;
+       uint32_t infoSize;
+       TPM_PCR_INFO_LONG info;
+       TPM_STORED_DATA12 out;
        TPM_AUTH_SESSION osap = TPM_AUTH_SESSION_INIT;
        TPM_AUTHDATA sharedsecret;
        TPM_AUTHDATA auth;
 
+       printk("Calling TPM_disk_seal\n");
+
        rc = TPM_OSAP(TPM_ET_KEYHANDLE, TPM_SRK_KEYHANDLE, (void*)&vtpm_globals.srk_auth,
                        &sharedsecret, &osap);
 
@@ -94,18 +97,26 @@ int TPM_disk_seal(struct disk_seal_entry *dst, const void* src, size_t size)
 #endif
 
        memset(auth, 0, 20);
-       info.pcrSelection.sizeOfSelect = 3;
-       info.pcrSelection.pcrSelect = (void*)&dst->pcr_selection;
+       info.tag = TPM_TAG_PCR_INFO_LONG;
+       info.localityAtCreation = 1 << vtpm_globals.hw_locality;
+       info.localityAtRelease = 1 << vtpm_globals.hw_locality;
+       info.creationPCRSelection.sizeOfSelect = 3;
+       info.creationPCRSelection.pcrSelect = (void*)&dst->pcr_selection;
+       info.releasePCRSelection.sizeOfSelect = 3;
+       info.releasePCRSelection.pcrSelect = (void*)&dst->pcr_selection;
        memcpy(&info.digestAtCreation, &dst->digest_at_seal, 20);
        memcpy(&info.digestAtRelease, &dst->digest_release, 20);
 
-       rc = TPM_Seal(TPM_SRK_KEYHANDLE, 45, &info, size, src, &out,
+       infoSize = 2 + 1 + 1 + 2 + 3 + 2 + 3 + 20 + 20;
+       //infoSize = sizeof_TPM_PCR_INFO_LONG(&info);
+
+       rc = TPM_Seal(TPM_SRK_KEYHANDLE, infoSize, &info, size, src, &out,
                        (void*)&sharedsecret, (void*)&auth, &osap);
 
        TPM_TerminateHandle(osap.AuthHandle);
 
 #ifdef DEBUG_SEAL_OPS
-       printk("TPM_Seal rc=%d encDataSize=%d sealInfoSize=%d\n", rc, out.encDataSize, out.sealInfoSize);
+       printk("TPM_Seal rc=%d encDataSize=%d sealInfoSize=%d\n", rc, out.encDataSize, out.sealInfoLongSize);
 #endif
        if (!rc)
                memcpy(dst->sealed_data, out.encData, 256);
@@ -113,7 +124,7 @@ int TPM_disk_seal(struct disk_seal_entry *dst, const void* src, size_t size)
 #ifdef DEBUG_SEAL_OPS
        uint8_t buf[512];
        uint8_t *start = buf;
-       uint8_t *end = pack_TPM_STORED_DATA(buf, &out);
+       uint8_t *end = pack_TPM_STORED_DATA12(buf, &out);
        printk("stored_data:");
        while (start != end) {
                printk(" %02x", *start);
@@ -122,37 +133,46 @@ int TPM_disk_seal(struct disk_seal_entry *dst, const void* src, size_t size)
        printk("\n");
 #endif
 
-       free_TPM_STORED_DATA(&out);
+       free_TPM_STORED_DATA12(&out);
        return rc;
 }
 
 int TPM_disk_unseal(void *dst, size_t size, const struct disk_seal_entry *src)
 {
        uint32_t rc;
-       TPM_STORED_DATA in;
+       TPM_STORED_DATA12 in;
        TPM_AUTH_SESSION oiap = TPM_AUTH_SESSION_INIT;
        TPM_AUTHDATA auth;
        uint32_t outSize = 0;
        uint8_t *out = NULL;
 
+       printk("Calling TPM_disk_unseal\n");
+
        rc = TPM_OIAP(&oiap);
        if (rc) abort();
 
        memset(auth, 0, 20);
 
-       in.ver = TPM_STRUCT_VER_1_1;
-       in.sealInfoSize = 45;
-       in.sealInfo.pcrSelection.sizeOfSelect = 3;
-       in.sealInfo.pcrSelection.pcrSelect = (void*)&src->pcr_selection;
-       memcpy(&in.sealInfo.digestAtCreation, &src->digest_at_seal, 20);
-       memcpy(&in.sealInfo.digestAtRelease, &src->digest_release, 20);
+       in.tag = TPM_TAG_STORED_DATA12;
+       in.et = 0;
+       //in.sealInfoLongSize = sizeof_TPM_PCR_INFO_LONG(&in.sealInfoLong);
+       in.sealInfoLongSize = 2 + 1 + 1 + 2 + 3 + 2 + 3 + 20 + 20;
+       in.sealInfoLong.tag = TPM_TAG_PCR_INFO_LONG;
+       in.sealInfoLong.localityAtCreation = 1 << vtpm_globals.hw_locality;
+       in.sealInfoLong.localityAtRelease = 1 << vtpm_globals.hw_locality;
+       in.sealInfoLong.creationPCRSelection.sizeOfSelect = 3;
+       in.sealInfoLong.creationPCRSelection.pcrSelect = (void*)&src->pcr_selection;
+       in.sealInfoLong.releasePCRSelection.sizeOfSelect = 3;
+       in.sealInfoLong.releasePCRSelection.pcrSelect = (void*)&src->pcr_selection;
+       memcpy(&in.sealInfoLong.digestAtCreation, &src->digest_at_seal, 20);
+       memcpy(&in.sealInfoLong.digestAtRelease, &src->digest_release, 20);
        in.encDataSize = 256;
        in.encData = (void*)src->sealed_data;
 
 #ifdef DEBUG_SEAL_OPS
        uint8_t buf[512];
        uint8_t *start = buf;
-       uint8_t *end = pack_TPM_STORED_DATA(buf, &in);
+       uint8_t *end = pack_TPM_STORED_DATA12(buf, &in);
        printk("stored_data:");
        while (start != end) {
                printk(" %02x", *start);

diff --git a/vtpmmgr/marshal.h b/vtpmmgr/marshal.h
index ef542720b5bda77a73f632c150d4fc387a2c8fdb..bcc7c46be2be91965eb635bc0527acd78436bee8 100644 (file)
--- a/vtpmmgr/marshal.h
+++ b/vtpmmgr/marshal.h
@@ -142,6 +142,7 @@ inline int unpack3_UINT32(BYTE* ptr, UINT32* pos, UINT32 max, UINT32 *t)
 #define pack_TPM_MIGRATE_SCHEME(p, t) pack_UINT16(p, t)
 #define pack_TPM_PHYSICAL_PRESENCE(p, t) pack_UINT16(p, t)
 #define pack_TPM_KEY_FLAGS(p, t) pack_UINT32(p, t)
+#define pack_TPM_LOCALITY_SELECTION(p, t) pack_BYTE(p, t)
 
 #define unpack_TPM_RESULT(p, t) unpack_UINT32(p, t)
 #define unpack_TPM_PCRINDEX(p, t) unpack_UINT32(p, t)
@@ -167,6 +168,7 @@ inline int unpack3_UINT32(BYTE* ptr, UINT32* pos, UINT32 max, UINT32 *t)
 #define unpack_TPM_MIGRATE_SCHEME(p, t) unpack_UINT16(p, t)
 #define unpack_TPM_PHYSICAL_PRESENCE(p, t) unpack_UINT16(p, t)
 #define unpack_TPM_KEY_FLAGS(p, t) unpack_UINT32(p, t)
+#define unpack_TPM_LOCALITY_SELECTION(p, t) unpack_BYTE(p, t)
 
 #define unpack3_TPM_RESULT(p, l, m, t) unpack3_UINT32(p, l, m, t)
 #define unpack3_TPM_PCRINDEX(p, l, m, t) unpack3_UINT32(p, l, m, t)
@@ -192,6 +194,7 @@ inline int unpack3_UINT32(BYTE* ptr, UINT32* pos, UINT32 max, UINT32 *t)
 #define unpack3_TPM_MIGRATE_SCHEME(p, l, m, t) unpack3_UINT16(p, l, m, t)
 #define unpack3_TPM_PHYSICAL_PRESENCE(p, l, m, t) unpack3_UINT16(p, l, m, t)
 #define unpack3_TPM_KEY_FLAGS(p, l, m, t) unpack3_UINT32(p, l, m, t)
+#define unpack3_TPM_LOCALITY_SELECTION(p, l, m, t) unpack3_BYTE(p, l, m, t)
 
 #define sizeof_TPM_RESULT(t) sizeof_UINT32(t)
 #define sizeof_TPM_PCRINDEX(t) sizeof_UINT32(t)
@@ -217,6 +220,7 @@ inline int unpack3_UINT32(BYTE* ptr, UINT32* pos, UINT32 max, UINT32 *t)
 #define sizeof_TPM_MIGRATE_SCHEME(t) sizeof_UINT16(t)
 #define sizeof_TPM_PHYSICAL_PRESENCE(t) sizeof_UINT16(t)
 #define sizeof_TPM_KEY_FLAGS(t) sizeof_UINT32(t)
+#define sizeof_TPM_LOCALITY_SELECTION(t) sizeof_BYTE(t)
 
 #define pack_TPM_AUTH_HANDLE(p, t) pack_UINT32(p, t)
 #define pack_TCS_CONTEXT_HANDLE(p, t) pack_UINT32(p, t)
@@ -312,6 +316,7 @@ inline int unpack3_TPM_AUTHDATA(BYTE* ptr, UINT32* pos, UINT32 len, TPM_AUTHDATA
 #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)
@@ -593,6 +598,43 @@ inline int sizeof_TPM_PCR_INFO(const TPM_PCR_INFO* p) {
        return rc;
 }
 
+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;
+}
+
+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;
+}
+
+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);
+}
 
 inline BYTE* pack_TPM_PCR_COMPOSITE(BYTE* ptr, const TPM_PCR_COMPOSITE* p) {
        ptr = pack_TPM_PCR_SELECTION(ptr, &p->select);
@@ -703,6 +745,46 @@ inline int unpack3_TPM_STORED_DATA(BYTE* ptr, UINT32* pos, UINT32 len, TPM_STORE
        return rc;
 }
 
+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;
+}
+
+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;
+}
+
+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;
+}
+
 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);

diff --git a/vtpmmgr/tcg.h b/vtpmmgr/tcg.h
index f4c8bc0c0ce7bd5c34b458c9b5b1c6f63e915367..7321ec643ded12876a3aca4793b5d32d35ddb1d2 100644 (file)
--- a/vtpmmgr/tcg.h
+++ b/vtpmmgr/tcg.h
@@ -259,6 +259,8 @@
 #define TPM_ST_DEACTIVATED 0x003
 
 // TPM_TAG values
+#define TPM_TAG_PCR_INFO_LONG 0x0006
+#define TPM_TAG_STORED_DATA12 0x0016
 #define TPM_TAG_RQU_COMMAND 0x00c1
 #define TPM_TAG_RQU_AUTH1_COMMAND 0x00c2
 #define TPM_TAG_RQU_AUTH2_COMMAND 0x00c3
@@ -582,6 +584,26 @@ inline void free_TPM_PCR_SELECTION(TPM_PCR_SELECTION* p) {
    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 }
+
+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;
@@ -667,6 +689,26 @@ inline void free_TPM_STORED_DATA(TPM_STORED_DATA* d) {
    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 }
+
+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

diff --git a/vtpmmgr/tpm.c b/vtpmmgr/tpm.c
index 0548e5c02cca0c7e12506ac396c948bf44e5dd3a..779cddd64ea88764ea6f0624444fda99439967af 100644 (file)
--- a/vtpmmgr/tpm.c
+++ b/vtpmmgr/tpm.c
@@ -492,11 +492,11 @@ abort_egress:
 
 TPM_RESULT TPM_Seal(
                TPM_KEY_HANDLE  keyHandle,  // in
-               UINT32   pcrInfoSize, // in
-               TPM_PCR_INFO*    pcrInfo,  // in
+               UINT32   pcrInfoLongSize, // in
+               TPM_PCR_INFO_LONG*       pcrInfoLong,  // in
                UINT32   inDataSize,  // in
                const BYTE*      inData,        // in
-               TPM_STORED_DATA* sealedData, //out
+               TPM_STORED_DATA12* sealedData, //out
                const TPM_SECRET* osapSharedSecret, //in
                const TPM_AUTHDATA* sealedDataAuth, //in
                TPM_AUTH_SESSION*       pubAuth  // in, out
@@ -509,28 +509,30 @@ TPM_RESULT TPM_Seal(
 
        xorEncrypt(osapSharedSecret, &pubAuth->NonceEven, sealedDataAuth, IN_PTR, NULL, NULL);
        in_pos += sizeof(TPM_ENCAUTH);
-       PACK_IN(UINT32, pcrInfoSize);
-       if (pcrInfoSize)
-               PACK_IN(TPM_PCR_INFO, pcrInfo);
+
+       PACK_IN(UINT32, pcrInfoLongSize);
+       if (pcrInfoLongSize) {
+               PACK_IN(TPM_PCR_INFO_LONG, pcrInfoLong);
+       }
        PACK_IN(UINT32, inDataSize);
        PACK_IN(BUFFER, inData, inDataSize);
 
        TPM_XMIT_AUTH1(osapSharedSecret, pubAuth);
 
-       UNPACK_OUT(TPM_STORED_DATA, sealedData, UNPACK_ALLOC);
+       UNPACK_OUT(TPM_STORED_DATA12, sealedData, UNPACK_ALLOC);
 
        TPM_END_AUTH1(osapSharedSecret, pubAuth);
 
  abort_egress:
        if (status)
-               free_TPM_STORED_DATA(sealedData);
+               free_TPM_STORED_DATA12(sealedData);
        TPM_AUTH_ERR_CHECK(pubAuth);
        return status;
 }
 
 TPM_RESULT TPM_Unseal(
                TPM_KEY_HANDLE parentHandle, // in
-               const TPM_STORED_DATA* sealedData,
+               const TPM_STORED_DATA12* sealedData,
                UINT32* outSize,  // out
                BYTE**   out, //out
                const TPM_AUTHDATA* key_usage_auth, //in
@@ -544,7 +546,7 @@ TPM_RESULT TPM_Unseal(
        PACK_IN(TPM_KEY_HANDLE, parentHandle);
 
        TPM_HASH_IN_BEGIN;
-       PACK_IN(TPM_STORED_DATA, sealedData);
+       PACK_IN(TPM_STORED_DATA12, sealedData);
 
        TPM_XMIT_AUTH2(key_usage_auth, keyAuth, data_usage_auth, dataAuth);
 

diff --git a/vtpmmgr/tpm.h b/vtpmmgr/tpm.h
index 21619769bf0436d5c516d7b72a2f6f346feb10db..d613eb3b758ce74d3526fc8383e3c0688fca0275 100644 (file)
--- a/vtpmmgr/tpm.h
+++ b/vtpmmgr/tpm.h
@@ -88,11 +88,11 @@ TPM_RESULT TPM_Reset(TPM_PCR_SELECTION *sel);
 
 TPM_RESULT TPM_Seal(
       TCS_KEY_HANDLE  keyHandle,  // in
-      UINT32    pcrInfoSize, // in
-      TPM_PCR_INFO*    pcrInfo,  // in
+      UINT32    pcrInfoLongSize, // in
+      TPM_PCR_INFO_LONG*    pcrInfoLong,  // in
       UINT32    inDataSize,  // in
       const BYTE*    inData,   // in
-      TPM_STORED_DATA* sealedData, //out
+      TPM_STORED_DATA12* sealedData, //out
       const TPM_SECRET* osapSharedSecret, //in
       const TPM_AUTHDATA* sealDataAuth, //in
       TPM_AUTH_SESSION*   pubAuth  // in, out
@@ -100,7 +100,7 @@ TPM_RESULT TPM_Seal(
 
 TPM_RESULT TPM_Unseal (
       TPM_KEY_HANDLE parentHandle, // in
-      const TPM_STORED_DATA* sealedData,
+      const TPM_STORED_DATA12* sealedData,
       UINT32*   outSize,  // out
       BYTE**    out, //out
       const TPM_AUTHDATA* key_usage_auth, //in