static TEE_Result read_lock_state(uint32_t pt, TEE_Param params[TEE_NUM_PARAMS])
{
const uint32_t exp_pt = TEE_PARAM_TYPES(TEE_PARAM_TYPE_VALUE_OUTPUT,
TEE_PARAM_TYPE_NONE,
TEE_PARAM_TYPE_NONE,
TEE_PARAM_TYPE_NONE);
uint32_t lock_state;
uint32_t count;
TEE_Result res;
TEE_ObjectHandle h;
if (pt != exp_pt)
return TEE_ERROR_BAD_PARAMETERS;
res = open_rb_state(DEFAULT_LOCK_STATE, &h);
if (res)
return res;
res = TEE_ReadObjectData(h, &lock_state, sizeof(lock_state), &count);
if (res)
goto out;
if (count != sizeof(lock_state)) {
/*
* Client need write the lock state to recover, this can
* normally not happen.
*/
res = TEE_ERROR_CORRUPT_OBJECT;
goto out;
}
params[0].value.a = lock_state;
out:
TEE_CloseObject(h);
return res;
}
static TEE_Result write_lock_state(uint32_t pt,
TEE_Param params[TEE_NUM_PARAMS])
{
const uint32_t exp_pt = TEE_PARAM_TYPES(TEE_PARAM_TYPE_VALUE_INPUT,
TEE_PARAM_TYPE_NONE,
TEE_PARAM_TYPE_NONE,
TEE_PARAM_TYPE_NONE);
uint32_t wlock_state;
uint32_t lock_state;
uint32_t count;
TEE_Result res;
TEE_ObjectHandle h;
if (pt != exp_pt)
return TEE_ERROR_BAD_PARAMETERS;
wlock_state = params[0].value.a;
res = open_rb_state(wlock_state, &h);
if (res)
return res;
res = TEE_ReadObjectData(h, &lock_state, sizeof(lock_state), &count);
if (res)
goto out;
if (count == sizeof(lock_state) && lock_state == wlock_state)
goto out;
res = create_rb_state(wlock_state, &h);
out:
TEE_CloseObject(h);
return res;
}
TEE_Result TA_EXPORT TA_CreateEntryPoint(void)
{
TEE_Result ret;
uint64_t initial_value = 0;
TEE_ObjectHandle counter;
OT_LOG(LOG_ERR, "Calling the create entry point");
ret = TEE_OpenPersistentObject(TEE_STORAGE_PRIVATE, &object_id, sizeof(object_id),
TEE_DATA_FLAG_ACCESS_READ | TEE_DATA_FLAG_ACCESS_WRITE,
&counter);
if (ret == TEE_ERROR_ITEM_NOT_FOUND) {
OT_LOG(LOG_DEBUG, "TEE_OpenPersistentObject failed, creating persistent object");
ret = TEE_CreatePersistentObject(TEE_STORAGE_PRIVATE, &object_id, sizeof(object_id),
TEE_DATA_FLAG_ACCESS_READ |
TEE_DATA_FLAG_ACCESS_WRITE,
NULL, &initial_value, sizeof(initial_value),
&counter);
if (ret != TEE_SUCCESS)
OT_LOG(LOG_ERR, "TEE_CreatePersistentObject failed: 0x%x", ret);
else
OT_LOG(LOG_DEBUG, "TEE_CreatePersistentObject succesful");
}
TEE_CloseObject(counter);
return ret;
}
TEE_Result ta_storage_cmd_close(uint32_t param_types, TEE_Param params[4])
{
ASSERT_PARAM_TYPE(TEE_PARAM_TYPES
(TEE_PARAM_TYPE_VALUE_INPUT, TEE_PARAM_TYPE_NONE,
TEE_PARAM_TYPE_NONE, TEE_PARAM_TYPE_NONE));
TEE_CloseObject((TEE_ObjectHandle)(uintptr_t)params[0].value.a);
return TEE_SUCCESS;
}
static TEE_Result read_rb_idx(uint32_t pt, TEE_Param params[TEE_NUM_PARAMS])
{
const uint32_t exp_pt = TEE_PARAM_TYPES(TEE_PARAM_TYPE_VALUE_INPUT,
TEE_PARAM_TYPE_VALUE_OUTPUT,
TEE_PARAM_TYPE_NONE,
TEE_PARAM_TYPE_NONE);
size_t slot_offset;
uint64_t idx;
uint32_t count;
TEE_Result res;
TEE_ObjectHandle h;
if (pt != exp_pt)
return TEE_ERROR_BAD_PARAMETERS;
res = get_slot_offset(params[0].value.a, &slot_offset);
if (res)
return res;
res = open_rb_state(DEFAULT_LOCK_STATE, &h);
if (res)
return res;
res = TEE_SeekObjectData(h, slot_offset, TEE_DATA_SEEK_SET);
if (res)
goto out;
res = TEE_ReadObjectData(h, &idx, sizeof(idx), &count);
if (res)
goto out;
if (count != sizeof(idx)) {
idx = 0; /* Not yet written slots are reported as 0 */
if (count) {
/*
* Somehow the file didn't even hold a complete
* slot index entry. Write it as 0.
*/
res = TEE_SeekObjectData(h, slot_offset,
TEE_DATA_SEEK_SET);
if (res)
goto out;
res = TEE_WriteObjectData(h, &idx, sizeof(idx));
if (res)
goto out;
}
}
params[1].value.a = idx >> 32;
params[1].value.b = idx;
out:
TEE_CloseObject(h);
return res;
}
static TEE_Result read_persist_value(uint32_t pt,
TEE_Param params[TEE_NUM_PARAMS])
{
const uint32_t exp_pt = TEE_PARAM_TYPES(TEE_PARAM_TYPE_MEMREF_INPUT,
TEE_PARAM_TYPE_MEMREF_INOUT,
TEE_PARAM_TYPE_NONE,
TEE_PARAM_TYPE_NONE);
uint32_t flags = TEE_DATA_FLAG_ACCESS_READ |
TEE_DATA_FLAG_ACCESS_WRITE;
TEE_Result res;
TEE_ObjectHandle h;
char name_full[TEE_OBJECT_ID_MAX_LEN];
uint32_t name_full_sz;
uint32_t count;
if (pt != exp_pt)
return TEE_ERROR_BAD_PARAMETERS;
char *name_buf = params[0].memref.buffer;
uint32_t name_buf_sz = params[0].memref.size;
char *value = params[1].memref.buffer;
uint32_t value_sz = params[1].memref.size;
res = get_named_object_name(name_buf, name_buf_sz,
name_full, &name_full_sz);
if (res)
return res;
res = TEE_OpenPersistentObject(storageid, name_full,
name_full_sz, flags, &h);
if (res) {
EMSG("Can't open named object value, res = 0x%x", res);
return res;
}
res = TEE_ReadObjectData(h, value, value_sz, &count);
if (res) {
EMSG("Can't read named object value, res = 0x%x", res);
goto out;
}
params[1].memref.size = count;
out:
TEE_CloseObject(h);
return res;
}
static TEE_Result write_rb_idx(uint32_t pt, TEE_Param params[TEE_NUM_PARAMS])
{
const uint32_t exp_pt = TEE_PARAM_TYPES(TEE_PARAM_TYPE_VALUE_INPUT,
TEE_PARAM_TYPE_VALUE_INPUT,
TEE_PARAM_TYPE_NONE,
TEE_PARAM_TYPE_NONE);
size_t slot_offset;
uint64_t widx;
uint64_t idx;
uint32_t count;
TEE_Result res;
TEE_ObjectHandle h;
if (pt != exp_pt)
return TEE_ERROR_BAD_PARAMETERS;
res = get_slot_offset(params[0].value.a, &slot_offset);
if (res)
return res;
widx = ((uint64_t)params[1].value.a << 32) | params[1].value.b;
res = open_rb_state(DEFAULT_LOCK_STATE, &h);
if (res)
return res;
res = TEE_SeekObjectData(h, slot_offset, TEE_DATA_SEEK_SET);
if (res)
goto out;
res = TEE_ReadObjectData(h, &idx, sizeof(idx), &count);
if (res)
goto out;
if (count != sizeof(idx))
idx = 0; /* Not yet written slots are reported as 0 */
if (widx < idx) {
res = TEE_ERROR_SECURITY;
goto out;
}
res = TEE_SeekObjectData(h, slot_offset, TEE_DATA_SEEK_SET);
if (res)
goto out;
res = TEE_WriteObjectData(h, &widx, sizeof(widx));
out:
TEE_CloseObject(h);
return res;
}
static TEE_Result get_counter_value(uint64_t *mem_data)
{
TEE_ObjectHandle counter;
TEE_Result ret;
uint64_t previous_value = 0, next_value = 0;
uint32_t bytes_read;
/* Open the object here if it exists */
ret = TEE_OpenPersistentObject(TEE_STORAGE_PRIVATE, &object_id, sizeof(object_id),
TEE_DATA_FLAG_ACCESS_READ | TEE_DATA_FLAG_ACCESS_WRITE,
&counter);
if (ret != TEE_SUCCESS) {
OT_LOG(LOG_ERR, "TEE_OpenPersistentObject failed: 0x%x", ret);
} else {
OT_LOG(LOG_ERR, "TEE_OpenPersistentObject succesful");
ret = TEE_ReadObjectData(counter, (void *)&previous_value, sizeof(uint64_t),
&bytes_read);
if (ret != TEE_SUCCESS) {
OT_LOG(LOG_ERR, "TEE_ReadObjectData failed: 0x%x", ret);
goto end_ctr;
}
*mem_data = previous_value;
/* Increment the value */
next_value = ++previous_value;
OT_LOG(LOG_ERR, "New counter value: %d", (int)next_value);
/* Set data position back to the start of object */
ret = TEE_SeekObjectData(counter, 0, TEE_DATA_SEEK_SET);
if (ret != TEE_SUCCESS) {
OT_LOG(LOG_ERR, "TEE_SeekObjectData failed: 0x%x", ret);
goto end_ctr;
}
/* Write the new counter value back to the persistent object */
ret = TEE_WriteObjectData(counter, (void *)&next_value, sizeof(uint64_t));
if (ret != TEE_SUCCESS)
OT_LOG(LOG_ERR, "TEE_WriteObjectData failed: 0x%x\n", ret);
}
end_ctr:
TEE_CloseObject(counter);
return ret;
}
static TEE_Result write_persist_value(uint32_t pt,
TEE_Param params[TEE_NUM_PARAMS])
{
const uint32_t exp_pt = TEE_PARAM_TYPES(TEE_PARAM_TYPE_MEMREF_INPUT,
TEE_PARAM_TYPE_MEMREF_INPUT,
TEE_PARAM_TYPE_NONE,
TEE_PARAM_TYPE_NONE);
const uint32_t flags = TEE_DATA_FLAG_ACCESS_READ |
TEE_DATA_FLAG_ACCESS_WRITE |
TEE_DATA_FLAG_OVERWRITE;
TEE_Result res;
TEE_ObjectHandle h;
char name_full[TEE_OBJECT_ID_MAX_LEN];
uint32_t name_full_sz;
if (pt != exp_pt)
return TEE_ERROR_BAD_PARAMETERS;
char *name_buf = params[0].memref.buffer;
uint32_t name_buf_sz = params[0].memref.size;
char *value = params[1].memref.buffer;
uint32_t value_sz = params[1].memref.size;
res = get_named_object_name(name_buf, name_buf_sz,
name_full, &name_full_sz);
if (res)
return res;
res = TEE_CreatePersistentObject(storageid, name_full,
name_full_sz,
flags, NULL, value,
value_sz, &h);
if (res)
EMSG("Can't create named object value, res = 0x%x", res);
TEE_CloseObject(h);
return res;
}
static TEE_Result prepare_test_file(size_t data_size, uint8_t *chunk_buf,
size_t chunk_size)
{
size_t remain_bytes = data_size;
TEE_Result res = TEE_SUCCESS;
TEE_ObjectHandle object;
res = TEE_CreatePersistentObject(TEE_STORAGE_PRIVATE,
filename, sizeof(filename),
TEE_DATA_FLAG_ACCESS_READ |
TEE_DATA_FLAG_ACCESS_WRITE |
TEE_DATA_FLAG_ACCESS_WRITE_META |
TEE_DATA_FLAG_OVERWRITE,
NULL, NULL, 0, &object);
if (res != TEE_SUCCESS) {
EMSG("Failed to create persistent object, res=0x%08x",
res);
goto exit;
}
while (remain_bytes) {
size_t write_size;
if (remain_bytes < chunk_size)
write_size = remain_bytes;
else
write_size = chunk_size;
res = TEE_WriteObjectData(object, chunk_buf, write_size);
if (res != TEE_SUCCESS) {
EMSG("Failed to write data, res=0x%08x", res);
goto exit_close_object;
}
remain_bytes -= write_size;
}
exit_close_object:
TEE_CloseObject(object);
exit:
return res;
}
static void rename_per_obj_and_enum_and_open_renameObj()
{
printf(" #### rename_per_obj_and_enum_and_open_renameObj ####\n");
TEE_Result ret;
TEE_ObjectHandle object = NULL;
TEE_ObjectHandle object2 = NULL;
uint32_t flags = 0xffffffff ^ TEE_DATA_FLAG_EXCLUSIVE;
TEE_ObjectEnumHandle iter_enum = NULL;
TEE_ObjectInfo info;
void *new_ID = NULL;
size_t new_ID_len = 15;
void *ret_ID = NULL;
size_t ret_ID_len = TEE_OBJECT_ID_MAX_LEN;
new_ID = malloc(new_ID_len);
ret_ID = malloc(ret_ID_len);
if (ret_ID == NULL || new_ID == NULL) {
printf("Fail: malloc ID\n");
goto err;
}
RAND_bytes(new_ID, new_ID_len);
gen_rand_per_data_obj(&object, 20);
if (object == NULL) {
printf("Fail: gen rand obj\n");
goto err;
}
ret = TEE_AllocatePersistentObjectEnumerator(&iter_enum);
if (ret != TEE_SUCCESS) {
printf("Fail: iter alloc\n");
goto err;
}
ret = TEE_StartPersistentObjectEnumerator(iter_enum, TEE_STORAGE_PRIVATE);
if (ret != TEE_SUCCESS) {
printf("Fail: iter start\n");
goto err;
}
for(;;) {
ret = TEE_GetNextPersistentObject(iter_enum, &info, ret_ID, &ret_ID_len);
if (ret == TEE_SUCCESS) {
/* continue */
} else if (ret == TEE_ERROR_ITEM_NOT_FOUND) {
break;
} else {
printf("Fail: get next\n");
goto err;
}
}
ret = TEE_RenamePersistentObject(object, new_ID, new_ID_len);
if (ret != TEE_SUCCESS) {
printf("Fail: renam\n");
goto err;
}
TEE_ResetPersistentObjectEnumerator(iter_enum);
for(;;) {
ret = TEE_GetNextPersistentObject(iter_enum, &info, ret_ID, &ret_ID_len);
if (ret == TEE_SUCCESS) {
/* continue */
} else if (ret == TEE_ERROR_ITEM_NOT_FOUND) {
break;
} else {
printf("Fail: get next\n");
goto err;
}
}
ret = TEE_OpenPersistentObject(TEE_STORAGE_PRIVATE, (void *)ret_ID,
ret_ID_len, flags, &object2);
if (ret != TEE_SUCCESS) {
printf("Fail: per open\n");
goto err;
}
err:
TEE_CloseAndDeletePersistentObject(object);
TEE_CloseObject(object2);
TEE_FreePersistentObjectEnumerator(iter_enum);
free(ret_ID);
free(new_ID);
}
static void data_stream_write_read()
{
printf(" #### data_stream_write_read ####\n");
TEE_Result ret;
TEE_ObjectHandle handler;
TEE_ObjectHandle per_han;
size_t key_size = 512;
char objID[] = "56c5d1b260704de30fe7af67e5b9327613abebe6172a2b4e949d84b8e561e2fb";
size_t objID_len = 64;
uint32_t flags = 0xffffffff ^ TEE_DATA_FLAG_EXCLUSIVE;
void *write_data = NULL;
void *read_data = NULL;
size_t data_size = 50;
uint32_t count = 0;
write_data = calloc(1, data_size);
if (write_data == NULL)
goto err;
read_data = calloc(1, data_size);
if (read_data == NULL)
goto err;
/* gen random data */
RAND_bytes(write_data, data_size);
ret = TEE_AllocateTransientObject(TEE_TYPE_RSA_KEYPAIR, key_size, &handler);
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;
}
ret = TEE_GenerateKey(handler, key_size, NULL, 0);
if (ret != TEE_SUCCESS) {
printf("Fail: bad para\n");
goto err;
}
ret = TEE_CreatePersistentObject(TEE_STORAGE_PRIVATE, (void *)objID, objID_len,
flags, handler, NULL, 0, &per_han);
if (ret != TEE_SUCCESS) {
printf("Fail: per creation\n");
goto err;
}
ret = TEE_WriteObjectData(per_han, write_data, data_size);
if (ret != TEE_SUCCESS) {
printf("Fail: per write\n");
goto err;
}
ret = TEE_SeekObjectData(per_han, 0, TEE_DATA_SEEK_SET);
if (ret != TEE_SUCCESS) {
printf("Fail: per seek\n");
goto err;
}
ret = TEE_ReadObjectData(per_han, read_data, data_size, &count);
if (ret != TEE_SUCCESS) {
printf("Fail: per read\n");
goto err;
}
err:
TEE_CloseAndDeletePersistentObject(per_han);
TEE_CloseObject(handler);
free(write_data);
free(read_data);
}
