TEE_Result rpc_open(void *session_context, uint32_t param_types,
TEE_Param params[4])
{
TEE_TASessionHandle session;
uint32_t orig;
TEE_Result res;
TEE_UUID uuid = TA_SIMS_TEST_UUID;
uint32_t types =
TEE_PARAM_TYPES(TEE_PARAM_TYPE_VALUE_OUTPUT, TEE_PARAM_TYPE_NONE,
TEE_PARAM_TYPE_NONE, TEE_PARAM_TYPE_NONE);
TEE_Param par[4];
(void)session_context;
(void)param_types;
res = TEE_OpenTASession(&uuid, 0, 0, NULL, &session, &orig);
if (res != TEE_SUCCESS)
return res;
TEE_MemFill(params, 0, sizeof(TEE_Param) * 4);
res =
TEE_InvokeTACommand(session, 0, TA_SIMS_CMD_GET_COUNTER, types, par,
&orig);
if (res != TEE_SUCCESS)
goto exit;
exit:
TEE_CloseTASession(session);
return res;
}
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;
}
static TEE_Result rpc_call_cryp(uint32_t nParamTypes, TEE_Param pParams[4],
uint32_t cmd)
{
TEE_TASessionHandle cryp_session;
TEE_Result res;
uint32_t origin;
TEE_Param params[4];
uint32_t types =
TEE_PARAM_TYPES(TEE_PARAM_TYPE_NONE, TEE_PARAM_TYPE_NONE,
TEE_PARAM_TYPE_NONE, TEE_PARAM_TYPE_NONE);
TEE_MemFill(params, 0, sizeof(TEE_Param) * 4);
res = TEE_OpenTASession(&cryp_uuid, 0, types, params, &cryp_session,
&origin);
if (res != TEE_SUCCESS) {
EMSG("rpc_sha256 - TEE_OpenTASession returned 0x%x\n",
(unsigned int)res);
return res;
}
res = TEE_InvokeTACommand(cryp_session, 0, cmd, nParamTypes,
pParams, &origin);
if (res != TEE_SUCCESS) {
EMSG("rpc_sha256 - TEE_InvokeTACommand returned 0x%x\n",
(unsigned int)res);
}
TEE_CloseTASession(cryp_session);
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 TEE_Result verify_file_data(TEE_ObjectHandle object, size_t data_size,
uint8_t *chunk_buf, size_t chunk_size)
{
TEE_Result res;
size_t tmp_data_size = data_size;
res = TEE_SeekObjectData(object, 0, TEE_DATA_SEEK_SET);
if (res != TEE_SUCCESS) {
EMSG("Failed to seek to offset 0");
goto exit;
}
TEE_MemFill(chunk_buf, 0, chunk_size);
tmp_data_size = data_size;
while (tmp_data_size > 0) {
uint32_t read_bytes = 0;
res = TEE_ReadObjectData(object, chunk_buf, chunk_size,
&read_bytes);
if (res != TEE_SUCCESS) {
EMSG("Failed to read data, res=0x%08x", res);
goto exit;
}
if (read_bytes != chunk_size) {
EMSG("Data size not match");
res = TEE_ERROR_CORRUPT_OBJECT;
goto exit;
}
res = verify_buffer(chunk_buf, chunk_size);
if (res != TEE_SUCCESS) {
EMSG("Verify data failed, res=0x%08x", res);
goto exit;
}
tmp_data_size -= chunk_size;
}
exit:
return res;
}
static int yaffsfs_GetHandle(void)
{
int i;
yaffsfs_Handle *h;
for(i = 0; i < YAFFSFS_N_HANDLES; i++)
{
h = yaffsfs_GetHandlePointer(i);
if(!h)
{
// todo bug: should never happen
}
if(!h->inUse)
{
TEE_MemFill(h,0,sizeof(yaffsfs_Handle));
h->inUse=1;
return i;
}
}
return -1;
}
static TEE_Result rpc_call_cryp(bool sec_mem, uint32_t nParamTypes,
TEE_Param pParams[4], uint32_t cmd)
{
TEE_TASessionHandle cryp_session;
TEE_Result res;
uint32_t origin;
TEE_Param params[4];
size_t n;
uint32_t types =
TEE_PARAM_TYPES(TEE_PARAM_TYPE_NONE, TEE_PARAM_TYPE_NONE,
TEE_PARAM_TYPE_NONE, TEE_PARAM_TYPE_NONE);
TEE_MemFill(params, 0, sizeof(TEE_Param) * 4);
res = TEE_OpenTASession(&cryp_uuid, 0, types, params, &cryp_session,
&origin);
if (res != TEE_SUCCESS) {
EMSG("rpc_sha256 - TEE_OpenTASession returned 0x%x\n",
(unsigned int)res);
return res;
}
types = nParamTypes;
if (sec_mem) {
TEE_MemFill(params, 0, sizeof(params));
for (n = 0; n < 4; n++) {
switch (TEE_PARAM_TYPE_GET(types, n)) {
case TEE_PARAM_TYPE_VALUE_INPUT:
case TEE_PARAM_TYPE_VALUE_INOUT:
params[n].value = pParams[n].value;
break;
case TEE_PARAM_TYPE_MEMREF_INPUT:
case TEE_PARAM_TYPE_MEMREF_OUTPUT:
case TEE_PARAM_TYPE_MEMREF_INOUT:
params[n].memref.buffer =
TEE_Malloc(pParams[n].memref.size, 0);
if (!params[n].memref.buffer)
TEE_Panic(0);
params[n].memref.size = pParams[n].memref.size;
if (TEE_PARAM_TYPE_GET(types, n) !=
TEE_PARAM_TYPE_MEMREF_OUTPUT)
TEE_MemMove(params[n].memref.buffer,
pParams[n].memref.buffer,
pParams[n].memref.size);
break;
default:
break;
}
}
} else {
TEE_MemMove(params, pParams, sizeof(params));
}
res = TEE_InvokeTACommand(cryp_session, 0, cmd, types, params, &origin);
if (res != TEE_SUCCESS) {
EMSG("rpc_call_cryp - TEE_InvokeTACommand returned 0x%x\n",
(unsigned int)res);
}
TEE_CloseTASession(cryp_session);
if (sec_mem) {
for (n = 0; n < 4; n++) {
switch (TEE_PARAM_TYPE_GET(types, n)) {
case TEE_PARAM_TYPE_VALUE_INOUT:
case TEE_PARAM_TYPE_VALUE_OUTPUT:
pParams[n].value = params[n].value;
break;
case TEE_PARAM_TYPE_MEMREF_INPUT:
case TEE_PARAM_TYPE_MEMREF_OUTPUT:
case TEE_PARAM_TYPE_MEMREF_INOUT:
if (TEE_PARAM_TYPE_GET(types, n) !=
TEE_PARAM_TYPE_MEMREF_INPUT)
TEE_MemMove(pParams[n].memref.buffer,
params[n].memref.buffer,
params[n].memref.size);
pParams[n].memref.size = params[n].memref.size;
TEE_Free(params[n].memref.buffer);
break;
default:
break;
}
}
}
return res;
}
TEE_Result TA_EXPORT TA_InvokeCommandEntryPoint(void *sessionContext, uint32_t commandID,
uint32_t paramTypes, TEE_Param params[4])
{
sessionContext = sessionContext;
paramTypes = paramTypes;
OT_LOG(LOG_ERR, "Calling the Invoke command entry point");
if (commandID == TEST_PERSISTENT) {
int count = params[0].value.a;
while (count--)
ta_storage_test(params[0].value.b);
} else if (commandID == TEST_MSG) {
int count2 = params[0].value.a;
while (count2--) {
int count = params[0].value.b;
while (count--) {
TEE_Result retVal = TEE_SUCCESS;
struct com_mgr_invoke_cmd_payload payload, returnPayload;
payload.size = count;
payload.data = TEE_Malloc(payload.size, 0);
TEE_MemFill(payload.data, 0x77, payload.size);
if (payload.data) {
retVal = TEE_InvokeMGRCommand(TEE_TIMEOUT_INFINITE,
COM_MGR_CMD_ID_TEST_COMM,
&payload, &returnPayload);
if ((retVal == TEE_SUCCESS) &&
(returnPayload.size-sizeof(struct com_mgr_invoke_cmd_payload)) == payload.size) {
bool check = true;
unsigned int n;
for (n = 0; n < payload.size && check; n++) {
char *s = payload.data;
char *r = returnPayload.data;
check = s[n] == r[payload.size-1-n];
}
TEE_Free(returnPayload.data);
if (!check)
return TEE_ERROR_COMMUNICATION;
} else if (retVal == TEE_SUCCESS &&
returnPayload.size == 0 &&
returnPayload.size == payload.size) {
/* this is ok */
} else {
return TEE_ERROR_COMMUNICATION;
}
TEE_Free(payload.data);
}
}
}
} else {
OT_LOG(LOG_ERR, "Unknow command ID");
}
return TEE_SUCCESS;
}
