TEE_Result set_key_value(TEE_ObjectHandle hKeyObject, const void *data, size_t data_size, uint32_t attributeID) { TEE_Result res = TEE_ERROR_GENERIC; TEE_Attribute attr; if(!hKeyObject) { res = TEE_ERROR_BAD_STATE; goto _ret_; } if(!data || 0 >= data_size) { res = TEE_ERROR_BAD_PARAMETERS; goto _ret_; } TEE_MemFill(&attr, sizeof(attr), 0); TEE_InitRefAttribute(&attr, attributeID /* TEE_ATTR_SECRET_VALUE */, (void *)data, data_size ); res = TEE_PopulateTransientObject(hKeyObject, &attr, 1); if(res != TEE_SUCCESS) { TEE_Printf("[err] TEE_PopulateTransientObject\n"); goto _ret_; } _ret_: if(res != TEE_SUCCESS) { TEE_Panic(res); } return res; }
TEE_Result crypt_cipher_aes_cbc(const void *message, size_t message_len, const void *key, size_t key_len, void *cipher, size_t *cipher_len, const void *IV, size_t IVLen, uint32_t mode) { TEE_Result res = TEE_ERROR_GENERIC; TEE_OperationHandle operation = TEE_HANDLE_NULL; uint32_t algorithm = TEE_ALG_AES_CBC_NOPAD; uint32_t maxKeySize = 256; /* valid sizes 128, 192, 256 */ res = TEE_AllocateOperation(&operation, algorithm, mode, maxKeySize); if(res != TEE_SUCCESS) { TEE_Printf("[err] TEE_AllocateOperation\n"); goto _ret_; } if(!key || 0 >= key_len) { res = TEE_ERROR_BAD_PARAMETERS; goto _ret_; } // set crypt key TEE_Attribute attr_list[1]; uint32_t attributeID = TEE_ATTR_SECRET_VALUE; TEE_MemFill(&attr_list[0], sizeof(attr_list[0]), 0); TEE_InitRefAttribute(&attr_list[0], attributeID /* TEE_ATTR_SECRET_VALUE */, (void *)key, key_len ); res = TEE_PopulateTransientObject(operation->key1, &attr_list[0], sizeof(attr_list)/sizeof(attr_list[0])); if(res != TEE_SUCCESS) { TEE_Printf("[err] TEE_PopulateTransientObject\n"); goto _ret_; } // do crypt res = crypt_cipher_interface(operation, (const void *)message, message_len, cipher, cipher_len, IV, IVLen); if(res != TEE_SUCCESS) { TEE_Printf("[err] crypt_cipher_interface\n"); goto _ret_; } _ret_: if (operation) { TEE_FreeOperation(operation); } if(res != TEE_SUCCESS) { TEE_Panic(res); } return res; }
static void popu_rsa_pub_key() { printf(" #### popu_rsa_pub_key ####\n"); TEE_Result ret; TEE_ObjectHandle rsa_pubkey; size_t key_size = 512; TEE_Attribute *params; size_t param_count = 2; ret = TEE_AllocateTransientObject(TEE_TYPE_RSA_PUBLIC_KEY, key_size, &rsa_pubkey); if (ret == TEE_ERROR_OUT_OF_MEMORY) { printf("Fail: no mem\n"); goto err; } if (ret == TEE_ERROR_NOT_SUPPORTED) { printf("Fail: no sup\n"); goto err; } params = TEE_Malloc(param_count * sizeof(TEE_Attribute), 0); if (params == NULL) goto err; // modulo params[0].attributeID = TEE_ATTR_RSA_MODULUS; params[0].content.ref.buffer = TEE_Malloc(KEY_IN_BYTES(key_size), 0); if (params[0].content.ref.buffer == NULL) goto err; RAND_bytes(params[0].content.ref.buffer, KEY_IN_BYTES(key_size)); params[0].content.ref.length = KEY_IN_BYTES(key_size); // pub exp params[1].attributeID = TEE_ATTR_RSA_PUBLIC_EXPONENT; params[1].content.ref.buffer = TEE_Malloc(KEY_IN_BYTES(key_size), 0); if (params[1].content.ref.buffer == NULL) goto err; RAND_bytes(params[1].content.ref.buffer, KEY_IN_BYTES(key_size)); params[1].content.ref.length = KEY_IN_BYTES(key_size); ret = TEE_PopulateTransientObject(rsa_pubkey, params, param_count); if (ret != TEE_SUCCESS) { printf("Fail: popu\n"); goto err; } err: free_attr(params, param_count); free(params); TEE_FreeTransientObject(rsa_pubkey); }
TEE_Result ta_entry_populate_transient_object(uint32_t param_type, TEE_Param params[4]) { TEE_Result res; TEE_Attribute *attrs; uint32_t attr_count; ASSERT_PARAM_TYPE(TEE_PARAM_TYPES (TEE_PARAM_TYPE_VALUE_INPUT, TEE_PARAM_TYPE_MEMREF_INPUT, TEE_PARAM_TYPE_NONE, TEE_PARAM_TYPE_NONE)); res = unpack_attrs(params[1].memref.buffer, params[1].memref.size, &attrs, &attr_count); if (res != TEE_SUCCESS) return res; res = TEE_PopulateTransientObject((TEE_ObjectHandle) params[0].value.a, attrs, attr_count); TEE_Free(attrs); return res; }
/** * @brief */ void test_storage_api() { uint32_t storageID=TEE_OBJECT_STORAGE_PRIVATE, r_flags=TEE_DATA_FLAG_ACCESS_READ, w_flags=TEE_DATA_FLAG_ACCESS_WRITE, rw_flags=(TEE_DATA_FLAG_ACCESS_READ | TEE_DATA_FLAG_ACCESS_WRITE), a_attribute_val=0x00000005,b_attribute_val=0x00000007, pop_ret_val,attribute_cnt=0x00000003,seek_ret_val,open_seek_retval, crt_ret_val,write_ret_val,open_write_retval,read_ret_val, open_read_retval,open_ret_val,open_delete_retval,allocate1_ret_val, allocate2_ret_val,rd_trunc_cnt=0x00000000,open_truncate_retval, trunc_size=0x0000000A,truncate_ret_val,rdtest_truncated_retval, optest_truncated_retval,rdtest_written_retval, optest_written_retval,rd_write_cnt=0x00000000,read_cnt=0x00000000, trunc_cnt=0x00000000,open_rename_retval,de_a, rd_rename_cnt=0x00000000,optest_renamed_retval,rename_ret_val, rdtest_renamed_retval,optest_deleted_retval; typedef signed int int32_t; int32_t offset=0x00000003; size_t objectIDLen=0x00000040,read_size=0x0000000F,rd_trunc_size=0x0000000A, rd_write_size=0x0000002C,rd_rename_size=0x0000000C; void* open_objectID="/test.dir/test.txt"; void* rename_objectID="/test.dir/new.txt"; void* initialData="This a sierraware created sample initial data\n"; void* create_objectID="/test.dir/crt.txt"; void* read_objectID="/test.dir/read.txt"; void* write_objectID="/test.dir/write.txt"; void* seek_objectID="/test.dir/seek.txt"; void* delete_objectID="/test.dir/delete.txt"; void* trunc_objectID="/test.dir/truncate.txt"; char wrie_buffer[255]={"This a sierraware created sample test string\n"}; char read_buffer[255],rd_trunc_buffer[255],rd_write_buffer[255], rd_rename_buffer[255]; void* attrsbuffer="This will get populated sometimes in the test fn\n"; void* p_buffer="And finally we tested GP_INTERNAL_STORAGE APP\n"; TEE_ObjectHandle crtattributes; TEE_ObjectHandle *first_object; TEE_ObjectHandle *second_object; TEE_Whence whence; whence=0x00000000; sw_printf("-----------Allocating Memory For Create Object--------------\n"); first_object=(TEE_ObjectHandle*)TEE_Malloc(sizeof(TEE_ObjectHandle),0); sw_printf("-------Allocating Memory For Create Object members----------\n"); allocate1_ret_val=TEE_AllocateTransientObject(TEE_TYPE_AES,0x00000800, first_object); sw_printf("the allocate transient function returns value is %x \n", allocate1_ret_val); crt_ret_val=TEE_CreatePersistentObject(storageID,create_objectID, objectIDLen,w_flags,crtattributes,initialData, (size_t)(sw_strlen((char*)initialData)),first_object); sw_printf("The create Persistent object funtion \ returns value is %x \n \n",crt_ret_val); sw_printf("------------Allocating Memory For open Object---------------\n"); second_object=(TEE_ObjectHandle*)TEE_Malloc(sizeof(TEE_ObjectHandle),0); sw_printf("------------Allocating Memory For open Object members-------\n"); allocate2_ret_val=TEE_AllocateTransientObject(TEE_TYPE_RSA_KEYPAIR, 0x00000800,second_object); sw_printf("the allocate transient function returns value is %x \n", allocate2_ret_val); open_ret_val=TEE_OpenPersistentObject(storageID,open_objectID,objectIDLen, r_flags,second_object); sw_printf("The open Persistent object funtion returns value is %x \n \n", open_ret_val); sw_printf("*****Reset the open object***** \n"); TEE_ResetTransientObject(*second_object); open_read_retval=TEE_OpenPersistentObject(storageID,read_objectID, objectIDLen,r_flags,second_object); sw_printf("The open Persistent object funtion \ returns value is %x \n \n",open_read_retval); read_ret_val=TEE_ReadObjectData(*second_object,(void*)&read_buffer, read_size,&read_cnt); sw_printf("The Read Persistent funtion returns value is %x \n \n", read_ret_val); sw_printf("*****Reset the read object***** \n"); TEE_ResetTransientObject(*second_object); open_write_retval=TEE_OpenPersistentObject(storageID,write_objectID, objectIDLen,w_flags,second_object); sw_printf("The open Persistent object funtion \ returns value is %x \n \n",open_write_retval); write_ret_val=TEE_WriteObjectData(*second_object,(void*)&wrie_buffer, (size_t)(sw_strlen((char*)&wrie_buffer))); sw_printf("The write Persistent funtion returns value is %x \n \n", write_ret_val); sw_printf("*****Reset the write object***** \n"); TEE_ResetTransientObject(*second_object); optest_written_retval=TEE_OpenPersistentObject(storageID,write_objectID, objectIDLen,r_flags,second_object); sw_printf("The open Persistent object funtion \ returns value is %x \n \n",optest_written_retval); rdtest_written_retval=TEE_ReadObjectData(*second_object, (void*)&rd_write_buffer,rd_write_size, &rd_write_cnt); sw_printf("The Read Persistent funtion returns value is %x \n \n", rdtest_written_retval); sw_printf("******TESTING:write persistent object*******\n"); if(rdtest_written_retval==1) { sw_printf("SUCCESS \n"); } else { sw_printf("FAILURE \n"); } sw_printf("*****Reset the read object***** \n"); TEE_ResetTransientObject(*second_object); open_truncate_retval=TEE_OpenPersistentObject(storageID,trunc_objectID, objectIDLen,w_flags,second_object); sw_printf("The open Persistent object funtion \ returns value is %x \n \n",open_truncate_retval); truncate_ret_val=TEE_TruncateObjectData(*second_object,trunc_size); sw_printf("The truncate Persistent funtion returns value is %x \n \n", truncate_ret_val); sw_printf("*****Reset the truncate object***** \n"); TEE_ResetTransientObject(*second_object); optest_truncated_retval=TEE_OpenPersistentObject(storageID,trunc_objectID, objectIDLen,r_flags,second_object); sw_printf("The open Persistent object funtion \ returns value is %x \n \n",optest_truncated_retval); rdtest_truncated_retval=TEE_ReadObjectData(*second_object, (void*)&rd_trunc_buffer,rd_trunc_size, &rd_trunc_cnt); sw_printf("The Read Persistent funtion returns value is %x \n \n", rdtest_truncated_retval); sw_printf("******TESTING:truncate persistent object*******\n"); if(rdtest_truncated_retval==1) { sw_printf("SUCCESS \n"); } else { sw_printf("FAILS \n"); } sw_printf("*****Reset the read object***** \n"); TEE_ResetTransientObject(*second_object); open_rename_retval=TEE_OpenPersistentObject(storageID,open_objectID, objectIDLen,rw_flags,second_object); sw_printf("The open Persistent object funtion \ returns value is %x \n \n",open_rename_retval); rename_ret_val=TEE_RenamePersistentObject(*second_object,rename_objectID, objectIDLen); sw_printf("The rename Persistent funtion returns value is %x \n \n", rename_ret_val); sw_printf("*****Reset the rename object***** \n"); TEE_ResetTransientObject(*second_object); optest_renamed_retval=TEE_OpenPersistentObject(storageID,rename_objectID, objectIDLen,r_flags,second_object); sw_printf("The open Persistent object funtion \ returns value is %x \n \n",optest_renamed_retval); rdtest_renamed_retval=TEE_ReadObjectData(*second_object, (void*)&rd_rename_buffer,rd_rename_size, &rd_rename_cnt); sw_printf("The Read Persistent funtion returns value is %x \n \n", rdtest_renamed_retval); sw_printf("******TESTING:rename persistent object*******\n"); if(rdtest_renamed_retval==1) { sw_printf("SUCCESS \n"); } else { sw_printf("FAILS \n"); } sw_printf("*****Reset the read object***** \n"); TEE_ResetTransientObject(*second_object); open_seek_retval=TEE_OpenPersistentObject(storageID,seek_objectID, objectIDLen,rw_flags,second_object); sw_printf("The open Persistent object funtion \ returns value is %x \n \n",open_seek_retval); seek_ret_val=TEE_SeekObjectData(*second_object,offset,whence); sw_printf("The seek Persistent funtion returns value is %x \n \n", seek_ret_val); sw_printf("*****Reset the seek object***** \n"); TEE_ResetTransientObject(*second_object); open_delete_retval=TEE_OpenPersistentObject(storageID,delete_objectID, objectIDLen,r_flags,second_object); sw_printf("The open Persistent object funtion returns value is %x \n", open_delete_retval); TEE_CloseAndDeletePersistentObject(*second_object); sw_printf("*****Reset the close object***** \n"); TEE_ResetTransientObject(*second_object); optest_deleted_retval=TEE_OpenPersistentObject(storageID,delete_objectID, objectIDLen,r_flags,second_object); sw_printf("The open Persistent object funtion \ returns value is %x \n \n",optest_deleted_retval); sw_printf("******TESTING:close and delete persistent object*******\n"); if(optest_deleted_retval!=1) { sw_printf("SUCCESS \n"); } else { sw_printf("FAILS\n"); } sw_printf("*****Reset the seek object***** \n"); TEE_ResetTransientObject(*second_object); TEE_Attribute* attref; attref=(TEE_Attribute*)TEE_Malloc(sizeof(TEE_Attribute),0); TEE_InitRefAttribute(attref,0x00000001,p_buffer, (size_t)(sw_strlen((char*)p_buffer))); TEE_Free((void*)attref); TEE_Attribute* attval; attval=(TEE_Attribute*)TEE_Malloc(sizeof(TEE_Attribute),0); TEE_InitValueAttribute(attval,0x20000000,a_attribute_val,b_attribute_val); TEE_Free((void*)attval); TEE_Attribute attributes[3]; attributes[0].attributeID=0x20000000; attributes[0].content.value.a=0x0000000A; attributes[0].content.value.b=0x0000000B; attributes[1].attributeID=0x00000275; attributes[1].content.ref.length=(size_t)(sw_strlen((char*)attrsbuffer)); attributes[1].content.ref.buffer=TEE_Malloc (attributes[1].content.ref.length,0); TEE_MemCpy(attributes[1].content.ref.buffer,attrsbuffer, (u32)(attributes[1].content.ref.length)); attributes[2].attributeID=0x23425676; attributes[2].content.value.a=0x0000001E; attributes[2].content.value.b=0x0000001F; pop_ret_val=TEE_PopulateTransientObject(*second_object,attributes, attribute_cnt); sw_printf("the populate transient function returns value is %x \n", pop_ret_val); sw_printf("*****Reset the populate object***** \n"); TEE_ResetTransientObject(*second_object); TEE_CopyObjectAttributes(*second_object,*first_object); sw_printf("*****free the create object by call TEE_FreeTransientObject \ fn***** \n"); TEE_FreeTransientObject(*first_object); sw_printf("*****free the common object by call TEE_FreeTransientObject \ fn***** \n"); TEE_FreeTransientObject(*second_object); sw_printf("--------------Program Successfully Terminated--------------\n"); }