static TEEC_Result run_test_with_args(enum storage_benchmark_cmd cmd, uint32_t arg0, uint32_t arg1, uint32_t arg2, uint32_t arg3, uint32_t *out0, uint32_t *out1) { TEEC_Operation op = TEEC_OPERATION_INITIALIZER; TEEC_Result res; TEEC_Session sess; uint32_t orig; res = xtest_teec_open_session(&sess, &storage_benchmark_ta_uuid, NULL, &orig); if (res != TEEC_SUCCESS) return res; op.params[0].value.a = arg0; op.params[0].value.b = arg1; op.params[1].value.a = arg2; op.params[1].value.b = arg3; op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT, TEEC_NONE); res = TEEC_InvokeCommand(&sess, cmd, &op, &orig); if (out0) *out0 = op.params[2].value.a; if (out1) *out1 = op.params[2].value.b; TEEC_CloseSession(&sess); return res; }
static int smcl_common_invoke_secwld(uint8_t cmd, TEEC_Operation *op) { TEEC_Context ctx = 0; TEEC_ErrorOrigin org = TEEC_ORIGIN_API; TEEC_Result result = TEEC_ERROR_GENERIC; TEEC_Session session; TEEC_UUID uuid = SMCL_TA_UUID; uint32_t ret = SMCL_GENERAL_FAILURE; memset(&session, 0, sizeof(TEEC_Session)); result = TEEC_InitializeContext(NULL, &ctx); if (result != TEEC_SUCCESS) { dprintf(ERROR, "TEEC_InitializeContext failed\n"); goto out; } result = TEEC_OpenSession(&ctx, &session, &uuid, TEEC_LOGIN_PUBLIC, NULL, NULL, &org); if (result != TEEC_SUCCESS) { dprintf(ERROR, "TEEC_OpenSession failed\n"); goto out_finalize; } op->memRefs[3].buffer = (void *)(&ret); op->memRefs[3].size = sizeof(uint32_t); op->memRefs[3].flags = TEEC_MEM_OUTPUT; op->flags |= TEEC_MEMREF_3_USED; result = TEEC_InvokeCommand(&session, cmd, op, &org); if (result != TEEC_SUCCESS) { dprintf(ERROR, "TEEC_InvokeCommand failed\n"); } result = TEEC_CloseSession(&session); if (result != TEEC_SUCCESS) { dprintf(ERROR, "TEEC_CloseSession failed\n"); } out_finalize: if (TEEC_FinalizeContext(&ctx) != TEEC_SUCCESS) { dprintf(ERROR, "TEEC_FinalizeContext failed\n"); /* * Special handling since there is a risk of overwriting old failing * result code from previous calls to tee. */ if (result == TEEC_SUCCESS) { result = TEEC_ERROR_GENERIC; } } out: if (result != TEEC_SUCCESS) { return SMCL_TEE_FAILURE; } return ret; }
SST_ERROR SST_EXPORT_API SSTTerminate(void) { stubMutexLock(); if (g_bSSTInitialized) { TEEC_CloseSession(&g_SSTSession); stubFinalizeContext(); g_bSSTInitialized = false; } /* else if not intialized => success too */ stubMutexUnlock(); return SST_SUCCESS; }
int main() { TEEC_Context context; TEEC_Session session; TEEC_Result ret; TEEC_Operation operation = {0}; uint32_t connection_method = TEEC_LOGIN_PUBLIC; printf("START: services test app\n"); /* Initialize context */ printf("Initializing context: "); ret = TEEC_InitializeContext(NULL, &context); if (ret != TEEC_SUCCESS) { printf("TEEC_InitializeContext failed: 0x%x\n", ret); goto end_1; } else { printf("initialized\n"); } operation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_NONE, TEEC_NONE, TEEC_NONE); /* Open session */ printf("Opening session: "); ret = TEEC_OpenSession(&context, &session, &uuid, connection_method, NULL, &operation, NULL); if (ret != TEEC_SUCCESS) { printf("TEEC_OpenSession failed: 0x%x\n", ret); goto end_2; } else { printf("opened\n"); } printf("Initialization complete\n"); /* Invoke commands */ printf("----- Counter tests begin -----\n"); ret = do_counter_tests(&session, &context); if (ret != TEEC_SUCCESS) { printf("Counter test failed: 0x%x\n", ret); goto end_3; } else { printf("Counter test ok\n"); } printf("----- Counter tests end -----\n"); /* Cleanup */ end_3: printf("Closing session: "); TEEC_CloseSession(&session); printf("closed\n"); end_2: printf("Finalizing context: "); TEEC_FinalizeContext(&context); printf("finalized\n"); end_1: printf("END: services test app\n"); exit(ret); }
int main(int argc, char *argv[]) { TEEC_Result res; TEEC_Context ctx; TEEC_Session sess; TEEC_Operation op; TEEC_UUID uuid_ta = TA_SE_API_TEST_UUID; TEEC_UUID uuid_sta = TA_SE_API_SELF_TEST_UUID; TEEC_UUID *uuid; uint32_t err_origin; bool self_test = false; int c; while ((c = getopt(argc, argv, "s")) != -1) { switch (c) { case 's': self_test = true; break; case '?': exit(1); } } /* Initialize a context connecting us to the TEE */ res = TEEC_InitializeContext(NULL, &ctx); if (res != TEEC_SUCCESS) errx(1, "TEEC_InitializeContext failed with code 0x%x", res); if (self_test) uuid = &uuid_sta; else uuid = &uuid_ta; /* * Open a session to the "hello world" TA, the TA will print "hello * world!" in the log when the session is created. */ res = TEEC_OpenSession(&ctx, &sess, uuid, TEEC_LOGIN_PUBLIC, NULL, NULL, &err_origin); if (res != TEEC_SUCCESS) errx(1, "TEEC_Opensession failed with code 0x%x origin 0x%x", res, err_origin); /* * Execute a function in the TA by invoking it, in this case * we're incrementing a number. * * The value of command ID part and how the parameters are * interpreted is part of the interface provided by the TA. */ /* * Prepare the argument. Pass a value in the first parameter, * the remaining three parameters are unused. */ memset(&op, 0, sizeof(op)); res = TEEC_InvokeCommand(&sess, CMD_SELF_TESTS, &op, &err_origin); if (res != TEEC_SUCCESS) printf("failed\n"); else printf("success\n"); /* * We're done with the TA, close the session and * destroy the context. * * The TA will print "Goodbye!" in the log when the * session is closed. */ TEEC_CloseSession(&sess); TEEC_FinalizeContext(&ctx); return 0; }
int main(void){ TEEC_Result res; TEEC_Context ctx; TEEC_Session sess; TEEC_Operation op,init_vals; TEEC_UUID uuid = TA_QUIZ_UUID; char question[DEF_QUES_SIZE] = {0}; uint32_t err_origin; //strt file read FILE *infile; infile = fopen("/bin/test.txt","r"); int num = 0; int i; ssize_t read; size_t len =0; char *line; line = (char *)malloc(sizeof(char) * 120); while((read = getline(&line,&len,infile)) != -1){ // printf("%s\n",line ); num++; } printf("%d\n",num); struct question ques[num/2]; fseek(infile,0,SEEK_SET); for(i =0 ; i < num;++i){ read = getline(&line,&len,infile); // printf("%s\n",line ); line[strlen(line)] = '\0'; if(i%2 == 0){ strcpy(ques[i/2].q,line); }else{ strcpy(ques[i/2].answer,line); } } free(line); num = num/2; /* FILE *infile; infile = fopen("/bin/test.txt","r"); int num = 0; struct question temp; int i; while(fread(&temp,sizeof(struct question),1,infile) != 0){ // printf("%s \n %s \n",temp.q,temp.answer); num++; } fseek(infile,0,SEEK_SET); struct question ques[num]; for(i =0 ; i < num;++i){ fread(&ques[i],sizeof(struct question),1,infile); } */ //end of read from file memset(&init_vals,0,sizeof(init_vals)); init_vals.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT,TEEC_MEMREF_TEMP_INPUT,TEEC_NONE,TEEC_NONE); init_vals.params[0].value.a = num; init_vals.params[1].tmpref.buffer = ques; init_vals.params[1].tmpref.size = sizeof(ques[0])*num; res = TEEC_InitializeContext(NULL, &ctx); // This basically checks if a TEE is present in the system if (res != TEEC_SUCCESS) errx(1, "TEEC_InitializeContext failed with code 0x%x", res); /* * Open a session to the TA */ res = TEEC_OpenSession(&ctx, &sess, &uuid,TEEC_LOGIN_PUBLIC, NULL, &init_vals, &err_origin); if (res != TEEC_SUCCESS) errx(1, "TEEC_Opensession failed with code 0x%x origin 0x%x",res, err_origin); /* * Prepare the argument. Pass a value in the first parameter, * the remaining three parameters are unused. */ memset(&op, 0, sizeof(op)); op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_OUTPUT, TEEC_MEMREF_TEMP_OUTPUT, TEEC_NONE, TEEC_NONE); op.params[1].tmpref.buffer = question; op.params[1].tmpref.size = sizeof(question); printf("********************** QUIZ **************************\n"); while(1){ res = TEEC_InvokeCommand(&sess, TA_QUIZ_CMD_START_QUIZ, &op,&err_origin); if (res != TEEC_SUCCESS) errx(1, "TEEC_Get_Question failed with code 0x%x origin 0x%x",res, err_origin); if(op.params[0].value.a == 0){ break; }else{ printf("\n----------------------- \n Question:\n %s \n",question ); printf(" Enter your anwer:\n"); char answer[DEF_QUES_SIZE]; fgets(answer,DEF_QUES_SIZE,stdin); if ((strlen(answer)>0) && (answer[strlen (answer) - 1] == '\n')) answer[strlen (answer) - 1] = '\0'; send_answer(sess,answer,err_origin); } } printf("Quiz ended\n"); /* * Close the session */ TEEC_CloseSession(&sess); TEEC_FinalizeContext(&ctx); return 0; }
int main() { TEEC_Context context; TEEC_Session session; TEEC_Operation operation; TEEC_SharedMemory in_mem; TEEC_SharedMemory out_mem; TEEC_Result ret; uint32_t return_origin; uint32_t connection_method = TEEC_LOGIN_PUBLIC; char data[DATA_SIZE]; uint8_t sha1[SHA1_SIZE]; int i; printf("START: example SHA1 calc app\n"); memset((void *)&in_mem, 0, sizeof(in_mem)); memset((void *)&out_mem, 0, sizeof(out_mem)); memset((void *)&operation, 0, sizeof(operation)); memset(data, 'y', DATA_SIZE); memset(sha1, 0, SHA1_SIZE); /* Initialize context */ printf("Initializing context: "); ret = TEEC_InitializeContext(NULL, &context); if (ret != TEEC_SUCCESS) { printf("TEEC_InitializeContext failed: 0x%x\n", ret); goto end_1; } else { printf("initiliazed\n"); } /* Open session is expecting HASH algorithm */ operation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_NONE, TEEC_NONE, TEEC_NONE); operation.params[0].value.a = HASH_SHA1; /* Open session */ printf("Openning session: "); ret = TEEC_OpenSession(&context, &session, &uuid, connection_method, NULL, &operation, &return_origin); if (ret != TEEC_SUCCESS) { printf("TEEC_OpenSession failed: 0x%x\n", ret); goto end_2; } else { printf("opened\n"); } /* Register shared memory for initial hash */ /* Data */ in_mem.buffer = data; in_mem.size = DATA_SIZE; in_mem.flags = TEEC_MEM_INPUT; ret = TEEC_RegisterSharedMemory(&context, &in_mem); if (ret != TEE_SUCCESS) { printf("Failed to register DATA shared memory\n"); goto end_3; } printf("Registered in mem..\n"); /* Fill operation parameters */ operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_WHOLE, TEEC_NONE, TEEC_NONE, TEEC_NONE); operation.params[0].memref.parent = &in_mem; /* Invoke command */ printf("Invoking command: Update sha1: "); ret = TEEC_InvokeCommand(&session, HASH_UPDATE, &operation, &return_origin); if (ret != TEEC_SUCCESS) { printf("TEEC_InvokeCommand failed: 0x%x\n", ret); goto end_3; } else { printf("done\n"); } /* register a shared memory region to hold the output of the sha1 operation */ out_mem.buffer = sha1; out_mem.size = SHA1_SIZE; out_mem.flags = TEEC_MEM_INPUT | TEEC_MEM_OUTPUT; ret = TEEC_RegisterSharedMemory(&context, &out_mem); if (ret != TEE_SUCCESS) { printf("Failed to allocate SHA1 shared memory\n"); goto end_3; } printf("Registered out mem..\n"); /* * Send some more data to calculate the hash over, this will be added to the origional hash * . This is not strictly needed it is a test for passing 2 memref params in a single * operation */ memset(data, 'Z', DATA_SIZE); /* Fill operation parameters */ operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_WHOLE, TEEC_MEMREF_WHOLE, TEEC_NONE, TEEC_NONE); /* * reuse the origional input shared memory, because we have just updated the contents * of the buffer */ operation.params[0].memref.parent = &in_mem; operation.params[1].memref.parent = &out_mem; /* Invoke command */ printf("Invoking command: Do final sha1: "); ret = TEEC_InvokeCommand(&session, HASH_DO_FINAL, &operation, &return_origin); if (ret != TEEC_SUCCESS) { printf("TEEC_InvokeCommand failed: 0x%x\n", ret); goto end_4; } else { printf("done\n"); } /* Printf sha1 buf */ printf("Calculated sha1: "); for (i = 0; i < SHA1_SIZE; i++) printf("%02x", sha1[i]); printf("\n"); /* Cleanup used connection/resources */ end_4: printf("Releasing shared out memory..\n"); TEEC_ReleaseSharedMemory(&out_mem); end_3: printf("Releasing shared in memory..\n"); TEEC_ReleaseSharedMemory(&in_mem); printf("Closing session..\n"); TEEC_CloseSession(&session); end_2: printf("Finalizing ctx..\n"); TEEC_FinalizeContext(&context); end_1: printf("END: example SHA1 calc app\n"); exit(ret); }
int main(int argc, char *argv[]) { TEEC_Result res; TEEC_Context ctx; TEEC_Session sess; TEEC_Operation op; TEEC_UUID uuid = TA_HELLO_WORLD_UUID; uint32_t err_origin; /* Initialize a context connecting us to the TEE */ res = TEEC_InitializeContext(NULL, &ctx); if (res != TEEC_SUCCESS) errx(1, "TEEC_InitializeContext failed with code 0x%x", res); /* * Open a session to the "hello world" TA, the TA will print "hello * world!" in the log when the session is created. */ res = TEEC_OpenSession(&ctx, &sess, &uuid, TEEC_LOGIN_PUBLIC, NULL, NULL, &err_origin); if (res != TEEC_SUCCESS) errx(1, "TEEC_Opensession failed with code 0x%x origin 0x%x", res, err_origin); /* * Execute a function in the TA by invoking it, in this case * we're incrementing a number. * * The value of command ID part and how the parameters are * interpreted is part of the interface provided by the TA. */ /* * Prepare the argument. Pass a value in the first parameter, * the remaining three parameters are unused. */ memset(&op, 0, sizeof(op)); op.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INOUT, TEEC_NONE, TEEC_NONE, TEEC_NONE); op.params[0].value.a = 42; printf("Invoking TA to increment %d\n", op.params[0].value.a); res = TEEC_InvokeCommand(&sess, TA_HELLO_WORLD_CMD_INC_VALUE, &op, &err_origin); if (res != TEEC_SUCCESS) errx(1, "TEEC_InvokeCommand failed with code 0x%x origin 0x%x", res, err_origin); printf("TA incremented value to %d\n", op.params[0].value.a); /* * We're done with the TA, close the session and * destroy the context. * * The TA will print "Goodbye!" in the log when the * session is closed. */ TEEC_CloseSession(&sess); TEEC_FinalizeContext(&ctx); return 0; }
int verify_start_modem(void *access_mem_start, size_t shared_mem_size, size_t access_private_mem_size, struct access_image_descr *access_image_descr) { int ret = 0; TEEC_Result teec_ret = TEEC_ERROR_GENERIC; TEEC_Context ctx; TEEC_SharedMemory shm; TEEC_ErrorOrigin org; TEEC_Session session; TEEC_Operation operation; TEEC_UUID ta_static_uuid = STATIC_TA_UUID; (void)access_mem_start; (void)shared_mem_size; (void)access_private_mem_size; if (NULL == access_image_descr || NULL == access_image_descr->elf_hdr) { ret = -1; dprintf(ERROR, "NULL pointer error"); goto out; } teec_ret = TEEC_InitializeContext(NULL, &ctx); if (teec_ret != TEEC_SUCCESS) { goto out; } teec_ret = TEEC_OpenSession(&ctx, &session, &ta_static_uuid, TEEC_LOGIN_PUBLIC, NULL, NULL, &org); if (teec_ret != TEEC_SUCCESS) { goto out_finalize; } shm.size = 4; shm.flags = TEEC_MEM_INPUT; teec_ret = TEEC_AllocateSharedMemory(&ctx, &shm); if (teec_ret != TEEC_SUCCESS) { goto out_close; } operation.memRefs[0] = shm; operation.flags = TEEC_MEMREF_0_USED; /* Point to entry. */ *((unsigned int *)shm.buffer) = (uintptr_t)((uint8_t *) access_image_descr->elf_hdr + ELF_ENTRY_OFFSET); teec_ret = TEEC_InvokeCommand(&session, BASS_APP_VERITY_START_MODEM, &operation, &org); if (teec_ret != TEEC_SUCCESS) { goto out_release; } out_release: TEEC_ReleaseSharedMemory(&shm); out_close: TEEC_CloseSession(&session); out_finalize: TEEC_FinalizeContext(&ctx); out: if (teec_ret != TEEC_SUCCESS) { ret = -1; } return ret; }
bass_return_code teec_invoke_secworld(TEEC_Operation *const operation, const uint32_t command_id) { bass_return_code ret_code = BASS_RC_FAILURE; TEEC_Result result = TEEC_ERROR_GENERIC; TEEC_Session session; TEEC_Context context; TEEC_ErrorOrigin errorOrigin; TEEC_UUID ta_static_uuid = STATIC_TA_UUID; result = TEEC_InitializeContext(NULL, &context); if (TEEC_SUCCESS != result) { dprintf(ERROR, "TEEC_InitializeContext error\n"); goto function_exit; } result = TEEC_OpenSession(&context, &session, &ta_static_uuid, TEEC_LOGIN_PUBLIC, NULL, NULL, &errorOrigin); if (TEEC_SUCCESS != result) { dprintf(ERROR, "TEEC_OpenSession error\n"); goto finalize; } result = TEEC_InvokeCommand(&session, command_id, operation, &errorOrigin); if (TEEC_SUCCESS != result) { dprintf(ERROR, "TEEC_InvokeCommand error\n"); goto close; } close: if (TEEC_CloseSession(&session) != TEEC_SUCCESS) { dprintf(ERROR, "TEEC_CloseSession error\n"); } finalize: if (TEEC_FinalizeContext(&context) != TEEC_SUCCESS) { dprintf(ERROR, "TEEC_FinalizeContext error\n"); } function_exit: if (TEEC_SUCCESS != result) { dprintf(ERROR, "result = 0x%X, errorOrigin = %d\n", result, errorOrigin); switch (errorOrigin) { case TEEC_ORIGIN_API: ret_code = BASS_RC_ERROR_TEE_API; break; case TEEC_ORIGIN_COMMS: ret_code = BASS_RC_ERROR_TEE_COMMS; break; case TEEC_ORIGIN_TEE: ret_code = BASS_RC_ERROR_TEE_CORE; break; case TEEC_ORIGIN_TRUSTED_APP: ret_code = BASS_RC_ERROR_TEE_TRUSTED_APP; break; default: ret_code = BASS_RC_ERROR_UNKNOWN; break; } } else { ret_code = BASS_RC_SUCCESS; } return ret_code; }