int TSPI_SealCurrPCR(TSS_HCONTEXT c, uint32_t keyhandle, uint32_t pcrmap,
unsigned char *keyauth,
unsigned char *dataauth,
unsigned char *data, unsigned int datalen,
unsigned char *blob, unsigned int *bloblen)
{
#define CHECK_ERROR(r,m) if (r != TSS_SUCCESS) { fprintf(stderr, m ": 0x%08x\n", r); return -1;}
TSS_RESULT r = 0;
TSS_HTPM tpm;
TSS_HPCRS pcrComposite;
TSS_UUID uuid;
TSS_UUID srk_uuid = TSS_UUID_SRK;
TSS_HKEY key;
TSS_HENCDATA seal;
TSS_HPOLICY key_policy, seal_policy;
unsigned char *cipher;
unsigned int cipher_len;
/* Get the PCR values into composite object */
r = Tspi_Context_GetTpmObject(c, &tpm);
CHECK_ERROR(r, "Error Getting TPM");
r = Tspi_Context_CreateObject(c, TSS_OBJECT_TYPE_PCRS, TSS_PCRS_STRUCT_INFO_LONG, &pcrComposite);
CHECK_ERROR(r, "Error Creating PCR-Composite");
r = Tspi_PcrComposite_SetPcrLocality(pcrComposite, TPM_LOC_ZERO | TPM_LOC_ONE |
TPM_LOC_TWO | TPM_LOC_THREE | TPM_LOC_FOUR);
CHECK_ERROR(r, "Error Setting Localities");
for (uint32_t pcrmask = 1, pcr = 0; pcr < NUM_PCRS; pcr++, pcrmask <<= 1) {
if ((pcrmap & pcrmask) != 0) {
uint32_t pcrval_size;
uint8_t *pcrval;
if (pcrvals[pcr] == NULL) {
r = Tspi_TPM_PcrRead(tpm, pcr, &pcrval_size, &pcrval);
CHECK_ERROR(r, "Error Reading PCR");
r = Tspi_PcrComposite_SetPcrValue(pcrComposite, pcr, pcrval_size, pcrval);
CHECK_ERROR(r, "Error Setting Composite");
r = Tspi_Context_FreeMemory(c, pcrval);
CHECK_ERROR(r, "Error Freeing Memory");
}
else {
pcrval = pcrvals[pcr];
r = Tspi_PcrComposite_SetPcrValue(pcrComposite, pcr, LEN, pcrval);
CHECK_ERROR(r, "Error Setting Composite");
}
}
}
/* Get the SRK and Policy Ready */
if (keyhandle = 0x40000000) {
uuid = srk_uuid;
} else {
fprintf(stderr, "Error, only SRK currently supported\n");
r = 1;
return -1;
}
r = Tspi_Context_LoadKeyByUUID(c, TSS_PS_TYPE_SYSTEM, uuid, &key);
CHECK_ERROR(r, "Error Loading Key");
r = Tspi_Context_CreateObject(c, TSS_OBJECT_TYPE_POLICY, TSS_POLICY_USAGE, &key_policy);
CHECK_ERROR(r, "Error Creating Policy");
r = Tspi_Policy_SetSecret(key_policy, TSS_SECRET_MODE_SHA1, keylen, keyauth);
CHECK_ERROR(r, "Error Setting Secret");
r = Tspi_Policy_AssignToObject(key_policy, key);
CHECK_ERROR(r, "Error Assigning Policy");
/* Get the Encdata Ready */
r = Tspi_Context_CreateObject(c, TSS_OBJECT_TYPE_ENCDATA, TSS_ENCDATA_SEAL, &seal);
CHECK_ERROR(r, "Error Creating EncData");
r = Tspi_Context_CreateObject(c, TSS_OBJECT_TYPE_POLICY, TSS_POLICY_USAGE, &seal_policy);
CHECK_ERROR(r, "Error Creating Policy");
r = Tspi_Policy_SetSecret(seal_policy, TSS_SECRET_MODE_SHA1, keylen, dataauth);
CHECK_ERROR(r, "Error Setting Secret");
r = Tspi_Policy_AssignToObject(seal_policy, seal);
CHECK_ERROR(r, "Error Assigning Policy");
/* Seal the Data */
r = Tspi_Data_Seal(seal, key, datalen, data, pcrComposite);
CHECK_ERROR(r, "Error Sealing Data");
r = Tspi_GetAttribData(seal, TSS_TSPATTRIB_ENCDATA_BLOB,
TSS_TSPATTRIB_ENCDATABLOB_BLOB,
&cipher_len, &cipher);
CHECK_ERROR(r, "Error Getting Sealed Data");
/* Return that stuff */
if (cipher_len > bloblen) {
sprintf(stderr, "Internal Error, cipher too long");
r = 1;
return -1;
}
memcpy(blob, cipher, cipher_len);
*bloblen = cipher_len;
/* Note: Do not even bother to return cipher directly. Would be freed during Context_Close anyways */
Tspi_Context_FreeMemory(c, cipher);
return (r == 0)? 0 : -1;
}
int
main_v1_2(char version)
{
char *function = "Tspi_Data_Seal-trans02";
TSS_HCONTEXT hContext;
TSS_HKEY hSRK;
TSS_HKEY hKey, hSigningKey, hWrappingKey;
TSS_HPOLICY hSrkPolicy;
BYTE *rgbDataToSeal = "This is a test. 1 2 3.";
BYTE rgbPcrValue[20];
TSS_HENCDATA hEncData;
TSS_HPCRS hPcrComposite;
UINT32 BlobLength;
UINT32 ulDataLength = strlen(rgbDataToSeal);
TSS_UUID uuid;
TSS_RESULT result;
TSS_HTPM hTPM;
TSS_FLAG initFlags = TSS_KEY_TYPE_SIGNING | TSS_KEY_SIZE_2048 |
TSS_KEY_VOLATILE | TSS_KEY_NO_AUTHORIZATION |
TSS_KEY_NOT_MIGRATABLE;
print_begin_test( function );
memset(rgbPcrValue, 0x5a, sizeof(rgbPcrValue));
result = connect_load_all(&hContext, &hSRK, &hTPM);
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_Create ", result);
exit(result);
}
result = Testsuite_Transport_Init(hContext, hSRK, hTPM, TRUE, TRUE, &hWrappingKey,
&hSigningKey);
if (result != TSS_SUCCESS) {
print_error("Testsuite_Transport_Init", result);
Tspi_Context_Close(hContext);
exit(result);
}
// create hKey
result = Tspi_Context_CreateObject( hContext,
TSS_OBJECT_TYPE_RSAKEY,
initFlags, &hKey );
if ( result != TSS_SUCCESS )
{
print_error( "Tspi_Context_CreateObject (hKey)", result );
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close( hContext );
exit( result );
}
result = Tspi_Context_CreateObject( hContext,
TSS_OBJECT_TYPE_ENCDATA,
TSS_ENCDATA_SEAL, &hEncData );
if ( result != TSS_SUCCESS )
{
print_error( "Tspi_Context_CreateObject (hEncData)", result );
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close( hContext );
exit( result );
}
result = Tspi_Context_CreateObject( hContext, TSS_OBJECT_TYPE_PCRS,
0, &hPcrComposite );
if ( result != TSS_SUCCESS )
{
print_error( "Tspi_Context_CreateObject (hPcrComposite)",
result );
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close( hContext );
exit( result );
}
result = Tspi_PcrComposite_SetPcrValue( hPcrComposite, 8, 20, rgbPcrValue );
if ( result != TSS_SUCCESS )
{
print_error( "Tspi_PcrComposite_SetPcrValue", result );
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close( hContext );
exit( result );
}
result = Tspi_PcrComposite_SetPcrValue( hPcrComposite, 9, 20, rgbPcrValue );
if ( result != TSS_SUCCESS )
{
print_error( "Tspi_PcrComposite_SetPcrValue", result );
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close( hContext );
exit( result );
}
// Data Seal
result = Tspi_Data_Seal( hEncData, hSRK, ulDataLength, rgbDataToSeal, hPcrComposite );
if ( result != TSS_SUCCESS )
{
print_error( "Tspi_Data_Seal", result );
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close( hContext );
exit( result );
}
result = Testsuite_Transport_Final(hContext, hSigningKey);
if ( result != TSS_SUCCESS )
{
if( !(checkNonAPI(result)) )
{
print_error( function, result );
}
else
{
print_error_nonapi( function, result );
}
}
else
{
print_success( function, result );
}
print_end_test( function );
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close( hContext );
exit(result);
}
int
main(int argc, char **argv)
{
#define BUF_LEN (1024*1024)
#define KEY_SIZE 64
TSS_RESULT result;
TSS_HCONTEXT hContext;
TSS_HKEY hSRK, hKey;
TSS_HPOLICY hPolicy;
TSS_HTPM hTPM;
TSS_HENCDATA hEncData;
TSS_HPCRS hPcrs;
UINT32 u32PcrValLen, u32EncDataLen;
BYTE *rgbPcrVal, *rgbEncData;
BYTE *random;
FILE *fpIn = NULL, *fpOut = NULL;
int len, size;
char *pBufIn = NULL, *pBufOut = NULL;
unsigned int salt[] = {12345, 54321};
EVP_CIPHER_CTX en;
TSS_UUID UUID_K1 = {0, 0, 0, 0, 0, {8, 0, 0, 0, 0, 1}} ;
if (argc < 3) {
usage(argv[0]);
return 0;
}
result = Tspi_Context_Create(&hContext);
if (TSS_SUCCESS != result) {
print_error("Tspi_Context_Create", result);
Tspi_Context_Close(hContext);
return result;
}
result = Tspi_Context_Connect(hContext, get_server(GLOBALSERVER));
if (TSS_SUCCESS != result) {
print_error("Tspi_Context_Connect", result);
Tspi_Context_Close(hContext);
return result;
}
result = Tspi_Context_GetTpmObject(hContext, &hTPM);
if (TSS_SUCCESS != result) {
print_error("Tspi_Context_GetTpmObject", result);
Tspi_Context_Close(hContext);
return result;
}
result = Tspi_Context_LoadKeyByUUID(hContext,
TSS_PS_TYPE_SYSTEM,
SRK_UUID,
&hSRK);
if (TSS_SUCCESS != result) {
print_error("Tspi_Context_LoadKeyByUUID", result);
Tspi_Context_Close(hContext);
return result;
}
#ifndef TESTSUITE_NOAUTH_SRK
result = Tspi_GetPolicyObject(hSRK, TSS_POLICY_USAGE, &hPolicy);
if (TSS_SUCCESS != result) {
print_error("Tspi_GetPolicyObject", result);
Tspi_Context_Close(hContext);
return result;
}
result = Tspi_Policy_SetSecret(hPolicy,
TESTSUITE_SRK_SECRET_MODE,
TESTSUITE_SRK_SECRET_LEN,
TESTSUITE_SRK_SECRET);
if (TSS_SUCCESS != result) {
print_error("Tspi_Policy_SetSecret", result);
Tspi_Context_Close(hContext);
return result;
}
#endif // #ifndef TESTSUITE_NOAUTH_SRK
result = Tspi_Context_CreateObject(hContext,
TSS_OBJECT_TYPE_PCRS,
0,
&hPcrs);
if (TSS_SUCCESS != result) {
print_error("Tspi_Context_CreateObject", result);
Tspi_Context_Close(hContext);
return result;
}
result = Tspi_Context_CreateObject(hContext,
TSS_OBJECT_TYPE_ENCDATA,
TSS_ENCDATA_SEAL,
&hEncData);
if (TSS_SUCCESS != result) {
print_error("Tspi_Context_CreateObject", result);
Tspi_Context_Close(hContext);
return result;
}
result = set_secret(hContext, hEncData, &hPolicy);
if (TSS_SUCCESS != result) {
print_error("set_secret", result);
Tspi_Context_Close(hContext);
return result;
}
result = Tspi_Context_LoadKeyByUUID(hContext,
TSS_PS_TYPE_SYSTEM,
UUID_K1,
&hKey);
if (TSS_SUCCESS != result) {
print_error("Tspi_Context_LoadKeyByUUID", result);
Tspi_Context_Close(hContext);
return -1;
}
result = set_popup_secret(hContext,
hKey,
TSS_POLICY_USAGE,
"Input K1's Pin\n",
0);
if (TSS_SUCCESS != result) {
print_error("set_popup_secret", result);
Tspi_Context_Close(hContext);
return result;
}
/*result = Tspi_GetPolicyObject(hKey, TSS_POLICY_USAGE, &hPolicy);
if (TSS_SUCCESS != result) {
print_error("Tspi_GetPolicyObject", result);
Tspi_Context_Close(hContext);
return result;
}
result = Tspi_Policy_SetSecret(hPolicy,
TESTSUITE_KEY_SECRET_MODE,
TESTSUITE_KEY_SECRET_LEN,
TESTSUITE_KEY_SECRET);
if (TSS_SUCCESS != result) {
print_error("Tspi_Policy_SetSecret", result);
Tspi_Context_Close(hContext);
return result;
}*/
result = Tspi_TPM_GetRandom(hTPM, KEY_SIZE, &random);
if (TSS_SUCCESS != result) {
print_error("Tspi_TPM_GetRandom", result);
Tspi_Context_Close(hContext);
return result;
}
result = Tspi_TPM_PcrRead(hTPM, 15, &u32PcrValLen, &rgbPcrVal);
if (TSS_SUCCESS != result) {
print_error("Tspi_TPM_PcrRead", result);
Tspi_Context_Close(hContext);
return result;
}
result = Tspi_PcrComposite_SetPcrValue(hPcrs, 15, u32PcrValLen, rgbPcrVal);
if (TSS_SUCCESS != result) {
print_error("Tspi_PcrComposite_SetPcrValue", result);
Tspi_Context_Close(hContext);
return result;
}
result = Tspi_Data_Seal(hEncData,
hKey,
KEY_SIZE,
random,
hPcrs);
if (TSS_SUCCESS != result) {
print_error("Tspi_Data_Seal", result);
Tspi_Context_Close(hContext);
return result;
}
result = Tspi_GetAttribData(hEncData,
TSS_TSPATTRIB_ENCDATA_BLOB,
TSS_TSPATTRIB_ENCDATABLOB_BLOB,
&u32EncDataLen,
&rgbEncData);
if (TSS_SUCCESS != result) {
print_error("Tspi_GetAttribData", result);
Tspi_Context_Close(hContext);
return result;
}
fpIn = fopen(argv[1], "rb");
if (!fpIn) {
printf("open file: %s failed\n", argv[1]);
Tspi_Context_Close(hContext);
return result;
}
fseek(fpIn, 0, SEEK_END);
size = ftell(fpIn);
if (size > BUF_LEN) {
printf("file is more than 1MB, too big !\n");
Tspi_Context_Close(hContext);
fclose(fpIn);
return -1;
}
pBufIn = malloc(size);
if (!pBufIn) {
printf("No Memmory\n");
Tspi_Context_Close(hContext);
}
fseek(fpIn, 0, SEEK_SET);
len = fread(pBufIn, 1, size, fpIn);
if (len != size) {
printf("fread error");
Tspi_Context_Close(hContext);
fclose(fpIn);
return -1;
}
fclose(fpIn);
if (aes_init(random, KEY_SIZE, (unsigned char *)&salt, &en)) {
printf("aes_init failed\n");
Tspi_Context_Close(hContext);
free(pBufIn);
return -1;
}
pBufOut = aes_encrypt(&en, pBufIn, &size);
fpOut = fopen(argv[2], "wb");
if (!fpOut) {
printf("open file: %s failed\n", argv[2]);
Tspi_Context_Close(hContext);
free(pBufIn);
free(pBufOut);
return -1;
}
len = fwrite(&u32EncDataLen, 1, sizeof(UINT32), fpOut);
if (sizeof(UINT32) != len) {
printf("fwrite u32EncDataLen failed\n");
Tspi_Context_Close(hContext);
free(pBufIn);
free(pBufOut);
fclose(fpOut);
return -1;
}
len = fwrite(rgbEncData, 1, u32EncDataLen, fpOut);
if (len != u32EncDataLen) {
printf("fwrite rgbEncData failed\n");
Tspi_Context_Close(hContext);
free(pBufIn);
free(pBufOut);
fclose(fpOut);
return -1;
}
len = fwrite(&size, 1, sizeof(int), fpOut);
if (len != sizeof(int)) {
printf("fwrite failed\n");
Tspi_Context_Close(hContext);
free(pBufIn);
free(pBufOut);
fclose(fpOut);
return -1;
}
len = fwrite(pBufOut, 1, size, fpOut);
if (len != size) {
printf("fwrite failed\n");
Tspi_Context_Close(hContext);
free(pBufIn);
free(pBufOut);
fclose(fpOut);
return -1;
}
fclose(fpOut);
free(pBufIn);
free(pBufOut);
Tspi_Context_Close(hContext);
return 0;
}
int main_v1_2(char version)
{
char *function = "Tspi_Data_Unseal01";
TSS_HCONTEXT hContext;
TSS_HKEY hSRK, hKey;
TSS_HTPM hTPM;
TSS_HPOLICY hKeyPolicy, hEncUsagePolicy, hSRKPolicy;
BYTE rgbDataToSeal[DATA_SIZE];
BYTE *rgbPcrValue;
UINT32 ulPcrLen;
TSS_HENCDATA hEncData;
BYTE *prgbDataToUnseal;
TSS_HPCRS hPcrComposite;
UINT32 BlobLength;
UINT32 ulDataLength = DATA_SIZE, ulNewDataLength;
TSS_UUID uuid;
TSS_RESULT result;
TSS_FLAG initFlags = TSS_KEY_TYPE_STORAGE | TSS_KEY_SIZE_2048 |
TSS_KEY_VOLATILE | TSS_KEY_AUTHORIZATION |
TSS_KEY_NOT_MIGRATABLE;
print_begin_test(function);
memset(rgbDataToSeal, 0x5d, DATA_SIZE);
// Create Context
result = Tspi_Context_Create(&hContext);
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_Create", result);
exit(result);
}
// Connect to Context
result = Tspi_Context_Connect(hContext, get_server(GLOBALSERVER));
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_Connect", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
// create hKey
result = Tspi_Context_CreateObject(hContext,
TSS_OBJECT_TYPE_RSAKEY,
initFlags, &hKey);
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_CreateObject (hKey)", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
result = Tspi_Context_CreateObject(hContext,
TSS_OBJECT_TYPE_ENCDATA,
TSS_ENCDATA_SEAL, &hEncData);
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_CreateObject (hEncData)",
result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
// get the use policy for the encrypted data to set its secret
result = Tspi_Context_CreateObject(hContext, TSS_OBJECT_TYPE_POLICY, TSS_POLICY_USAGE,
&hEncUsagePolicy);
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_CreateObject", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
result = Tspi_Policy_SetSecret(hEncUsagePolicy, TESTSUITE_ENCDATA_SECRET_MODE,
TESTSUITE_ENCDATA_SECRET_LEN, TESTSUITE_ENCDATA_SECRET);
if (result != TSS_SUCCESS) {
print_error("Tspi_Policy_SetSecret (hEncUsagePolicy)", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
// Assign the use policy to the object
result = Tspi_Policy_AssignToObject(hEncUsagePolicy, hEncData);
if (result != TSS_SUCCESS) {
print_error("Tspi_Policy_AssignToObject", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
//Load Key By UUID
result = Tspi_Context_LoadKeyByUUID(hContext, TSS_PS_TYPE_SYSTEM,
SRK_UUID, &hSRK);
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_LoadKeyByUUID (hSRK)", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
#ifndef TESTSUITE_NOAUTH_SRK
// set the SRK auth data
result = Tspi_GetPolicyObject(hSRK, TSS_POLICY_USAGE, &hSRKPolicy);
if (result != TSS_SUCCESS) {
print_error("Tspi_GetPolicyObject (hSRK)", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
result =
Tspi_Policy_SetSecret(hSRKPolicy, TESTSUITE_SRK_SECRET_MODE,
TESTSUITE_SRK_SECRET_LEN,
TESTSUITE_SRK_SECRET);
if (result != TSS_SUCCESS) {
print_error("Tspi_Policy_SetSecret (hSRKPolicy)", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
#endif
// set the new key's authdata
result = Tspi_Context_CreateObject(hContext, TSS_OBJECT_TYPE_POLICY, TSS_POLICY_USAGE,
&hKeyPolicy);
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_CreateObject", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
result =
Tspi_Policy_SetSecret(hKeyPolicy, TESTSUITE_KEY_SECRET_MODE, TESTSUITE_KEY_SECRET_LEN,
TESTSUITE_KEY_SECRET);
if (result != TSS_SUCCESS) {
print_error("Tspi_Policy_SetSecret (hKeyPolicy)", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
// Assign the use policy to the object
result = Tspi_Policy_AssignToObject(hKeyPolicy, hKey);
if (result != TSS_SUCCESS) {
print_error("Tspi_Policy_AssignToObject", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
// create the key
result = Tspi_Key_CreateKey(hKey, hSRK, 0);
if (result != TSS_SUCCESS) {
print_error("Tspi_Key_CreateKey (hKey)", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
result = Tspi_Key_LoadKey(hKey, hSRK);
if (result != TSS_SUCCESS) {
print_error("Tspi_Key_LoadKey (hKey)", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
result = Tspi_Context_CreateObject(hContext, TSS_OBJECT_TYPE_PCRS,
TSS_PCRS_STRUCT_INFO_LONG, &hPcrComposite);
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_CreateObject (hPcrComposite)",
result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
result = Tspi_Context_GetTpmObject(hContext, &hTPM);
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_GetTpmObject", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
#define PCR_NUM 5
result = Tspi_TPM_PcrRead(hTPM, PCR_NUM, &ulPcrLen, &rgbPcrValue);
if (result != TSS_SUCCESS) {
print_error("Tspi_TPM_PcrRead", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
result =
Tspi_PcrComposite_SetPcrValue(hPcrComposite, PCR_NUM, ulPcrLen,
rgbPcrValue);
if (result != TSS_SUCCESS) {
print_error("Tspi_PcrComposite_SetPcrValue", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
result = Tspi_Context_FreeMemory(hContext, rgbPcrValue);
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_FreeMemory", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
result = Tspi_PcrComposite_SetPcrLocality(hPcrComposite, TPM_LOC_ZERO);
if (result != TSS_SUCCESS) {
print_error("Tspi_PcrComposite_SetPcrValue", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
// Tell the TSS to mask the data before sending
result = Tspi_SetAttribUint32(hEncData, TSS_TSPATTRIB_ENCDATA_SEAL,
TSS_TSPATTRIB_ENCDATASEAL_PROTECT_MODE,
TSS_TSPATTRIB_ENCDATA_SEAL_PROTECT);
if (result != TSS_SUCCESS) {
print_error("Tspi_SetAttribUint32", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
// Data Seal
result =
Tspi_Data_Seal(hEncData, hKey, ulDataLength, rgbDataToSeal, hPcrComposite);
if (result != TSS_SUCCESS) {
print_error("Tspi_Data_Seal", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
result = Tspi_Data_Unseal(hEncData, hKey, &ulNewDataLength, &prgbDataToUnseal);
if (result != TSS_SUCCESS) {
if (!(checkNonAPI(result))) {
print_error(function, result);
} else {
print_error_nonapi(function, result);
}
} else {
if (ulDataLength != ulNewDataLength) {
printf
("ERROR length of returned data doesn't match!\n");
print_end_test(function);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
} else
if (memcmp
(prgbDataToUnseal, rgbDataToSeal, ulDataLength)) {
printf
("ERROR data returned from unseal doesn't match!\n");
print_end_test(function);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
result =
Tspi_Context_FreeMemory(hContext, prgbDataToUnseal);
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_FreeMemory ", result);
Tspi_Context_Close(hContext);
exit(result);
}
print_success(function, result);
}
print_end_test(function);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
