static int tpm_rand_bytes(unsigned char *buf, int num)
{
TSS_RESULT result;
BYTE *rand_data;
UINT32 total_requested = 0;
DBG("%s getting %d bytes", __FUNCTION__, num);
if (num - total_requested > 4096) {
if ((result = Tspi_TPM_GetRandom(hTPM, 4096, &rand_data))) {
TSSerr(TPM_F_TPM_RAND_BYTES, TPM_R_REQUEST_FAILED);
return 0;
}
memcpy(&buf[total_requested], rand_data, 4096);
Tspi_Context_FreeMemory(hContext, rand_data);
total_requested += 4096;
}
if ((result = Tspi_TPM_GetRandom(hTPM, num - total_requested, &rand_data))) {
TSSerr(TPM_F_TPM_RAND_BYTES, TPM_R_REQUEST_FAILED);
return 0;
}
memcpy(buf + total_requested, rand_data, num - total_requested);
Tspi_Context_FreeMemory(hContext, rand_data);
return 1;
}
void getrandombytes(
unsigned long bytes_size,
unsigned char *&output_value)
{
//establish a session
result = Tspi_Context_Connect(hcontext, 0);
if(result != TSS_SUCCESS) throw libhis_exception("Connect Context", result);
//get the TPM object
result = Tspi_Context_GetTpmObject(hcontext, &htpm);
if(result != TSS_SUCCESS) throw libhis_exception("Get TPM Object", result);
//get random bytes
BYTE *bytes_value;
result = Tspi_TPM_GetRandom(htpm, bytes_size, &bytes_value);
if(result != TSS_SUCCESS) throw libhis_exception("Get Random Bytes", result);
//copy C-style output into C++ format
output_value = new unsigned char[bytes_size];
for(unsigned long i = 0; i < bytes_size; i++)
{
output_value[i] = bytes_value[i];
}
//clean up random bytes
result = Tspi_Context_FreeMemory(hcontext, bytes_value);
if(result != TSS_SUCCESS) throw libhis_exception("Cleanup bytes", result);
return;
}
int
main_v1_2(char version)
{
char *function = "Tspi_TPM_GetRandom-trans02";
BYTE *random;
TSS_HCONTEXT hContext;
TSS_HTPM hTPM;
TSS_RESULT result;
TSS_HKEY hSRK, hSigningKey, hWrappingKey;
print_begin_test( function );
result = connect_load_all(&hContext, &hSRK, &hTPM);
if ( result != TSS_SUCCESS )
{
print_error( "connect_load_all", (result) );
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close( hContext );
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);
}
//Get random number
result = Tspi_TPM_GetRandom( hTPM, 16, &random );
if (result != TSS_SUCCESS) {
print_error("Tspi_TPM_GetRandom", result);
Tspi_Context_Close(hContext);
exit(result);
}
result = Tspi_Context_FreeMemory(hContext, random);
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_FreeMemory ", result);
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_v1_1( void )
{
char *function = "Tspi_TPM_GetRandom01";
BYTE *random;
TSS_HCONTEXT hContext;
TSS_HTPM hTPM;
TSS_RESULT result;
print_begin_test( function );
// 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 );
}
// Retrieve TPM object of context
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 );
}
//Get random number
result = Tspi_TPM_GetRandom( hTPM, 16, &random );
if ( result != TSS_SUCCESS )
{
if( !(checkNonAPI(result)) )
{
print_error( function, result );
}
else
{
print_error_nonapi( function, result );
}
}
else
{
result = Tspi_Context_FreeMemory(hContext, random);
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 );
}
main_v1_1(void){
char *nameOfFunction = "Tspi_TPM_Quote03";
TSS_HCONTEXT hContext;
TSS_RESULT result;
TSS_HTPM hTPM;
TSS_HKEY hSRK;
TSS_UUID identityKeyUUID = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 2};
TSS_VALIDATION pValidationData;
TSS_HPCRS hPcrComposite;
TSS_FLAG initFlags;
TSS_HPOLICY srkUsagePolicy;
BYTE *data;
initFlags = TSS_KEY_TYPE_SIGNING | TSS_KEY_SIZE_2048 |
TSS_KEY_VOLATILE | TSS_KEY_NO_AUTHORIZATION |
TSS_KEY_NOT_MIGRATABLE;
print_begin_test(nameOfFunction);
//Create Context
result = Tspi_Context_Create(&hContext);
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_Create ", result);
exit(result);
}
//Connect Context
result = Tspi_Context_Connect(hContext, get_server(GLOBALSERVER));
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_Connect", result);
Tspi_Context_Close(hContext);
exit(result);
}
//Get TPM Object
result = Tspi_Context_GetTpmObject(hContext, &hTPM);
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_GetTpmObject", result);
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", result);
Tspi_Context_Close(hContext);
exit(result);
}
#ifndef TESTSUITE_NOAUTH_SRK
//Get Policy Object
result = Tspi_GetPolicyObject(hSRK, TSS_POLICY_USAGE, &srkUsagePolicy);
if (result != TSS_SUCCESS) {
print_error("Tspi_GetPolicyObject", result);
Tspi_Context_Close(hContext);
exit(result);
}
//Set Secret
result = Tspi_Policy_SetSecret(srkUsagePolicy, TESTSUITE_SRK_SECRET_MODE,
TESTSUITE_SRK_SECRET_LEN, TESTSUITE_SRK_SECRET);
if (result != TSS_SUCCESS) {
print_error("Tspi_Policy_SetSecret", result);
Tspi_Context_Close(hContext);
exit(result);
}
#endif
//Create object for the hPcrComposite Key
result = Tspi_Context_CreateObject(hContext,
TSS_OBJECT_TYPE_PCRS, 0,
&hPcrComposite);
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_CreatehIdentKey", result);
Tspi_Context_CloseObject(hContext, hPcrComposite);
Tspi_Context_Close(hContext);
exit(result);
}
//SelectPcrIndex
result = Tspi_PcrComposite_SelectPcrIndex(hPcrComposite, 1);
if (result != TSS_SUCCESS) {
print_error("Tspi_PcrComposite_SelectPcrIndex ", result);
Tspi_Context_CloseObject(hContext, hPcrComposite);
Tspi_Context_Close(hContext);
exit(result);
}
result = Tspi_TPM_GetRandom(hTPM, 20, &data);
if (result != TSS_SUCCESS) {
print_error("Tspi_TPM_GetRandom ", result);
Tspi_Context_Close(hContext);
exit(result);
}
pValidationData.ulDataLength = 20;
pValidationData.rgbExternalData = data;
//Call TPM Quote
result = Tspi_TPM_Quote(hTPM, -1, hPcrComposite, &pValidationData);
if (TSS_ERROR_CODE(result) != TSS_E_INVALID_HANDLE) {
if(!checkNonAPI(result)){
print_error(nameOfFunction, result);
print_end_test(nameOfFunction);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_CloseObject(hContext, hPcrComposite);
Tspi_Context_Close(hContext);
exit(result);
}
else{
print_error_nonapi(nameOfFunction, result);
print_end_test(nameOfFunction);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_CloseObject(hContext, hPcrComposite);
Tspi_Context_Close(hContext);
exit(result);
}
}
else{
print_success(nameOfFunction, result);
print_end_test(nameOfFunction);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_CloseObject(hContext, hPcrComposite);
Tspi_Context_Close(hContext);
exit(0);
}
}
int main_v1_2(char version)
{
char *function = "Tspi_Hash_TickStampBlob02";
TSS_HCONTEXT hContext;
TSS_HKEY hSRK, hMSigningKey;
TSS_HTPM hTPM;
TSS_RESULT result;
TSS_HPOLICY srkUsagePolicy;
TSS_VALIDATION validationData;
BYTE *nonce;
print_begin_test(function);
// 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);
}
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);
}
//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
//Get Policy Object
result = Tspi_GetPolicyObject(hSRK, TSS_POLICY_USAGE,
&srkUsagePolicy);
if (result != TSS_SUCCESS) {
print_error("Tspi_GetPolicyObject", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
//Set Secret
result = Tspi_Policy_SetSecret(srkUsagePolicy, TESTSUITE_SRK_SECRET_MODE,
TESTSUITE_SRK_SECRET_LEN, TESTSUITE_SRK_SECRET);
if (result != TSS_SUCCESS) {
print_error("Tspi_Policy_SetSecret", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
#endif
//Create Signing Key
result =
Tspi_Context_CreateObject(hContext, TSS_OBJECT_TYPE_RSAKEY,
TSS_KEY_SIZE_2048 |
TSS_KEY_TYPE_SIGNING |
TSS_KEY_NO_AUTHORIZATION,
&hMSigningKey);
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_CreateObject (signing key)",
result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
result = Tspi_Key_CreateKey(hMSigningKey, hSRK, 0);
if (result != TSS_SUCCESS) {
print_error("Tspi_Key_CreateKey (signing key)", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
result = Tspi_Key_LoadKey(hMSigningKey, hSRK);
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_LoadKey (hMSigningKey)", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
result = Tspi_TPM_GetRandom(hTPM, 20, &nonce);
if (result != TSS_SUCCESS) {
print_error("Tspi_TPM_GetRandom", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
validationData.rgbExternalData = nonce;
validationData.ulExternalDataLength = 20;
result = Tspi_Hash_TickStampBlob(0xffffffff, hMSigningKey, &validationData);
if (TSS_ERROR_CODE(result) != TSS_E_INVALID_HANDLE) {
if (!(checkNonAPI(result))) {
print_error(function, result);
} else {
print_error_nonapi(function, result);
}
print_end_test(function);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(TSS_E_FAIL);
}
print_success(function, result);
print_end_test(function);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(0);
}
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(int argc, char **argv)
{
TSS_HKEY hKey, hSRK;
TSS_HCONTEXT hContext;
TSS_HTPM hTPM;
TSS_RESULT result;
TSS_HPOLICY hPolicy;
TSS_HPCRS hPcrs;
UINT32 ulPcrValueLength, subCap, subCapLength;
UINT32 pulRespDataLength, numPcrs;
BYTE *pNumPcrs, *rgbPcrValue, *uuidString, *pcrsSelectedValues[24];
int i, c, *pcrsSelected = NULL, numPcrsSelected = 0;
TSS_UUID *uuid;
BYTE wellknown[] = TSS_WELL_KNOWN_SECRET;
while (1) {
c = getopt(argc, argv, "p:");
if (c == -1)
break;
switch (c) {
case 'p':
numPcrsSelected++;
pcrsSelected = realloc(pcrsSelected,
(sizeof(int)
* numPcrsSelected));
if (pcrsSelected == NULL) {
PRINT_ERR("Malloc of %zd bytes failed.",
(sizeof(int)
* numPcrsSelected));
return -1;
}
pcrsSelected[numPcrsSelected - 1] =
atoi(optarg);
break;
default:
usage(argv[0]);
break;
}
}
if (numPcrsSelected == 0)
printf("Warning: Key will not be bound to any PCR's!\n");
if (numPcrsSelected > 24) {
PRINT_ERR("Too many PCRs selected! Exiting.");
return -EINVAL;
}
result = Tspi_Context_Create(&hContext);
if (result != TSS_SUCCESS) {
PRINT_TSS_ERR("Tspi_Context_Create", result);
return result;
}
result = Tspi_Context_Connect(hContext, NULL);
if (result != TSS_SUCCESS) {
PRINT_TSS_ERR("Tspi_Context_Connect", result);
Tspi_Context_Close(hContext);
return result;
}
result = Tspi_Context_GetTpmObject(hContext, &hTPM);
if (result != TSS_SUCCESS) {
PRINT_TSS_ERR("Tspi_Context_GetTpmObject", result);
Tspi_Context_Close(hContext);
return result;
}
subCap = TSS_TPMCAP_PROP_PCR;
subCapLength = sizeof(UINT32);
result = Tspi_TPM_GetCapability(hTPM, TSS_TPMCAP_PROPERTY,
subCapLength, (BYTE *)&subCap,
&pulRespDataLength, &pNumPcrs );
if (result != TSS_SUCCESS) {
PRINT_TSS_ERR("Tspi_TPM_GetCapability", result);
Tspi_Context_Close(hContext);
return result;
}
numPcrs = *(UINT32 *)pNumPcrs;
for (i = 0; i < (int)numPcrsSelected; i++) {
if (pcrsSelected[i] > (int)numPcrs) {
fprintf(stderr, "%d: invalid PCR register. PCRs range "
"from 0 - %u\n", pcrsSelected[i], numPcrs);
return -1;
}
}
result = Tspi_Context_CreateObject(hContext, TSS_OBJECT_TYPE_PCRS, 0,
&hPcrs);
if (result != TSS_SUCCESS) {
PRINT_TSS_ERR("Tspi_Context_CreateObject", result);
return result;
}
for (i = 0; i < numPcrsSelected; i++) {
result = Tspi_TPM_PcrRead(hTPM, pcrsSelected[i],
&ulPcrValueLength, &rgbPcrValue);
if (result != TSS_SUCCESS) {
PRINT_TSS_ERR("Tspi_TPM_PcrRead", result);
Tspi_Context_Close(hContext);
return result;
}
result = Tspi_PcrComposite_SetPcrValue(hPcrs, pcrsSelected[i],
ulPcrValueLength,
rgbPcrValue);
if (result != TSS_SUCCESS) {
PRINT_TSS_ERR("Tspi_PcrComposite_SetPcrValue", result );
Tspi_Context_Close( hContext );
return result;
}
pcrsSelectedValues[i] = rgbPcrValue;
}
result = Tspi_Context_LoadKeyByUUID(hContext, TSS_PS_TYPE_SYSTEM,
SRK_UUID, &hSRK);
if (result != TSS_SUCCESS) {
PRINT_TSS_ERR("Tspi_Context_LoadKeyByUUID", result);
Tspi_Context_Close(hContext);
return result;
}
result = Tspi_GetPolicyObject(hSRK, TSS_POLICY_USAGE, &hPolicy);
if (result != TSS_SUCCESS) {
PRINT_TSS_ERR("Tspi_GetPolicyObject", result);
Tspi_Context_Close(hContext);
return result;
}
result = Tspi_Policy_SetSecret(hPolicy, TSS_SECRET_MODE_SHA1,
sizeof(wellknown), wellknown);
if (result != TSS_SUCCESS) {
PRINT_TSS_ERR("Tspi_GetPolicyObject", result);
Tspi_Context_Close(hContext);
return result;
}
result = Tspi_Context_CreateObject(hContext, TSS_OBJECT_TYPE_RSAKEY,
(TSS_KEY_TYPE_STORAGE
| TSS_KEY_SIZE_2048
| TSS_KEY_VOLATILE
| TSS_KEY_NO_AUTHORIZATION
| TSS_KEY_NOT_MIGRATABLE), &hKey);
if (result != TSS_SUCCESS) {
PRINT_TSS_ERR("Tspi_Context_CreateObject", result);
Tspi_Context_Close(hContext);
return result;
}
result = Tspi_Key_CreateKey(hKey, hSRK, hPcrs);
if (result != TSS_SUCCESS) {
PRINT_TSS_ERR("Tspi_Key_CreateKey", result);
Tspi_Context_Close(hContext);
return result;
}
result = Tspi_TPM_GetRandom(hTPM, (UINT32)16, (BYTE **)&uuid);
if (result != TSS_SUCCESS) {
PRINT_TSS_ERR("Tspi_TPM_GetRandom", result);
Tspi_Context_Close(hContext);
return result;
}
result = Tspi_Context_RegisterKey(hContext, hKey, TSS_PS_TYPE_USER,
*uuid, TSS_PS_TYPE_SYSTEM, SRK_UUID);
if (result != TSS_SUCCESS) {
PRINT_TSS_ERR("Tspi_Context_RegisterKey", result);
Tspi_Context_Close(hContext);
return result;
}
printf("Success: Key created bound to:\n");
for (i = 0; i < numPcrsSelected; i++) {
uuidString = (unsigned char *)
util_bytes_to_string((char *)
pcrsSelectedValues[i], 20);
if (uuidString == NULL) {
PRINT_ERR("malloc of 41 bytes failed");
Tspi_Context_Close(hContext);
return result;
}
printf("PCR %d: %s\n", pcrsSelected[i], uuidString);
free(uuidString);
Tspi_Context_FreeMemory(hContext, pcrsSelectedValues[i]);
}
uuidString = (BYTE *)util_bytes_to_string((char *)uuid, 16);
if (uuidString == NULL) {
PRINT_ERR("malloc of 33 bytes failed");
Tspi_Context_Close(hContext);
return result;
}
printf("And registered in persistent storage with UUID "
"(tspi_uuid parameter): %s\n", uuidString);
Tspi_Context_FreeMemory(hContext, (BYTE *)uuid);
free(uuidString);
Tspi_Context_Close(hContext);
return 0;
}
int
main_v1_2( char version )
{
char * function = "Tspi_TPM_GetAuditDigest02";
TSS_HCONTEXT hContext;
TSS_HKEY hSRK;
TSS_HTPM hTPM;
TSS_HPOLICY hTpmPolicy;
TSS_HKEY hKey;
UINT32 auditDigestLen, ordListLen;
BYTE * auditDigest;
UINT32 * ordList;
TPM_COUNTER_VALUE counterValue;
TSS_RESULT result;
TSS_VALIDATION valData;
BYTE* data;
print_begin_test( function );
result = connect_load_all(&hContext, &hSRK, &hTPM);
if ( result != TSS_SUCCESS )
{
print_error( "connect_load_all", result );
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close( hContext );
exit( result );
}
result = Tspi_GetPolicyObject(hTPM, TSS_POLICY_USAGE, &hTpmPolicy);
if ( result != TSS_SUCCESS )
{
print_error( "Tspi_GetPolicyObject", result );
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close( hContext );
exit( result );
}
result = Tspi_Policy_SetSecret(hTpmPolicy, TESTSUITE_OWNER_SECRET_MODE,
TESTSUITE_OWNER_SECRET_LEN, TESTSUITE_OWNER_SECRET);
if ( result != TSS_SUCCESS )
{
print_error( "Tspi_Policy_SetSecret", result );
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close( hContext );
exit( result );
}
/* Check if ordinal auditing is supported on this TPM */
result = Testsuite_Is_Ordinal_Supported(hTPM, TPM_ORD_SetOrdinalAuditStatus);
if (result != TSS_SUCCESS) {
fprintf(stderr, "%s: TPM doesn't support auditing, returning success\n", __FILE__);
print_success( function, TSS_SUCCESS );
print_end_test( function );
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close( hContext );
exit( 0 );
}
//Call GetAuditDigest
result = Tspi_TPM_GetAuditDigest(hTPM, NULL_HKEY, FALSE, &auditDigestLen, &auditDigest,
&counterValue, NULL, &ordListLen, &ordList);
if ( result != TSS_SUCCESS )
{
print_error( "Tspi_TPM_GetAuditDigest", result );
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close( hContext );
exit( result );
} else {
result = Tspi_Context_FreeMemory(hContext, auditDigest);
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_FreeMemory ", result);
Tspi_Context_Close(hContext);
exit(result);
}
result = Tspi_Context_FreeMemory(hContext, (BYTE *)ordList);
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_FreeMemory ", result);
Tspi_Context_Close(hContext);
exit(result);
}
}
result = create_load_key(hContext, TSS_KEY_TYPE_SIGNING | TSS_KEY_AUTHORIZATION, hSRK, &hKey);
if ( result != TSS_SUCCESS )
{
print_error( "create_load_key", result );
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close( hContext );
exit( result );
}
/* Set the Validation Data */
result = Tspi_TPM_GetRandom( hTPM, 20, &data );
if ( result != TSS_SUCCESS )
{
print_error( "Tspi_TPM_GetRandom", result );
Tspi_Context_CloseObject(hContext, hKey);
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close(hContext);
exit(result);
}
valData.ulExternalDataLength = 20;
valData.rgbExternalData = data;
//Call GetAuditDigest
result = Tspi_TPM_GetAuditDigest(hTPM, hKey, FALSE, &auditDigestLen, &auditDigest,
&counterValue, &valData, NULL, NULL);
if ( result != TSS_SUCCESS )
{
print_error( function , result );
Tspi_Context_CloseObject(hContext, hKey);
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close( hContext );
exit( result );
} else {
result = Tspi_Context_FreeMemory(hContext, auditDigest);
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_FreeMemory ", result);
Tspi_Context_Close(hContext);
exit(result);
}
/* Check the signature */
result = Testsuite_Verify_Signature(hContext, hKey, &valData);
if (result != TSS_SUCCESS){
print_error("Error on signature checking", result);
}else{
fprintf(stderr, "TPM Signature Verification Successful\n");
print_success( function, result );
}
}
print_end_test( function );
Tspi_Context_CloseObject(hContext, hKey);
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close( hContext );
exit( 0 );
}
int main_v1_2(char version)
{
char *function = "Tspi_Hash_TickStampBlob-trans02";
TSS_HCONTEXT hContext;
TSS_HKEY hSRK, hMSigningKey, hSigningKey, hWrappingKey;
TSS_HHASH hHash;
TSS_HTPM hTPM;
TSS_RESULT result;
TSS_HPOLICY srkUsagePolicy;
TSS_VALIDATION validationData;
BYTE *nonce;
print_begin_test(function);
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 Signing Key
result =
Tspi_Context_CreateObject(hContext, TSS_OBJECT_TYPE_RSAKEY,
TSS_KEY_SIZE_2048 |
TSS_KEY_TYPE_SIGNING |
TSS_KEY_NO_AUTHORIZATION,
&hMSigningKey);
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_CreateObject (signing key)",
result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
result = Tspi_Key_CreateKey(hMSigningKey, hSRK, 0);
if (result != TSS_SUCCESS) {
print_error("Tspi_Key_CreateKey (signing key)", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
result = Tspi_Key_LoadKey(hMSigningKey, hSRK);
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_LoadKey (hMSigningKey)", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
// create hash
result = Tspi_Context_CreateObject(hContext, TSS_OBJECT_TYPE_HASH,
TSS_HASH_SHA1, &hHash);
if (result != TSS_SUCCESS) {
print_error("Tspi_Context_CreateObject (hash)", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
result = Tspi_Hash_SetHashValue(hHash, 20, "Je pense, danc je s");
if (result != TSS_SUCCESS) {
print_error("Tspi_Hash_SetHashValue", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
result = Tspi_TPM_GetRandom(hTPM, 20, &nonce);
if (result != TSS_SUCCESS) {
print_error("Tspi_TPM_GetRandom", result);
Tspi_Context_FreeMemory(hContext, NULL);
Tspi_Context_Close(hContext);
exit(result);
}
validationData.rgbExternalData = nonce;
validationData.ulExternalDataLength = 20;
result = Tspi_Hash_TickStampBlob(hHash, hMSigningKey, &validationData);
if (result != TSS_SUCCESS) {
print_error("Tspi_Hash_TickStampBlob", 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)
{
TSS_HCONTEXT hContext;
TSS_HTPM hTPM;
TSS_HKEY hSRK;
TSS_RESULT result;
UINT32 rnd_len, i;
BYTE *rnd;
size_t nmembers;
int rc, seed = 0;
if (argv[1] && !strncmp(argv[1], "-s", 2))
seed = 1;
if ((result = connect_load_all(&hContext, &hSRK, &hTPM))) {
print_error( "connect_load_all", result );
ERR("connect_load_all failed: %s.", err_string(result));
return 1;
}
if (seed) {
BYTE entropy[64];
FILE *f;
if ((f = fopen(RANDOM_DEVICE, "r")) == NULL) {
ERR("Opening device failed: %s.", RANDOM_DEVICE);
print_error( "Opening device failed ", TSS_E_FAIL);
Tspi_Context_Close(hContext);
return 1;
}
if ((rc = fread(entropy, SEED_SIZE, 1, f)) != 1) {
ERR("Reading from device %s failed: %s.", RANDOM_DEVICE, strerror(errno));
fclose(f);
print_error("Reading from device failed", TSS_E_FAIL);
Tspi_Context_Close(hContext);
return 1;
}
fclose(f);
if ((result = Tspi_TPM_StirRandom(hTPM, SEED_SIZE, entropy))) {
ERR("Tspi_TPM_StirRandom failed: %s.", err_string(result));
print_error( "Tspi_TPM_StirRandom", result);
Tspi_Context_Close(hContext);
return 1;
}
}
rnd_len = RNG_BLOCK_SIZE;
for (i = 0; i < LOOPS; i++) {
if ((result = Tspi_TPM_GetRandom(hTPM, rnd_len, &rnd))) {
ERR("Tspi_TPM_GetRandom failed: %s.", err_string(result));
print_error( "Tspi_TPM_GetRandom", result);
Tspi_Context_Close(hContext);
return 1;
}
if ((nmembers = fwrite(rnd, rnd_len, 1, stdout)) != 1) {
ERR("fwrite failed: %s.", strerror(errno));
print_error( "fwrite failed", TSS_E_FAIL);
Tspi_Context_FreeMemory(hContext, rnd);
Tspi_Context_Close(hContext);
return 1;
}
Tspi_Context_FreeMemory(hContext, rnd);
}
Tspi_Context_Close(hContext);
return 0;
}
int
main_v1_1( void )
{
char *function = "Tspi_Context_RegisterKey05";
TSS_HKEY hSRK;
TSS_HTPM hTPM;
TSS_RESULT result;
TSS_HPOLICY srkUsagePolicy;
int i;
BYTE *rand;
print_begin_test( function );
// 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 );
}
// Retrieve TPM object of context
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 );
}
/* initialize the struct */
for (i = 0; i < NUM_KEYS; i++)
{
result = Tspi_TPM_GetRandom( hTPM, sizeof(TSS_UUID), &rand);
if ( result != TSS_SUCCESS )
{
print_error( "Tspi_TPM_GetRandom", result );
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close( hContext );
exit( result );
}
memcpy(&hKey[i].uuid, rand, sizeof(TSS_UUID));
Tspi_Context_FreeMemory(hContext, rand);
hKey[i].registered = hKey[i].handle = 0;
}
// Load SRK
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
// Get SRK Usage Policy
result = Tspi_GetPolicyObject( hSRK, TSS_POLICY_USAGE,
&srkUsagePolicy );
if ( result != TSS_SUCCESS )
{
print_error( "Tspi_GetPolicyObject", result );
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close( hContext );
exit( result );
}
// set secret
result = Tspi_Policy_SetSecret( srkUsagePolicy, TESTSUITE_SRK_SECRET_MODE,
TESTSUITE_SRK_SECRET_LEN, TESTSUITE_SRK_SECRET );
if ( result != TSS_SUCCESS )
{
print_error( "Tspi_Policy_SetSecret (1)", result );
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close( hContext );
exit( result );
}
#endif
/* create NUM_KEYS keys */
for (i = 0; i < NUM_KEYS; i++)
{
// create object
result = Tspi_Context_CreateObject( hContext, TSS_OBJECT_TYPE_RSAKEY,
TSS_KEY_SIZE_2048 | TSS_KEY_TYPE_SIGNING,
&hKey[i].handle );
if ( result != TSS_SUCCESS )
{
print_error( "Tspi_Context_CreateObject", result );
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close( hContext );
exit( result );
}
// create signing key
result = Tspi_Key_CreateKey( hKey[i].handle, hSRK, 0 );
if ( (result != TSS_SUCCESS) )
{
print_error( "Tspi_Key_CreateKey", result );
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close( hContext );
exit( result );
}
}
/* all in order */
for (i = 0; i < NUM_KEYS; i++)
{
if ((result = registerkey(i))) {
printf("%d: registerkey error, key %d\n", __LINE__, i);
goto cleanup;
}
}
for (i = 0; i < NUM_KEYS; i++)
{
if ((result = unregisterkey(i))) {
printf("%d: unregisterkey error, key %d\n", __LINE__, i);
goto cleanup;
}
}
/* backwards */
for (i = 0; i < NUM_KEYS; i++)
{
if ((result = registerkey(i))) {
printf("%d: registerkey error, key %d\n", __LINE__, i);
goto cleanup;
}
}
for (i = NUM_KEYS-1; i >= 0; i--)
{
if ((result = unregisterkey(i))) {
printf("%d: unregisterkey error, key %d\n", __LINE__, i);
goto cleanup;
}
}
print_end_test( function );
cleanup:
for (i = 0; i < NUM_KEYS; i++) {
if (hKey[i].registered == 1) {
Tspi_Context_UnregisterKey( hContext, TSS_PS_TYPE_SYSTEM,
hKey[i].uuid, &throw_away);
}
}
Tspi_Context_FreeMemory( hContext, NULL );
Tspi_Context_Close( hContext );
exit( result );
}
