int main(int argc,char **argv) { TSS_HCONTEXT hContext; TSS_HTPM hTPM; TSS_RESULT result; TSS_HKEY hSRK=0; TSS_HPOLICY hSRKPolicy=0; TSS_UUID SRK_UUID=TSS_UUID_SRK; BYTE wks[20]; //For the well known secret // Set wks to the well known secret: 20 bytes of all 0’s memset(wks,0,20); //Pick the TPM you are talking to. // In this case, it is the system TPM (indicated with NULL). result = Tspi_Context_Create( &hContext); DBG("Create Context",result); result = Tspi_Context_Connect(hContext, NULL); DBG("Context Connect�",result); // Get the TPM handle result=Tspi_Context_GetTpmObject(hContext,&hTPM); DBG("Get TPM Handle",result); // Get the SRK handle result=Tspi_Context_LoadKeyByUUID(hContext,TSS_PS_TYPE_SYSTEM,SRK_UUID,&hSRK); DBG("Got the SRK handle�", result); //Get the SRK policy result = Tspi_GetPolicyObject(hSRK,TSS_POLICY_USAGE,&hSRKPolicy); DBG("Got the SRK policy",result); //Then set the SRK policy to be the well known secret result=Tspi_Policy_SetSecret(hSRKPolicy,TSS_SECRET_MODE_SHA1,20,wks); //Note: TSS SECRET MODE SHA1 says ”Don’t hash this. // Use the 20 bytes as they are. DBG("Set the SRK secret in its policy",result); //Do something usefull TSS_UUID MY_UUID=BACKUP_KEY_UUID; TSS_HKEY hESS_Bind_Key; result=Tspi_Context_GetKeyByUUID(hContext,TSS_PS_TYPE_SYSTEM,MY_UUID,&hESS_Bind_Key); DBG("Get key handle", result); printf("Unregistering key\r\n"); result=Tspi_Context_UnregisterKey(hContext,TSS_PS_TYPE_SYSTEM,MY_UUID,&hESS_Bind_Key); DBG("Unregister key",result); //Done doing something usefull // Context Close(hobjects you have created); Tspi_Context_FreeMemory(hContext,NULL); // This frees up memory automatically allocated for you. Tspi_Context_Close(hContext); return 0; }
main_v1_2(char version){ char *nameOfFunction = "Load KEY"; TSS_HCONTEXT hContext; TSS_HTPM hTPM; TSS_FLAG initFlags; TSS_HKEY hKey1, hKey2, hKey3, hKey4; TSS_HKEY hSRK; TSS_RESULT result; TSS_UUID uuid; TSS_HPOLICY srkUsagePolicy, keyUsagePolicy, keyMigPolicy, hKeyPolicy; print_begin_test(nameOfFunction); printf("KEY structure:\n%s\n", key_structure); //Create Context result = Tspi_Context_Create(&hContext); if (result != TSS_SUCCESS) { print_error("Tspi_Context_Connect", result); print_error_exit(nameOfFunction, err_string(result)); exit(result); } //Connect Context result = Tspi_Context_Connect(hContext, get_server(GLOBALSERVER)); if (result != TSS_SUCCESS) { print_error("Tspi_Context_Connect", result); print_error_exit(nameOfFunction, err_string(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); print_error_exit(nameOfFunction, err_string(result)); Tspi_Context_Close(hContext); exit(result); } printf("Load SRK sucessed!\n"); #ifndef TESTSUITE_NOAUTH_SRK //Get Policy Object result = Tspi_GetPolicyObject(hSRK, TSS_POLICY_USAGE, &srkUsagePolicy); if (result != TSS_SUCCESS) { print_error("Tspi_GetPolicyObject", result); print_error_exit(nameOfFunction, err_string(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); print_error_exit(nameOfFunction, err_string(result)); Tspi_Context_Close(hContext); exit(result); } #endif // -------------------------------- load k1 --------------------------------- printf("Loading K1...\n"); result = Tspi_Context_GetKeyByUUID(hContext, TSS_PS_TYPE_SYSTEM, UUID_K1, &hKey1); if (result != TSS_SUCCESS) { print_error("Tspi_Context_LoadKeyByUUID", result); print_error_exit(nameOfFunction, err_string(result)); Tspi_Context_FreeMemory(hContext, NULL); Tspi_Context_Close(hContext); exit(result); } //验证使用测略 result = Tspi_Key_LoadKey(hKey1, hSRK); if (result != TSS_SUCCESS) { print_error("Tspi_Key_LoadKey", result); Tspi_Context_FreeMemory(hContext, NULL); Tspi_Context_Close(hContext); exit(result); } printf("Load UserK1 sucessed!\n"); // -------------------------------- load k2 --------------------------------- //Load Key By UUID --K2 printf("Loading K2...\n"); result = Tspi_Context_GetKeyByUUID( hContext, TSS_PS_TYPE_SYSTEM, UUID_K2, &hKey2 ); if (result != TSS_SUCCESS) { print_error("Tspi_Context_LoadKeyByUUID", result); print_error_exit(nameOfFunction, err_string(result)); Tspi_Context_FreeMemory(hContext, NULL); Tspi_Context_Close(hContext); exit(result); } //验证使用测略 result = set_popup_secret(hContext, hKey1, TSS_POLICY_USAGE, "Input K1's pin", 0); if (TSS_SUCCESS != result) { print_error("set_popup_secret", result); Tspi_Context_Close(hContext); return result; } result = Tspi_Key_LoadKey(hKey2, hKey1); if (result != TSS_SUCCESS) { print_error("Tspi_Key_LoadKey", result); Tspi_Context_FreeMemory(hContext, NULL); Tspi_Context_Close(hContext); exit(result); } printf("Load UserK2 sucessed!\n"); // 给SRK授权 #ifndef TESTSUITE_NOAUTH_SRK //Get Policy Object result = Tspi_GetPolicyObject(hSRK, TSS_POLICY_USAGE, &srkUsagePolicy); if (result != TSS_SUCCESS) { print_error("Tspi_GetPolicyObject", result); print_error_exit(nameOfFunction, err_string(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); print_error_exit(nameOfFunction, err_string(result)); Tspi_Context_Close(hContext); exit(result); } #endif // -------------------------------- load k3 --------------------------------- printf("Loading K3...\n"); result = Tspi_Context_LoadKeyByUUID(hContext, TSS_PS_TYPE_SYSTEM, UUID_K3, &hKey3); if (result != TSS_SUCCESS) { print_error("Tspi_Context_GetKeyByUUID", result); print_error_exit(nameOfFunction, err_string(result)); Tspi_Context_FreeMemory(hContext, NULL); Tspi_Context_Close(hContext); exit(result); } printf("Load UserK3 sucessed!\n"); // -------------------------------- load k4 --------------------------------- printf("Loading K4...\n"); result = Tspi_Context_GetKeyByUUID( hContext, TSS_PS_TYPE_SYSTEM, UUID_K4, &hKey4 ); if (result != TSS_SUCCESS) { print_error("Tspi_Context_LoadKeyByUUID", result); print_error_exit(nameOfFunction, err_string(result)); Tspi_Context_FreeMemory(hContext, NULL); Tspi_Context_Close(hContext); exit(result); } //验证使用测略 result = set_popup_secret(hContext, hKey3, TSS_POLICY_USAGE, "Input K3's pin", 0); if (TSS_SUCCESS != result) { print_error("set_popup_secret", result); Tspi_Context_Close(hContext); return result; } result = Tspi_Key_LoadKey(hKey4, hKey3); if (result != TSS_SUCCESS) { print_error("Tspi_Key_LoadKey", result); Tspi_Context_FreeMemory(hContext, NULL); Tspi_Context_Close(hContext); exit(result); } printf("Load UserK4 sucessed!\n"); print_success(nameOfFunction, result); print_end_test(nameOfFunction); Tspi_Context_FreeMemory(hContext, NULL); Tspi_Context_Close(hContext); exit(0); }
int main(int argc,char **argv) { TSS_HCONTEXT hContext; TSS_HTPM hTPM; TSS_RESULT result; TSS_HKEY hSRK=0; TSS_HPOLICY hSRKPolicy=0; TSS_UUID SRK_UUID=TSS_UUID_SRK; BYTE wks[20]; //For the well known secret // Set wks to the well known secret: 20 bytes of all 0’s memset(wks,0,20); //Pick the TPM you are talking to. // In this case, it is the system TPM (indicated with NULL). result = Tspi_Context_Create( &hContext); DBG("Create Context",result); result = Tspi_Context_Connect(hContext, NULL); DBG("Context Connect�",result); // Get the TPM handle result=Tspi_Context_GetTpmObject(hContext,&hTPM); DBG("Get TPM Handle",result); // Get the SRK handle result=Tspi_Context_LoadKeyByUUID(hContext,TSS_PS_TYPE_SYSTEM,SRK_UUID,&hSRK); DBG("Got the SRK handle�", result); //Get the SRK policy result = Tspi_GetPolicyObject(hSRK,TSS_POLICY_USAGE,&hSRKPolicy); DBG("Got the SRK policy",result); //Then set the SRK policy to be the well known secret result=Tspi_Policy_SetSecret(hSRKPolicy,TSS_SECRET_MODE_SHA1,20,wks); //Note: TSS SECRET MODE SHA1 says ”Don’t hash this. // Use the 20 bytes as they are. DBG("Set the SRK secret in its policy",result); //Do something usefull UINT32 ulDataLength; TSS_HKEY hESS_Bind_Key; FILE * fin; FILE * fout; TSS_HENCDATA hEncData; TSS_UUID MY_UUID=BACKUP_KEY_UUID; BYTE encryptedData[256]; BYTE * decryptedData; BYTE pass123[3]; memset(pass123,0,3); //Read in the encrypted data from the file fin=fopen("data/AES.key.enc","rb"); read(fileno(fin),encryptedData,ulDataLength); fclose(fin); // Create a data object , fill it with clear text and then bind it. result=Tspi_Context_CreateObject(hContext,TSS_OBJECT_TYPE_ENCDATA,TSS_ENCDATA_BIND,&hEncData); DBG("Create Data object",result); result = Tspi_Context_GetKeyByUUID(hContext,TSS_PS_TYPE_SYSTEM,MY_UUID,&hESS_Bind_Key); DBG("Get unbinding key",result); result = Tspi_Key_LoadKey(hESS_Bind_Key,hSRK); DBG("Loaded Key",result); TSS_HPOLICY hBackup_Policy; // Create a policy for the new key. Set its password to ?~@~\123?~@~] result=Tspi_Context_CreateObject(hContext,TSS_OBJECT_TYPE_POLICY,TSS_POLICY_USAGE, &hBackup_Policy); DBG("Create a backup policy object",result); result=Tspi_Policy_SetSecret(hBackup_Policy,TSS_SECRET_MODE_PLAIN,3,pass123); DBG("Set backup policy object secret",result); // Assign the key?~@~Ys policy to the key object result=Tspi_Policy_AssignToObject( hBackup_Policy,hESS_Bind_Key); DBG("Assign the keys policy to the key", result); result = Tspi_SetAttribData(hEncData,TSS_TSPATTRIB_ENCDATA_BLOB,TSS_TSPATTRIB_ENCDATABLOB_BLOB,256,encryptedData); DBG("Load Data",result); // Use the Unbinding key to decrypt the encrypted data // in the BindData object, and return it result=Tspi_Data_Unbind(hEncData,hESS_Bind_Key,&ulDataLength,&decryptedData); DBG("Unbind",result); fout=fopen("data/originalAES.key", "wb"); write(fileno(fout),decryptedData,ulDataLength); fclose(fout); //Done doing something usefull // Context Close(hobjects you have created); Tspi_Context_FreeMemory(hContext,NULL); // This frees up memory automatically allocated for you. Tspi_Context_Close(hContext); return 0; }
/*ARGSUSED*/ int cmd_keyinfo(TSS_HCONTEXT hContext, TSS_HTPM hTPM, int argc, char *argv[]) { TSS_RESULT ret; UINT32 i, num_keys; TSS_KM_KEYINFO2 *keys; hash_node_t *parent, *child, *srk = NULL; TSS_HKEY hKey; union { uuid_t arr_uuid; TSS_UUID tss_uuid; } uuid; switch (argc) { case 1: /* Print key hierarchy */ ret = Tspi_Context_GetRegisteredKeysByUUID2(hContext, TSS_PS_TYPE_USER, NULL, &num_keys, &keys); if (ret) { print_error(ret, gettext("Get key hierarchy")); return (ERR_FAIL); } for (i = 0; i < num_keys; i++) { parent = hash_insert(keys[i].parentKeyUUID, NULL); child = hash_insert(keys[i].keyUUID, &keys[i]); add_child(parent, child); if (memcmp(&(keys[i].keyUUID), &srk_uuid, sizeof (TSS_UUID)) == 0) srk = child; } if (srk != NULL) print_all(srk, 0); ret = Tspi_Context_FreeMemory(hContext, (BYTE *) keys); if (ret) { print_error(ret, gettext("Free key list")); return (ERR_FAIL); } return (0); case 2: /* Print detailed info about a single key */ if (uuid_parse(argv[1], uuid.arr_uuid)) return (ERR_FAIL); ret = Tspi_Context_GetKeyByUUID(hContext, TSS_PS_TYPE_USER, uuid.tss_uuid, &hKey); if (ret == TSP_ERROR(TSS_E_PS_KEY_NOTFOUND)) { ret = Tspi_Context_GetKeyByUUID(hContext, TSS_PS_TYPE_SYSTEM, uuid.tss_uuid, &hKey); } if (ret) { print_error(ret, gettext("Get key by UUID")); return (ERR_FAIL); } print_key_info(hContext, hKey); return (0); default: (void) fprintf(stderr, gettext("Usage:\n")); (void) fprintf(stderr, "\tkeyinfo [uuid]\n"); return (ERR_USAGE); } }
void getkeyblob( unsigned char *auth_srk_value, unsigned long auth_srk_size, bool auth_srk_sha1, unsigned char *auth_key_value, unsigned long auth_key_size, bool auth_key_sha1, unsigned char *uuid_key_value, unsigned char *&output_value, unsigned long &output_size) { //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); //load the SRK TSS_UUID uuid_srk = TSS_UUID_SRK; result = Tspi_Context_LoadKeyByUUID(hcontext, TSS_PS_TYPE_SYSTEM, uuid_srk, &hkey_srk); if(result != TSS_SUCCESS) throw libhis_exception("Load SRK", result); //set up SRK auth if(auth_srk_sha1) { result = Tspi_Policy_SetSecret(hpolicy_srk, TSS_SECRET_MODE_SHA1, auth_srk_size, auth_srk_value); if(result != TSS_SUCCESS) throw libhis_exception("Set SRK Secret SHA1", result); } else { result = Tspi_Policy_SetSecret(hpolicy_srk, TSS_SECRET_MODE_PLAIN, auth_srk_size, auth_srk_value); if(result != TSS_SUCCESS) throw libhis_exception("Set SRK Secret Plain", result); } //assign the SRK auth result = Tspi_Policy_AssignToObject(hpolicy_srk, hkey_srk); if(result != TSS_SUCCESS) throw libhis_exception("Assign SRK Secret", result); //Set up the key UUID hextouuid(uuid_key_value, uuid_key); //Get the key by UUID result = Tspi_Context_GetKeyByUUID(hcontext, TSS_PS_TYPE_SYSTEM, uuid_key, &hkey_key); if(result != TSS_SUCCESS) throw libhis_exception("Get key by UUID", result); //set up key auth if(auth_key_sha1) { result = Tspi_Policy_SetSecret(hpolicy_key, TSS_SECRET_MODE_SHA1, auth_key_size, auth_key_value); if(result != TSS_SUCCESS) throw libhis_exception("Set key Secret SHA1", result); } else { result = Tspi_Policy_SetSecret(hpolicy_key, TSS_SECRET_MODE_PLAIN, auth_key_size, auth_key_value); if(result != TSS_SUCCESS) throw libhis_exception("Set key Secret Plain", result); } //assign the key auth result = Tspi_Policy_AssignToObject(hpolicy_key, hkey_key); if(result != TSS_SUCCESS) throw libhis_exception("Assign key Secret", result); //Unwrap the key result = Tspi_Key_LoadKey(hkey_key, hkey_srk); if(result != TSS_SUCCESS) throw libhis_exception("Unwrap key", result); //get the keyblob UINT32 size; BYTE *value; result = Tspi_GetAttribData(hkey_key, TSS_TSPATTRIB_KEY_BLOB, TSS_TSPATTRIB_KEYBLOB_BLOB, &size, &value); if(result != TSS_SUCCESS) throw libhis_exception("Get keyblob", result); //copy out the results output_size = size; output_value = new unsigned char[size]; for(unsigned long i = 0; i < size; i++) output_value[i] = value[i]; //clean up dynamic memory result = Tspi_Context_FreeMemory(hcontext, value); if(result != TSS_SUCCESS) throw libhis_exception("Cleanup dynamic memory", result); return; }
int main() { TSS_HCONTEXT hContext; TSS_HKEY hBindKey,hSRKey; TSS_HPOLICY hBind_Policy,hSRKey_Policy; TSS_HENCDATA hEncData; TSS_RESULT result; TSS_UUID SRK_UUID=TSS_UUID_SRK,BIND_UUID=BACKUP_KEY_UUID; UINT32 encLen=256; BYTE encryptedData[256]; BYTE *rgbDataUnbind; UINT32 ulDataLength; FILE *fin; result=Tspi_Context_Create(&hContext); DBG("Create context",result); result=Tspi_Context_Connect(hContext,NULL); DBG("Connect to native TCS",result); fin=fopen("bind.data","rb"); read(fileno(fin),encryptedData,encLen); fclose(fin); result=Tspi_Context_LoadKeyByUUID(hContext,TSS_PS_TYPE_SYSTEM,SRK_UUID, &hSRKey); DBG("Load SRK",result); result=Tspi_GetPolicyObject(hSRKey,TSS_POLICY_USAGE,&hSRKey_Policy); DBG("Get SRK policy object",result); result=Tspi_Policy_SetSecret(hSRKey_Policy,TSS_SECRET_MODE_PLAIN, 8,(BYTE *)"46113200"); DBG("Set secret of SRK policy",result); result=Tspi_Context_CreateObject(hContext,TSS_OBJECT_TYPE_ENCDATA, TSS_ENCDATA_BIND,&hEncData); DBG("Created Data object",result); result=Tspi_SetAttribData(hEncData,TSS_TSPATTRIB_ENCDATA_BLOB, TSS_TSPATTRIB_ENCDATABLOB_BLOB,encLen,encryptedData); DBG("Set hEncdata object",result); result=Tspi_Context_GetKeyByUUID(hContext,TSS_PS_TYPE_SYSTEM,BIND_UUID, &hBindKey); DBG("Get unbinding key",result); result=Tspi_Key_LoadKey(hBindKey,hSRKey); DBG("Load unbinding key",result); result=Tspi_GetPolicyObject(hSRKey,TSS_POLICY_USAGE,&hBind_Policy); DBG("Get unbinding key policy",result); result=Tspi_Policy_SetSecret(hBind_Policy,TSS_SECRET_MODE_PLAIN, 3,(BYTE *)"123"); DBG("Set secret of unbinding key policy",result); result=Tspi_Data_Unbind(hEncData,hBindKey,&ulDataLength,&rgbDataUnbind); DBG("Unbind",result); int i; for(i=0;i<ulDataLength;i++) printf("%c",rgbDataUnbind[i]); printf("\n"); result=Tspi_Context_CloseObject(hContext,hEncData); DBG("Close hEncData",result); result=Tspi_Context_Close(hContext); DBG("Close context",result); return 0; }
int main(int argc, char **argv) { TSS_HCONTEXT hContext=0; TSS_HTPM hTPM = 0; TSS_RESULT result; TSS_HKEY hSRK = 0; TSS_HPOLICY hSRKPolicy=0; TSS_UUID SRK_UUID = TSS_UUID_SRK; BYTE wks[20]; memset(wks,0,20); TSS_HKEY hESS_Bind_Key; TSS_UUID ESS_BIND_UUID=BACKUP_KEY_UUID; TSS_HPOLICY hESS_Policy; TSS_FLAG initFlags; BYTE *pubKey; UINT32 pubKeySize; FILE *fout, *fin; result =Tspi_Context_Create(&hContext); DBG("Create a context", result); result=Tspi_Context_Connect(hContext, NULL); DBG("Connect to TPM", result); result=Tspi_Context_GetTpmObject(hContext, &hTPM); DBG("Get TPM handle", result); result=Tspi_Context_LoadKeyByUUID(hContext, TSS_PS_TYPE_SYSTEM, SRK_UUID, &hSRK); DBG("Get SRK handle", result); result=Tspi_GetPolicyObject(hSRK, TSS_POLICY_USAGE, &hSRKPolicy); DBG("Get SRK Policy", result); result=Tspi_Policy_SetSecret(hSRKPolicy,TSS_SECRET_MODE_SHA1, 20, wks); DBG("Tspi_Policy_SetSecret", result); result = Tspi_Context_CreateObject(hContext,TSS_OBJECT_TYPE_POLICY, TSS_POLICY_USAGE, &hESS_Policy); DBG("Create a key policy object", result); result = Tspi_Policy_SetSecret(hESS_Policy, TSS_SECRET_MODE_SHA1, 20, wks); DBG("Set key policy object secret", result); initFlags = TSS_KEY_TYPE_BIND | TSS_KEY_SIZE_2048 | TSS_KEY_AUTHORIZATION | TSS_KEY_NOT_MIGRATABLE; result = Tspi_Context_CreateObject(hContext, TSS_OBJECT_TYPE_RSAKEY, initFlags, &hESS_Bind_Key); DBG("Create the key object", result); result = Tspi_SetAttribUint32(hESS_Bind_Key, TSS_TSPATTRIB_KEY_INFO, TSS_TSPATTRIB_KEYINFO_ENCSCHEME, TSS_ES_RSAESPKCSV15); DBG("Set the keys's padding type", result); result = Tspi_Policy_AssignToObject(hESS_Policy, hESS_Bind_Key); DBG("Assign the key's policy to the key", result); printf("Creating the key could take a while\n"); result = Tspi_Key_CreateKey(hESS_Bind_Key, hSRK, 0); DBG("Asking TPM to create the key", result); result = Tspi_Context_RegisterKey(hContext, hESS_Bind_Key, TSS_PS_TYPE_SYSTEM, ESS_BIND_UUID, TSS_PS_TYPE_SYSTEM, SRK_UUID); DBG("Registering the key for later retrieval", result); printf("Registering the key blob for later retrieval\r\n"); result = Tspi_Key_LoadKey(hESS_Bind_Key,hSRK); DBG("Loading key in TPM", result); result = Tspi_Key_GetPubKey(hESS_Bind_Key, &pubKeySize, &pubKey); DBG("Get Public portion of key", result); fout = fopen("BackupESSBindKey.pub", "wb"); if(fout != NULL) { write(fileno(fout), pubKey, pubKeySize); printf("Finished writing BackupESSBindKey.pub\n"); fclose(fout); } else { printf("Error opening XXXXXXXXXXXX \r\n"); } result = Tspi_Policy_FlushSecret(hESS_Policy); DBG("Policy flush secret", result); result = Tspi_Context_GetKeyByUUID(hContext, TSS_PS_TYPE_SYSTEM, ESS_BIND_UUID, &hESS_Bind_Key); DBG("Get key handle", result); printf("Unregistering key\r\n"); result = Tspi_Context_UnregisterKey(hContext, TSS_PS_TYPE_SYSTEM, ESS_BIND_UUID, &hESS_Bind_Key); DBG("Unregister key", result); // Load a key and bind data UINT32 ulDataLength; BYTE *rbgBoundData; BYTE newPubKey[1000], encData[1000]; TSS_HENCDATA hEncData; fin = fopen("BackupESSBindKey.pub", "r"); read(fileno(fin), newPubKey,284); if (fin == NULL) return 0; fclose(fin); result = Tspi_Context_CreateObject(hContext, TSS_OBJECT_TYPE_RSAKEY, initFlags, &hESS_Bind_Key); DBG("Tspi_Context_CreateObject BindKey", result); result = Tspi_SetAttribData(hESS_Bind_Key, TSS_TSPATTRIB_KEY_BLOB, TSS_TSPATTRIB_KEYBLOB_PUBLIC_KEY, 284,newPubKey); DBG("Set Public key into new key object", result); fin = fopen("data", "rb"); read(fileno(fin), encData, 7); fclose(fin); result=Tspi_Context_CreateObject(hContext, TSS_OBJECT_TYPE_ENCDATA, TSS_ENCDATA_BIND, &hEncData); DBG("Create Data Object", result); result = Tspi_Data_Bind(hEncData,hESS_Bind_Key,7,encData); DBG("Bind data", result); result = Tspi_GetAttribData(hEncData, TSS_TSPATTRIB_ENCDATA_BLOB, TSS_TSPATTRIB_ENCDATABLOB_BLOB, &ulDataLength,&rbgBoundData); DBG("Get encrypted data", result); fout = fopen("Bound.data", "wb"); write(fileno(fout),rbgBoundData,ulDataLength); fclose(fout); result = Tspi_Context_FreeMemory(hContext, NULL); DBG("Tspi Context Free Memory", result); result = Tspi_Context_Close(hContext); DBG("Tspi Context Close", result); return 0; }
int main_v1_1( void ) { char *function = "Tspi_Context_GetKeyByUUID04"; TSS_HKEY hSRK; TSS_HKEY hMSigningKey; TSS_UUID SRKUUID = {0,0,0,0,0,0,0,0,0,0,1}; TSS_UUID migratableSignUUID = {1,2,3,4,5,6,7,8,9,10,2}; TSS_UUID wrongUUID = {4,1,5,2,2,6,6,3,4,8,0}; TSS_HCONTEXT hContext; TSS_RESULT result; TSS_HPOLICY srkUsagePolicy; UINT32 exitCode = 0; 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 ); } // 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 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, &hMSigningKey ); if ( result != TSS_SUCCESS ) { print_error( "Tspi_Context_CreateObject (signing key)", result ); Tspi_Context_FreeMemory( hContext, NULL ); Tspi_Context_Close( hContext ); exit( result ); } // Create signing key 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 ); } // register signing key; srk is parent result = Tspi_Context_RegisterKey( hContext, hMSigningKey, TSS_PS_TYPE_SYSTEM, migratableSignUUID, TSS_PS_TYPE_SYSTEM, SRKUUID ); if ( (result != TSS_SUCCESS) && (TSS_ERROR_CODE(result) != TSS_E_KEY_ALREADY_REGISTERED)) { print_error( "Tspi_Context_RegisterKey", result ); Tspi_Context_UnregisterKey( hContext, TSS_PS_TYPE_SYSTEM, migratableSignUUID, &hMSigningKey ); Tspi_Context_FreeMemory( hContext, NULL ); Tspi_Context_Close( hContext ); exit( result ); } // get signing key result = Tspi_Context_GetKeyByUUID( hContext, TSS_PS_TYPE_SYSTEM, wrongUUID, &hMSigningKey ); if ( TSS_ERROR_CODE(result) != TSS_E_PS_KEY_NOTFOUND ) { if( !(checkNonAPI(result)) ) { print_error( function, result ); exitCode = result; } else { print_error_nonapi( function, result ); exitCode = result; } } else { print_success( function, result ); } print_end_test( function ); Tspi_Context_UnregisterKey( hContext, TSS_PS_TYPE_SYSTEM, migratableSignUUID, &hMSigningKey ); Tspi_Context_FreeMemory( hContext, NULL ); Tspi_Context_Close( hContext ); exit( exitCode ); }