1 /*
2 * Copyright (C) 2022 Huawei Technologies Co., Ltd.
3 * Licensed under the Mulan PSL v2.
4 * You can use this software according to the terms and conditions of the Mulan PSL v2.
5 * You may obtain a copy of Mulan PSL v2 at:
6 * http://license.coscl.org.cn/MulanPSL2
7 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
8 * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
9 * PURPOSE.
10 * See the Mulan PSL v2 for more details.
11 */
12
13 #include <gtest/gtest.h>
14
15 #include <common_test.h>
16 #include <empty_test.h>
17 #include <iostream>
18 #include <pthread.h>
19
20 #include <public_test.h>
21 #include <securec.h>
22 #include <session_mgr/client_session_mgr.h>
23 #include <string>
24 #include <tee_client_api.h>
25 #include <tee_client_type.h>
26 #include <test_comm_cmdid.h>
27 #include <test_defines.h>
28 #include <test_log.h>
29
30 using namespace std;
31 using namespace testing::ext;
32
33 // The test case uses the same string to pass the input and output test of buffer during REE and tee communication
34 static char g_teeOutput[] = "TEEMEM_OUTPUT";
35 static char g_teeInout[] = "the param is TEEMEM_INOUT";
36 static uint32_t g_teeOutputLen;
37 static uint32_t g_teeInoutLen;
38 static string g_testString = "11223344556677889900qwertyuiop";
39 char g_testData0[TEST_STR_LEN] = "Hello";
40 char g_testData1[TEST_STR_LEN] = "abcdefgh";
41 char g_testData2[TEST_STR_LEN] = "qwertyuiop";
42 char g_testData3[TEST_STR_LEN] = "this is test string";
43
44 static char g_offset0[] = "11223344556677889900";
45 static char g_offset100[] = "offset is 100";
46 static char g_offset200[] = "offset is 200";
47 static char g_offset300[] = "offset is 300";
48
49 #define SIZE_4K (4 * 1024)
50 #define SIZE_1024K (1024 * 1024)
51 #define SIZE_2048K (2048 * 1024)
52
53 /**
54 * @testcase.name : InvokeCommand_WithSessionNotOpen
55 * @testcase.desc : call TEEC_InvokeCommand With session is not open
56 * @testcase.expect : return TEEC_ERROR_BAD_PARAMETERS
57 */
58 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithSessionNotOpen, Function | MediumTest | Level0)
59 {
60 TEEC_Result ret;
61 uint32_t origin;
62 TEEC_UUID testId = CLIENTAPI_UUID_1;
63 ClientSessionMgr sess;
64 ret = sess.Start(&testId);
65 EXPECT_EQ(ret, TEEC_SUCCESS);
66 TEEC_CloseSession(&sess.session);
67
68 TEEC_Operation operation = { 0 };
69 operation.started = 1;
70 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INOUT, TEEC_NONE, TEEC_NONE, TEEC_NONE);
71 operation.params[0].value.a = 0xaaa;
72 operation.params[0].value.b = 0xbbb;
73
74 ret = TEEC_InvokeCommand(&sess.session, 0, &operation, &origin);
75 ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
76 ASSERT_EQ(origin, TEEC_ORIGIN_API);
77 }
78
79 /**
80 * @testcase.name : InvokeCommand_WithSessionIsClose
81 * @testcase.desc : call TEEC_InvokeCommand With session is closed
82 * @testcase.expect : return TEEC_ERROR_BAD_PARAMETERS
83 */
84 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithSessionIsClose, Function | MediumTest | Level0)
85 {
86 TEEC_Result ret;
87 uint32_t origin;
88 TEEC_UUID testId = CLIENTAPI_UUID_1;
89 ClientSessionMgr sess;
90 ret = sess.Start(&testId);
91 EXPECT_EQ(ret, TEEC_SUCCESS);
92 TEEC_CloseSession(&sess.session);
93
94 TEEC_Operation operation = { 0 };
95 operation.started = 1;
96 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INOUT, TEEC_NONE, TEEC_NONE, TEEC_NONE);
97 operation.params[0].value.a = 0xaaa;
98 operation.params[0].value.b = 0xbbb;
99
100 ret = TEEC_InvokeCommand(&sess.session, 0, &operation, &origin);
101 ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
102 ASSERT_EQ(origin, TEEC_ORIGIN_API);
103 }
104
105 /**
106 * @testcase.name : InvokeCommand_WithoutOperation
107 * @testcase.desc : call TEEC_InvokeCommand Without operation
108 * @testcase.expect : return TEEC_SUCCESS
109 */
110 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithoutOperation, Function | MediumTest | Level0)
111 {
112 TEEC_Result ret;
113 uint32_t origin;
114 TEEC_UUID testId = CLIENTAPI_UUID_1;
115 ClientSessionMgr sess;
116 ret = sess.Start(&testId);
117 EXPECT_EQ(ret, TEEC_SUCCESS);
118
119 ret = TEEC_InvokeCommand(&sess.session, 0, NULL, &origin);
120 ASSERT_EQ(ret, TEEC_SUCCESS);
121 ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
122 }
123
124 /**
125 * @testcase.name : InvokeCommand_WithoutOrigin
126 * @testcase.desc : call TEEC_InvokeCommand Without Origin
127 * @testcase.expect : return TEEC_SUCCESS
128 */
129 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithoutOrigin, Function | MediumTest | Level0)
130 {
131 TEEC_Result ret;
132 TEEC_UUID testId = CLIENTAPI_UUID_1;
133 ClientSessionMgr sess;
134 ret = sess.Start(&testId);
135 EXPECT_EQ(ret, TEEC_SUCCESS);
136
137 TEEC_Operation operation = { 0 };
138 operation.started = 1;
139 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_NONE, TEEC_NONE, TEEC_NONE);
140
141 ret = TEEC_InvokeCommand(&sess.session, 0, &operation, NULL);
142 ASSERT_EQ(ret, TEEC_SUCCESS);
143 }
144
145 /**
146 * @testcase.name : InvokeCommand_WithoutSession
147 * @testcase.desc : call TEEC_InvokeCommand Without session
148 * @testcase.expect : return TEEC_ERROR_BAD_PARAMETERS
149 */
150 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithoutSession, Function | MediumTest | Level0)
151 {
152 TEEC_Result ret;
153 uint32_t origin;
154 TEEC_UUID testId = CLIENTAPI_UUID_1;
155 ClientSessionMgr sess;
156 ret = sess.Start(&testId);
157 EXPECT_EQ(ret, TEEC_SUCCESS);
158
159 TEEC_Operation operation = { 0 };
160 operation.started = 1;
161 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_NONE, TEEC_NONE, TEEC_NONE);
162
163 ret = TEEC_InvokeCommand(NULL, 0, &operation, &origin);
164 ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
165 ASSERT_EQ(origin, TEEC_ORIGIN_API);
166 }
167
168 /**
169 * @testcase.name : InvokeCommand_WithOperationIsValue
170 * @testcase.desc : call TEEC_InvokeCommand With paramtype is value
171 * @testcase.expect : return TEEC_SUCCESS, TA can modify input value and return to CA
172 */
173 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithOperationIsValue, Function | MediumTest | Level0)
174 {
175 TEEC_Result ret;
176 uint32_t origin;
177 TEEC_UUID testId = CLIENTAPI_UUID_1;
178 ClientSessionMgr sess;
179 ret = sess.Start(&testId);
180 ASSERT_EQ(ret, TEEC_SUCCESS);
181
182 TEEC_Operation operation = { 0 };
183 operation.started = 1;
184 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_VALUE_OUTPUT, TEEC_VALUE_INOUT, TEEC_VALUE_INOUT);
185 operation.params[0].value.a = 0x111;
186 operation.params[0].value.b = 0x222;
187 operation.params[1].value.a = 0x333;
188 operation.params[1].value.b = 0x444;
189 operation.params[2].value.a = 0x555;
190 operation.params[2].value.b = 0x666;
191 operation.params[3].value.a = 0x777;
192 operation.params[3].value.b = 0x888;
193
194 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_VALUE, &operation, &origin);
195 ASSERT_EQ(ret, TEEC_SUCCESS);
196 ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
197 ASSERT_EQ(operation.params[0].value.a, 0x111);
198 ASSERT_EQ(operation.params[0].value.b, 0x222);
199 ASSERT_EQ(operation.params[1].value.a, 0x333 + 1);
200 ASSERT_EQ(operation.params[1].value.b, 0x444 + 1);
201 ASSERT_EQ(operation.params[2].value.a, 0x555 - 1);
202 ASSERT_EQ(operation.params[2].value.b, 0x666 - 1);
203 ASSERT_EQ(operation.params[3].value.a, 0x777 - 1);
204 ASSERT_EQ(operation.params[3].value.b, 0x888 - 1);
205 }
206
207 /**
208 * @testcase.name : InvokeCommand_WithOperationIsTempMem
209 * @testcase.desc : call TEEC_InvokeCommand With paramtype is TempMem
210 * @testcase.expect : return TEEC_SUCCESS, TA can modify input tempmem and return to CA
211 */
212 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithOperationIsTempMem, Function | MediumTest | Level0)
213 {
214 TEEC_Result ret;
215 uint32_t origin;
216 TEEC_Operation operation = { 0 };
217 TEEC_UUID testId = CLIENTAPI_UUID_1;
218 ClientSessionMgr sess;
219 ret = sess.Start(&testId);
220 ASSERT_EQ(ret, TEEC_SUCCESS);
221
222 g_teeOutputLen = strlen(g_teeOutput) + 1;
223 g_teeInoutLen = strlen(g_teeInout) + 1;
224
225 operation.started = 1;
226 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_MEMREF_TEMP_OUTPUT, TEEC_MEMREF_TEMP_INOUT,
227 TEEC_MEMREF_TEMP_INOUT);
228 operation.params[0].tmpref.buffer = g_testData0;
229 operation.params[0].tmpref.size = TEST_STR_LEN;
230 operation.params[1].tmpref.buffer = g_testData1;
231 operation.params[1].tmpref.size = TEST_STR_LEN;
232 operation.params[2].tmpref.buffer = g_testData2;
233 operation.params[2].tmpref.size = TEST_STR_LEN;
234 operation.params[3].tmpref.buffer = g_testData3;
235 operation.params[3].tmpref.size = TEST_STR_LEN;
236
237 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_BUFFER, &operation, &origin);
238 ASSERT_EQ(ret, TEEC_SUCCESS);
239 ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
240 ASSERT_STREQ(reinterpret_cast<char *>(operation.params[0].tmpref.buffer), g_testData0);
241 ASSERT_EQ(operation.params[0].tmpref.size, TEST_STR_LEN);
242 ASSERT_STREQ(reinterpret_cast<char *>(operation.params[1].tmpref.buffer), g_teeOutput);
243 ASSERT_EQ(operation.params[1].tmpref.size, g_teeOutputLen);
244 ASSERT_STREQ(reinterpret_cast<char *>(operation.params[2].tmpref.buffer), g_teeInout);
245 ASSERT_EQ(operation.params[2].tmpref.size, g_teeInoutLen);
246 ASSERT_STREQ(reinterpret_cast<char *>(operation.params[3].tmpref.buffer), g_teeInout);
247 ASSERT_EQ(operation.params[3].tmpref.size, g_teeInoutLen);
248 }
249
MemSharedFreeShmem(TEEC_SharedMemory * shmems,uint32_t count)250 static void MemSharedFreeShmem(TEEC_SharedMemory *shmems, uint32_t count)
251 {
252 if (count == 0) {
253 TEST_PRINT_ERROR("input for free count is wrong!\n");
254 return;
255 }
256
257 for (uint32_t idx = 0; idx < count; idx++) {
258 TEEC_ReleaseSharedMemory(shmems + idx);
259 }
260 }
261
MemSharedAllocShmem(TEEC_Context * context,TEEC_SharedMemory * shmems,uint32_t count,uint32_t size,uint32_t flag)262 static TEEC_Result MemSharedAllocShmem(TEEC_Context *context, TEEC_SharedMemory *shmems, uint32_t count, uint32_t size,
263 uint32_t flag)
264 {
265 TEEC_Result result;
266 if (count == 0) {
267 TEST_PRINT_ERROR("input for free count is wrong!\n");
268 return TEEC_ERROR_GENERIC;
269 }
270
271 for (uint32_t id = 0; id < count; id++) {
272 shmems[id].flags = flag;
273 shmems[id].size = size;
274 result = TEEC_AllocateSharedMemory(context, shmems + id);
275 if (result != TEEC_SUCCESS) {
276 TEST_PRINT_ERROR("%dth TEEC_AllocateSharedMemory size 0x%x fail,ret=0x%x\n", id + 1, size, result);
277 MemSharedFreeShmem(shmems, id);
278 return TEEC_FAIL;
279 }
280 (void)memset_s(shmems[id].buffer, shmems[id].size, 0x0, shmems[id].size);
281 }
282
283 return TEEC_SUCCESS;
284 }
285
286 /**
287 * @testcase.name : InvokeCommand_WithOperationIsPartialMem
288 * @testcase.desc : call TEEC_InvokeCommand With paramtype is PartialMem
289 * @testcase.expect : return TEEC_SUCCESS, TA can modify input PartialMem and return to CA
290 */
291 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithOperationIsPartialMem, Function | MediumTest | Level0)
292 {
293 TEEC_Result ret;
294 uint32_t origin;
295 int rc;
296 TEEC_Operation operation = { 0 };
297
298 TEEC_UUID testId = CLIENTAPI_UUID_1;
299 ClientSessionMgr sess;
300 ret = sess.Start(&testId);
301 ASSERT_EQ(ret, TEEC_SUCCESS);
302
303 TEEC_SharedMemory sharedMem[PARAM_COUNT] = { { 0 } };
304 // test malloc mem
305 ret = MemSharedAllocShmem(&sess.context, sharedMem, PARAM_COUNT, TEST_STR_LEN, TEEC_MEM_INOUT);
306 ASSERT_EQ(ret, TEEC_SUCCESS);
307
308 g_teeOutputLen = strlen(g_teeOutput) + 1;
309 g_teeInoutLen = strlen(g_teeInout) + 1;
310 rc = memcpy_s(sharedMem[0].buffer, TEST_STR_LEN, g_testData0, TEST_STR_LEN);
311 ASSERT_EQ(rc, 0);
312 rc = memcpy_s(sharedMem[1].buffer, TEST_STR_LEN, g_testData1, TEST_STR_LEN);
313 ASSERT_EQ(rc, 0);
314 rc = memcpy_s(sharedMem[2].buffer, TEST_STR_LEN, g_testData2, TEST_STR_LEN);
315 ASSERT_EQ(rc, 0);
316 rc = memcpy_s(sharedMem[3].buffer, TEST_STR_LEN, g_testData3, TEST_STR_LEN);
317 ASSERT_EQ(rc, 0);
318
319 operation.started = 1;
320 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_INPUT, TEEC_MEMREF_PARTIAL_OUTPUT,
321 TEEC_MEMREF_PARTIAL_INOUT, TEEC_MEMREF_PARTIAL_INOUT);
322 operation.params[0].memref.parent = &sharedMem[0];
323 operation.params[0].memref.offset = 0;
324 operation.params[0].memref.size = sharedMem[0].size;
325 operation.params[1].memref.parent = &sharedMem[1];
326 operation.params[1].memref.offset = 0;
327 operation.params[1].memref.size = sharedMem[1].size;
328 operation.params[2].memref.parent = &sharedMem[2];
329 operation.params[2].memref.offset = 0;
330 operation.params[2].memref.size = sharedMem[2].size;
331 operation.params[3].memref.parent = &sharedMem[3];
332 operation.params[3].memref.offset = 0;
333 operation.params[3].memref.size = sharedMem[3].size;
334
335 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_BUFFER, &operation, &origin);
336 ASSERT_EQ(ret, TEEC_SUCCESS);
337 ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
338 ASSERT_STREQ(reinterpret_cast<char *>(sharedMem[0].buffer), g_testData0);
339 ASSERT_EQ(operation.params[0].memref.size, TEST_STR_LEN);
340 ASSERT_STREQ(reinterpret_cast<char *>(sharedMem[1].buffer), g_teeOutput);
341 ASSERT_EQ(operation.params[1].memref.size, g_teeOutputLen);
342 ASSERT_STREQ(reinterpret_cast<char *>(sharedMem[2].buffer), g_teeInout);
343 ASSERT_EQ(operation.params[2].memref.size, g_teeInoutLen);
344 ASSERT_STREQ(reinterpret_cast<char *>(sharedMem[3].buffer), g_teeInout);
345 ASSERT_EQ(operation.params[3].memref.size, g_teeInoutLen);
346 }
347
348 /**
349 * @testcase.name : InvokeCommand_WithOperationIsTempMemIsNULL
350 * @testcase.desc : call TEEC_InvokeCommand With tempMem is null
351 * @testcase.expect : return TEEC_ERROR_BAD_PARAMETERS
352 */
353 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithOperationIsTempMemIsNULL, Function | MediumTest | Level0)
354 {
355 TEEC_Result ret;
356 uint32_t origin;
357 TEEC_Operation operation = { 0 };
358 TEEC_UUID testId = CLIENTAPI_UUID_1;
359 ClientSessionMgr sess;
360 ret = sess.Start(&testId);
361 EXPECT_EQ(ret, TEEC_SUCCESS);
362
363 operation.started = 1;
364 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_MEMREF_TEMP_INOUT, TEEC_NONE, TEEC_NONE);
365 operation.params[1].tmpref.buffer = NULL;
366 operation.params[1].tmpref.size = TEST_STR_LEN;
367
368 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_BUFFER, &operation, &origin);
369 ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
370 ASSERT_EQ(origin, TEEC_ORIGIN_API);
371 }
372
373 /**
374 * @testcase.name : InvokeCommand_WithOperationNotStart
375 * @testcase.desc : call TEEC_InvokeCommand With Operation is Not Start
376 * @testcase.expect : return TEEC_ERROR_NOT_IMPLEMENTED
377 */
378 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithOperationNotStart, Function | MediumTest | Level0)
379 {
380 TEEC_Result ret;
381 uint32_t origin;
382 TEEC_Operation operation = { 0 };
383 TEEC_UUID testId = CLIENTAPI_UUID_1;
384 ClientSessionMgr sess;
385 ret = sess.Start(&testId);
386 EXPECT_EQ(ret, TEEC_SUCCESS);
387
388 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_MEMREF_TEMP_INOUT, TEEC_NONE, TEEC_NONE);
389 operation.params[1].tmpref.buffer = g_testData0;
390 operation.params[1].tmpref.size = TEST_STR_LEN;
391
392 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_BUFFER, &operation, &origin);
393 ASSERT_EQ(ret, TEEC_ERROR_NOT_IMPLEMENTED);
394 ASSERT_EQ(origin, TEEC_ORIGIN_API);
395 }
396
397 /**
398 * @testcase.name : InvokeCommand_WithOperationTypeTempUsePartial
399 * @testcase.desc : call TEEC_InvokeCommand With ParamType is temp while operation is memref
400 * @testcase.expect : return TEEC_ERROR_COMMUNICATION
401 */
402 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithOperationTypeTempUsePartial, Function | MediumTest | Level0)
403 {
404 TEEC_Result ret;
405 uint32_t origin;
406 TEEC_Operation operation = { 0 };
407 TEEC_UUID testId = CLIENTAPI_UUID_1;
408 ClientSessionMgr sess;
409 ret = sess.Start(&testId);
410 ASSERT_EQ(ret, TEEC_SUCCESS);
411
412 ClientShareMemMgr testMem;
413 testMem.sharedMem.size = TEST_STR_LEN;
414 testMem.sharedMem.flags = TEEC_MEM_INOUT;
415 ret = TEEC_AllocateSharedMemory(&sess.context, &testMem.sharedMem);
416 ASSERT_EQ(ret, TEEC_SUCCESS);
417
418 operation.started = 1;
419 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INOUT, TEEC_NONE, TEEC_NONE, TEEC_NONE);
420 operation.params[0].memref.parent = &testMem.sharedMem;
421 operation.params[0].memref.offset = 0;
422 operation.params[0].memref.size = testMem.sharedMem.size;
423
424 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_BUFFER, &operation, &origin);
425 TEEC_ReleaseSharedMemory(&testMem.sharedMem);
426 ASSERT_EQ(ret, TEEC_ERROR_COMMUNICATION);
427 ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
428 }
429
430 /**
431 * @testcase.name : InvokeCommand_WithOperationTypePartialUseTemp
432 * @testcase.desc : call TEEC_InvokeCommand With ParamType is partial while operation is tmpref
433 * @testcase.expect : return TEEC_ERROR_BAD_PARAMETERS
434 */
435 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithOperationTypePartialUseTemp, Function | MediumTest | Level0)
436 {
437 TEEC_Result ret;
438 uint32_t origin;
439 TEEC_Operation operation = { 0 };
440 TEEC_UUID testId = CLIENTAPI_UUID_1;
441 ClientSessionMgr sess;
442 ret = sess.Start(&testId);
443 EXPECT_EQ(ret, TEEC_SUCCESS);
444
445 operation.started = 1;
446 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_INOUT, TEEC_NONE, TEEC_NONE, TEEC_NONE);
447 operation.params[0].tmpref.buffer = g_testData0;
448 operation.params[0].tmpref.size = TEST_STR_LEN;
449
450 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_BUFFER, &operation, &origin);
451 ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
452 ASSERT_EQ(origin, TEEC_ORIGIN_API);
453 }
454
455 /**
456 * @testcase.name : InvokeCommand_WithOperationTypePartialIsNULL
457 * @testcase.desc : call TEEC_InvokeCommand With ParamType is partial while memref.buffer is assign
458 * @testcase.expect : return TEEC_ERROR_BAD_PARAMETERS
459 */
460 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithOperationTypePartialIsNULL, Function | MediumTest | Level0)
461 {
462 TEEC_Result ret;
463 uint32_t origin;
464 TEEC_Operation operation = { 0 };
465 TEEC_UUID testId = CLIENTAPI_UUID_1;
466 ClientSessionMgr sess;
467 ret = sess.Start(&testId);
468 EXPECT_EQ(ret, TEEC_SUCCESS);
469
470 operation.started = 1;
471 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_INOUT, TEEC_NONE, TEEC_NONE, TEEC_NONE);
472 operation.params[0].memref.offset = 0;
473 operation.params[0].memref.size = TEST_STR_LEN;
474
475 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_BUFFER, &operation, &origin);
476 ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
477 ASSERT_EQ(origin, TEEC_ORIGIN_API);
478 }
479
480 /**
481 * @testcase.name : InvokeCommand_WithOperationTypePartialSizeIsExceed
482 * @testcase.desc : call TEEC_InvokeCommand With ParamType is partial while memref offset+size > sharedMem.size
483 * @testcase.expect : return TEEC_ERROR_BAD_PARAMETERS
484 */
485 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithOperationTypePartialSizeIsExceed, Function | MediumTest | Level0)
486 {
487 TEEC_Result ret;
488 uint32_t origin;
489 TEEC_Operation operation = { 0 };
490 TEEC_UUID testId = CLIENTAPI_UUID_1;
491 ClientSessionMgr sess;
492 ret = sess.Start(&testId);
493 ASSERT_EQ(ret, TEEC_SUCCESS);
494
495 ClientShareMemMgr testMem;
496 testMem.sharedMem.size = TEST_STR_LEN;
497 testMem.sharedMem.flags = TEEC_MEM_INOUT;
498 ret = TEEC_AllocateSharedMemory(&sess.context, &testMem.sharedMem);
499 ASSERT_EQ(ret, TEEC_SUCCESS);
500
501 operation.started = 1;
502 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_INOUT, TEEC_NONE, TEEC_NONE, TEEC_NONE);
503 operation.params[0].memref.parent = &testMem.sharedMem;
504 operation.params[0].memref.offset = 1;
505 operation.params[0].memref.size = testMem.sharedMem.size;
506
507 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_BUFFER, &operation, &origin);
508 TEEC_ReleaseSharedMemory(&testMem.sharedMem);
509 ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
510 ASSERT_EQ(origin, TEEC_ORIGIN_API);
511 }
512
513 /**
514 * @testcase.name : InvokeCommand_WithOperationTypePartialSizeIsZero
515 * @testcase.desc : call TEEC_InvokeCommand With ParamType is partial while memref.size = 0
516 * @testcase.expect : return TEEC_ERROR_BAD_PARAMETERS
517 */
518 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithOperationTypePartialSizeIsZero, Function | MediumTest | Level0)
519 {
520 TEEC_Result ret;
521 uint32_t origin;
522 TEEC_Operation operation = { 0 };
523 TEEC_UUID testId = CLIENTAPI_UUID_1;
524 ClientSessionMgr sess;
525 ret = sess.Start(&testId);
526 ASSERT_EQ(ret, TEEC_SUCCESS);
527
528 ClientShareMemMgr testMem;
529 testMem.sharedMem.size = TEST_STR_LEN;
530 testMem.sharedMem.flags = TEEC_MEM_INOUT;
531 ret = TEEC_AllocateSharedMemory(&sess.context, &testMem.sharedMem);
532 ASSERT_EQ(ret, TEEC_SUCCESS);
533
534 operation.started = 1;
535 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_INOUT, TEEC_NONE, TEEC_NONE, TEEC_NONE);
536 operation.params[0].memref.parent = &testMem.sharedMem;
537 operation.params[0].memref.offset = 0;
538 operation.params[0].memref.size = 0;
539
540 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_BUFFER, &operation, &origin);
541 TEEC_ReleaseSharedMemory(&testMem.sharedMem);
542 ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
543 ASSERT_EQ(origin, TEEC_ORIGIN_COMMS);
544 }
545
546 /**
547 * @testcase.name : InvokeCommand_WithMemrefPartialBufferIsWrong
548 * @testcase.desc : call TEEC_InvokeCommand With ParamType is partial while sharedMem.buffer is not use
549 * TEEC_AllocateSharedMemory allocated
550 * @testcase.expect : return TEEC_ERROR_BAD_PARAMETERS
551 */
552 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithMemrefPartialBufferIsWrong, Function | MediumTest | Level0)
553 {
554 TEEC_Result ret;
555 uint32_t origin;
556 ClientShareMemMgr testMem;
557 ClientSessionMgr sess;
558 TEEC_UUID testId = CLIENTAPI_UUID_1;
559 ret = sess.Start(&testId);
560 ASSERT_EQ(ret, TEEC_SUCCESS);
561
562 char *testData0 = reinterpret_cast<char *>(malloc(TEST_STR_LEN));
563 ASSERT_STRNE(testData0, NULL);
564 (void)memset_s(testData0, TEST_STR_LEN, 0x0, TEST_STR_LEN);
565
566 /* *allocate shared memory* */
567 testMem.sharedMem.flags = TEEC_MEM_INOUT;
568 testMem.sharedMem.size = TEST_STR_LEN;
569 ret = TEEC_AllocateSharedMemory(&sess.context, &testMem.sharedMem);
570 ASSERT_EQ(ret, TEEC_SUCCESS);
571 testMem.sharedMem.buffer = testData0;
572
573 TEEC_Operation operation = { 0 };
574 operation.started = 1;
575 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_MEMREF_PARTIAL_OUTPUT, TEEC_NONE, TEEC_NONE);
576 operation.params[1].memref.parent = &testMem.sharedMem;
577 operation.params[1].memref.offset = 0;
578 operation.params[1].memref.size = TEST_STR_LEN;
579
580 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_ALLTYPE, &operation, &origin);
581 free(testData0);
582 TEEC_ReleaseSharedMemory(&testMem.sharedMem);
583 ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
584 ASSERT_EQ(origin, TEEC_ORIGIN_API);
585 }
586
587 /**
588 * @testcase.name : InvokeCommand_WithContextIsAlreadyFinalize
589 * @testcase.desc : call TEEC_InvokeCommand With Context is already Finalized
590 * @testcase.expect : return TEEC_ERROR_BAD_PARAMETERS
591 */
592 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithContextIsAlreadyFinalize, Function | MediumTest | Level0)
593 {
594 TEEC_Result ret;
595 uint32_t origin;
596 TEEC_Operation operation = { 0 };
597 TEEC_UUID testId = CLIENTAPI_UUID_1;
598 ClientSessionMgr sess;
599 ret = sess.Start(&testId);
600 EXPECT_EQ(ret, TEEC_SUCCESS);
601 sess.Destroy();
602
603 operation.started = 1;
604 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_MEMREF_TEMP_INOUT, TEEC_NONE, TEEC_NONE);
605 operation.params[1].tmpref.buffer = g_testData0;
606 operation.params[1].tmpref.size = TEST_STR_LEN;
607
608 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_BUFFER, &operation, &origin);
609 ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
610 ASSERT_EQ(origin, TEEC_ORIGIN_API);
611 }
612
613 /**
614 * @testcase.name : InvokeCommand_WithOperationAllType
615 * @testcase.desc : call TEEC_InvokeCommand With paramType is all kind of type
616 * @testcase.expect : return TEEC_SUCCESS
617 */
618 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithOperationAllType, Function | MediumTest | Level0)
619 {
620 TEEC_Result ret;
621 int rc;
622 uint32_t origin;
623 TEEC_Operation operation = { 0 };
624 TEEC_UUID testId = CLIENTAPI_UUID_1;
625 ClientSessionMgr sess;
626 ret = sess.Start(&testId);
627 ASSERT_EQ(ret, TEEC_SUCCESS);
628
629 g_teeInoutLen = strlen(g_teeInout) + 1;
630 ClientShareMemMgr testMem;
631 ClientShareMemMgr nonZeroCopysharedMem;
632 /* *allocate shared memory* */
633 testMem.sharedMem.size = TEST_STR_LEN;
634 testMem.sharedMem.flags = TEEC_MEM_INOUT;
635 ret = TEEC_AllocateSharedMemory(&sess.context, &testMem.sharedMem);
636 ASSERT_EQ(ret, TEEC_SUCCESS);
637 (void)memset_s(testMem.sharedMem.buffer, TEST_STR_LEN, 0x0, TEST_STR_LEN);
638 rc = strcpy_s(reinterpret_cast<char *>(testMem.sharedMem.buffer), testMem.sharedMem.size, g_testData2);
639 ASSERT_EQ(rc, 0);
640
641 /* *register shared memory* */
642 nonZeroCopysharedMem.sharedMem.buffer = g_testData1;
643 nonZeroCopysharedMem.sharedMem.size = TEST_STR_LEN;
644 nonZeroCopysharedMem.sharedMem.flags = TEEC_MEM_INOUT;
645 ret = TEEC_RegisterSharedMemory(&sess.context, &nonZeroCopysharedMem.sharedMem);
646 ASSERT_EQ(ret, TEEC_SUCCESS);
647
648 operation.started = 1;
649 operation.paramTypes =
650 TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_INOUT, TEEC_MEMREF_WHOLE, TEEC_MEMREF_TEMP_INOUT, TEEC_VALUE_INOUT);
651 operation.params[0].memref.parent = &nonZeroCopysharedMem.sharedMem;
652 operation.params[0].memref.offset = 0;
653 operation.params[0].memref.size = nonZeroCopysharedMem.sharedMem.size;
654 operation.params[1].memref.parent = &testMem.sharedMem;
655 operation.params[1].memref.offset = 0;
656 operation.params[1].memref.size = 0;
657 operation.params[2].tmpref.buffer = g_testData0;
658 operation.params[2].tmpref.size = TEST_STR_LEN;
659 operation.params[3].value.a = 0x123;
660 operation.params[3].value.b = 0x987;
661
662 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_ALLTYPE, &operation, &origin);
663 ASSERT_EQ(ret, TEEC_SUCCESS);
664 ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
665 ASSERT_STREQ(reinterpret_cast<char *>(nonZeroCopysharedMem.sharedMem.buffer), g_teeInout);
666 ASSERT_EQ(operation.params[0].memref.size, g_teeInoutLen);
667 ASSERT_STREQ(reinterpret_cast<char *>(testMem.sharedMem.buffer), g_teeInout);
668 ASSERT_EQ(operation.params[1].memref.size, 0);
669 ASSERT_STREQ(reinterpret_cast<char *>(operation.params[2].tmpref.buffer), g_teeInout);
670 ASSERT_EQ(operation.params[2].tmpref.size, g_teeInoutLen);
671 ASSERT_EQ(operation.params[3].value.a, 0x123 - 1);
672 ASSERT_EQ(operation.params[3].value.b, 0x987 - 1);
673 TEEC_ReleaseSharedMemory(&testMem.sharedMem);
674 }
675
676 /**
677 * @testcase.name : InvokeCommand_WithMemrefTempInput1024k
678 * @testcase.desc : call TEEC_InvokeCommand With paramType is TEMP_INPUT and size is 1024k
679 * @testcase.expect : return TEEC_SUCCESS
680 */
681 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithMemrefTempInput1024k, Function | MediumTest | Level0)
682 {
683 TEEC_Result ret;
684 int rc;
685 uint32_t origin;
686 TEEC_Operation operation = { 0 };
687 TEEC_UUID testId = CLIENTAPI_UUID_1;
688 ClientSessionMgr sess;
689 ret = sess.Start(&testId);
690 ASSERT_EQ(ret, TEEC_SUCCESS);
691
692 char *testData0 = reinterpret_cast<char *>(malloc(SIZE_1024K));
693 ASSERT_STRNE(testData0, NULL);
694 (void)memset_s(testData0, SIZE_1024K, 0x0, SIZE_1024K);
695 rc = memcpy_s(testData0, SIZE_1024K, g_testString.c_str(), g_testString.length());
696 ASSERT_EQ(rc, 0);
697
698 operation.started = 1;
699 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_MEMREF_TEMP_INPUT, TEEC_NONE, TEEC_NONE);
700 operation.params[1].tmpref.buffer = testData0;
701 operation.params[1].tmpref.size = SIZE_1024K;
702
703 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_ALLTYPE, &operation, &origin);
704 EXPECT_EQ(ret, TEEC_SUCCESS);
705 EXPECT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
706 EXPECT_STREQ(reinterpret_cast<char *>(operation.params[1].tmpref.buffer), testData0);
707 EXPECT_EQ(operation.params[1].tmpref.size, SIZE_1024K);
708 free(testData0);
709 }
710
711 /**
712 * @testcase.name : InvokeCommand_WithMemrefTempOutput1024k
713 * @testcase.desc : call TEEC_InvokeCommand With paramType is TEMP_OUTPUT and size is 1024k
714 * @testcase.expect : return TEEC_SUCCESS
715 */
716 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithMemrefTempOutput1024k, Function | MediumTest | Level0)
717 {
718 TEEC_Result ret;
719 int rc;
720 uint32_t origin;
721 TEEC_UUID testId = CLIENTAPI_UUID_1;
722 ClientSessionMgr sess;
723 ret = sess.Start(&testId);
724 ASSERT_EQ(ret, TEEC_SUCCESS);
725
726 g_teeOutputLen = strlen(g_teeOutput) + 1;
727 char *testData0 = reinterpret_cast<char *>(malloc(SIZE_1024K));
728 ASSERT_STRNE(testData0, NULL);
729 (void)memset_s(testData0, SIZE_1024K, 0x0, SIZE_1024K);
730 rc = memcpy_s(testData0, SIZE_1024K, g_testString.c_str(), g_testString.length());
731 ASSERT_EQ(rc, 0);
732
733 TEEC_Operation operation = { 0 };
734 operation.started = 1;
735 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_MEMREF_TEMP_OUTPUT, TEEC_NONE, TEEC_NONE);
736 operation.params[1].tmpref.buffer = testData0;
737 operation.params[1].tmpref.size = SIZE_1024K;
738
739 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_ALLTYPE, &operation, &origin);
740 EXPECT_EQ(ret, TEEC_SUCCESS);
741 EXPECT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
742 EXPECT_STREQ(reinterpret_cast<char *>(operation.params[1].tmpref.buffer), g_teeOutput);
743 EXPECT_EQ(operation.params[1].tmpref.size, g_teeOutputLen);
744 free(testData0);
745 }
746
747 /**
748 * @testcase.name : InvokeCommand_WithMemrefTempInout1024k
749 * @testcase.desc : call TEEC_InvokeCommand With paramType is TEMP_INOUT and size is 1024k
750 * @testcase.expect : return TEEC_SUCCESS
751 */
752 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithMemrefTempInout1024k, Function | MediumTest | Level0)
753 {
754 TEEC_Result ret;
755 uint32_t origin;
756 int rc;
757 ClientSessionMgr sess;
758 TEEC_UUID testId = CLIENTAPI_UUID_1;
759 ret = sess.Start(&testId);
760 ASSERT_EQ(ret, TEEC_SUCCESS);
761
762 g_teeInoutLen = strlen(g_teeInout) + 1;
763 char *testData0 = reinterpret_cast<char *>(malloc(SIZE_1024K));
764 ASSERT_STRNE(testData0, NULL);
765 (void)memset_s(testData0, SIZE_1024K, 0x0, SIZE_1024K);
766 rc = memcpy_s(testData0, SIZE_1024K, g_testString.c_str(), g_testString.length());
767 ASSERT_EQ(rc, 0);
768
769 TEEC_Operation operation = { 0 };
770 operation.started = 1;
771 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_MEMREF_TEMP_INOUT, TEEC_NONE, TEEC_NONE);
772 operation.params[1].tmpref.buffer = testData0;
773 operation.params[1].tmpref.size = SIZE_1024K;
774
775 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_ALLTYPE, &operation, &origin);
776 EXPECT_EQ(ret, TEEC_SUCCESS);
777 EXPECT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
778 EXPECT_STREQ(reinterpret_cast<char *>(operation.params[1].tmpref.buffer), g_teeInout);
779 EXPECT_EQ(operation.params[1].tmpref.size, g_teeInoutLen);
780 free(testData0);
781 }
782
783 /**
784 * @testcase.name : InvokeCommand_WithMemrefTempInoutExceed1024k
785 * @testcase.desc : call TEEC_InvokeCommand With paramType is TEMP_INOUT and size is 1024k + 1
786 * @testcase.expect : return TEEC_ERROR_ACCESS_DENIED
787 */
788 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithMemrefTempInoutExceed1024k, Function | MediumTest | Level0)
789 {
790 TEEC_Result ret;
791 int rc;
792 uint32_t origin;
793 ClientSessionMgr sess;
794 TEEC_UUID testId = CLIENTAPI_UUID_1;
795 ret = sess.Start(&testId);
796 ASSERT_EQ(ret, TEEC_SUCCESS);
797
798 char *testData0 = reinterpret_cast<char *>(malloc(SIZE_1024K + 1));
799 ASSERT_STRNE(testData0, NULL);
800 (void)memset_s(testData0, SIZE_1024K + 1, 0x0, SIZE_1024K + 1);
801 rc = memcpy_s(testData0, SIZE_1024K + 1, g_testString.c_str(), g_testString.length());
802 ASSERT_EQ(rc, 0);
803
804 TEEC_Operation operation = { 0 };
805 operation.started = 1;
806 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_MEMREF_TEMP_INOUT, TEEC_NONE, TEEC_NONE);
807 operation.params[1].tmpref.buffer = testData0;
808 operation.params[1].tmpref.size = SIZE_1024K + 1;
809
810 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_ALLTYPE, &operation, &origin);
811 free(testData0);
812 ASSERT_EQ(ret, TEEC_ERROR_ACCESS_DENIED);
813 ASSERT_EQ(origin, TEEC_ORIGIN_COMMS);
814 }
815
816 /**
817 * @testcase.name : InvokeCommand_WithMemrefWhole2048k
818 * @testcase.desc : call TEEC_InvokeCommand With paramType is WHOLE and size is 2048k
819 * @testcase.expect : return TEEC_SUCCESS
820 */
821 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithMemrefWhole2048k, Function | MediumTest | Level0)
822 {
823 TEEC_Result ret;
824 uint32_t origin;
825 ClientSessionMgr sess;
826 TEEC_UUID testId = CLIENTAPI_UUID_1;
827 ret = sess.Start(&testId);
828 ASSERT_EQ(ret, TEEC_SUCCESS);
829
830 /* *allocate shared memory* */
831 ClientShareMemMgr testMem;
832 testMem.sharedMem.size = SIZE_2048K;
833 testMem.sharedMem.flags = TEEC_MEM_INOUT;
834 ret = TEEC_AllocateSharedMemory(&sess.context, &testMem.sharedMem);
835 ASSERT_EQ(ret, TEEC_SUCCESS);
836 (void)memset_s(testMem.sharedMem.buffer, SIZE_2048K, 0x0, SIZE_2048K);
837
838 TEEC_Operation operation = { 0 };
839 operation.started = 1;
840 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_MEMREF_WHOLE, TEEC_NONE, TEEC_NONE);
841 operation.params[1].memref.parent = &testMem.sharedMem;
842 operation.params[1].memref.offset = 0;
843 operation.params[1].memref.size = testMem.sharedMem.size;
844
845 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_ALLTYPE, &operation, &origin);
846 TEEC_ReleaseSharedMemory(&testMem.sharedMem);
847 ASSERT_EQ(ret, TEEC_SUCCESS);
848 ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
849 }
850
851 /**
852 * @testcase.name : InvokeCommand_WithMemrefWholeExceed2048k
853 * @testcase.desc : call TEEC_InvokeCommand With paramType is WHOLE and sharedMem.size is 2048k + 1
854 * @testcase.expect : return TEEC_ERROR_OUT_OF_MEMORY
855 */
856 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithMemrefWholeExceed2048k, Function | MediumTest | Level0)
857 {
858 TEEC_Result ret;
859 uint32_t origin;
860 ClientSessionMgr sess;
861 TEEC_UUID testId = CLIENTAPI_UUID_1;
862 ret = sess.Start(&testId);
863 ASSERT_EQ(ret, TEEC_SUCCESS);
864
865 /* *allocate shared memory* */
866 ClientShareMemMgr testMem;
867 testMem.sharedMem.size = SIZE_2048K + 1;
868 testMem.sharedMem.flags = TEEC_MEM_INOUT;
869 ret = TEEC_AllocateSharedMemory(&sess.context, &testMem.sharedMem);
870 ASSERT_EQ(ret, TEEC_SUCCESS);
871 (void)memset_s(testMem.sharedMem.buffer, SIZE_2048K + 1, 0x0, SIZE_2048K + 1);
872
873 TEEC_Operation operation = { 0 };
874 operation.started = 1;
875 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_MEMREF_WHOLE, TEEC_NONE, TEEC_NONE);
876 operation.params[1].memref.parent = &testMem.sharedMem;
877 operation.params[1].memref.offset = 0;
878 operation.params[1].memref.size = testMem.sharedMem.size;
879
880 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_ALLTYPE, &operation, &origin);
881 TEEC_ReleaseSharedMemory(&testMem.sharedMem);
882 ASSERT_EQ(ret, TEEC_ERROR_OUT_OF_MEMORY);
883 ASSERT_EQ(origin, TEEC_ORIGIN_COMMS);
884 }
885
886 /**
887 * @testcase.name : InvokeCommand_WithMemrefPartialInput2048k
888 * @testcase.desc : call TEEC_InvokeCommand With paramType is PARTIAL_INPUT and size is 2048k
889 * @testcase.expect : return TEEC_SUCCESS
890 */
891 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithMemrefPartialInput2048k, Function | MediumTest | Level0)
892 {
893 TEEC_Result ret;
894 int rc;
895 uint32_t origin;
896 TEEC_Operation operation = { 0 };
897 ClientShareMemMgr testMem;
898 ClientSessionMgr sess;
899 TEEC_UUID testId = CLIENTAPI_UUID_1;
900 ret = sess.Start(&testId);
901 ASSERT_EQ(ret, TEEC_SUCCESS);
902
903 /* *allocate shared memory* */
904 testMem.sharedMem.size = SIZE_2048K;
905 testMem.sharedMem.flags = TEEC_MEM_INOUT;
906 ret = TEEC_AllocateSharedMemory(&sess.context, &testMem.sharedMem);
907 ASSERT_EQ(ret, TEEC_SUCCESS);
908 (void)memset_s(testMem.sharedMem.buffer, SIZE_2048K, 0x0, SIZE_2048K);
909 rc = memcpy_s(testMem.sharedMem.buffer, SIZE_2048K, g_testString.c_str(), g_testString.length());
910 ASSERT_EQ(rc, 0);
911
912 operation.started = 1;
913 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_MEMREF_PARTIAL_INPUT, TEEC_NONE, TEEC_NONE);
914 operation.params[1].memref.parent = &testMem.sharedMem;
915 operation.params[1].memref.offset = 0;
916 operation.params[1].memref.size = testMem.sharedMem.size;
917
918 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_ALLTYPE, &operation, &origin);
919 EXPECT_EQ(ret, TEEC_SUCCESS);
920 EXPECT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
921 EXPECT_STREQ(reinterpret_cast<char *>(testMem.sharedMem.buffer), g_testString.c_str());
922 EXPECT_EQ(operation.params[1].memref.size, SIZE_2048K);
923 TEEC_ReleaseSharedMemory(&testMem.sharedMem);
924 }
925
926 /**
927 * @testcase.name : InvokeCommand_WithMemrefPartialOutput2048k
928 * @testcase.desc : call TEEC_InvokeCommand With paramType is PARTIAL_OUTPUT and size is 2048k
929 * @testcase.expect : return TEEC_SUCCESS
930 */
931 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithMemrefPartialOutput2048k, Function | MediumTest | Level0)
932 {
933 TEEC_Result ret;
934 int rc;
935 uint32_t origin;
936 ClientShareMemMgr testMem;
937 ClientSessionMgr sess;
938 TEEC_UUID testId = CLIENTAPI_UUID_1;
939 ret = sess.Start(&testId);
940 ASSERT_EQ(ret, TEEC_SUCCESS);
941
942 /* *allocate shared memory* */
943 testMem.sharedMem.size = SIZE_2048K;
944 testMem.sharedMem.flags = TEEC_MEM_INOUT;
945 ret = TEEC_AllocateSharedMemory(&sess.context, &testMem.sharedMem);
946 ASSERT_EQ(ret, TEEC_SUCCESS);
947 (void)memset_s(testMem.sharedMem.buffer, SIZE_2048K, 0x0, SIZE_2048K);
948 rc = memcpy_s(testMem.sharedMem.buffer, SIZE_2048K, g_testString.c_str(), g_testString.length());
949 ASSERT_EQ(rc, 0);
950
951 g_teeOutputLen = strlen(g_teeOutput) + 1;
952 TEEC_Operation operation = { 0 };
953 operation.started = 1;
954 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_MEMREF_PARTIAL_OUTPUT, TEEC_NONE, TEEC_NONE);
955 operation.params[1].memref.parent = &testMem.sharedMem;
956 operation.params[1].memref.offset = 0;
957 operation.params[1].memref.size = testMem.sharedMem.size;
958
959 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_ALLTYPE, &operation, &origin);
960 EXPECT_EQ(ret, TEEC_SUCCESS);
961 EXPECT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
962 EXPECT_STREQ(reinterpret_cast<char *>(testMem.sharedMem.buffer), g_teeOutput);
963 EXPECT_EQ(operation.params[1].memref.size, g_teeOutputLen);
964 TEEC_ReleaseSharedMemory(&testMem.sharedMem);
965 }
966
967 /**
968 * @testcase.name : InvokeCommand_WithMemrefPartialInout2048k
969 * @testcase.desc : call TEEC_InvokeCommand With paramType is PARTIAL_INOUT and size is 2048k
970 * @testcase.expect : return TEEC_SUCCESS
971 */
972 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithMemrefPartialInout2048k, Function | MediumTest | Level0)
973 {
974 TEEC_Result ret;
975 int rc;
976 uint32_t origin;
977 ClientShareMemMgr testMem;
978 TEEC_Operation operation = { 0 };
979 ClientSessionMgr sess;
980 TEEC_UUID testId = CLIENTAPI_UUID_1;
981 ret = sess.Start(&testId);
982 ASSERT_EQ(ret, TEEC_SUCCESS);
983
984 /* *allocate shared memory* */
985 g_teeInoutLen = strlen(g_teeInout) + 1;
986 testMem.sharedMem.size = SIZE_2048K;
987 testMem.sharedMem.flags = TEEC_MEM_INOUT;
988 ret = TEEC_AllocateSharedMemory(&sess.context, &testMem.sharedMem);
989 ASSERT_EQ(ret, TEEC_SUCCESS);
990 (void)memset_s(testMem.sharedMem.buffer, SIZE_2048K, 0x0, SIZE_2048K);
991 rc = memcpy_s(testMem.sharedMem.buffer, SIZE_2048K, g_testString.c_str(), g_testString.length());
992 ASSERT_EQ(rc, 0);
993
994 operation.started = 1;
995 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_MEMREF_PARTIAL_INOUT, TEEC_NONE, TEEC_NONE);
996 operation.params[1].memref.parent = &testMem.sharedMem;
997 operation.params[1].memref.offset = 0;
998 operation.params[1].memref.size = testMem.sharedMem.size;
999
1000 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_ALLTYPE, &operation, &origin);
1001 EXPECT_EQ(ret, TEEC_SUCCESS);
1002 EXPECT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
1003 EXPECT_STREQ(reinterpret_cast<char *>(testMem.sharedMem.buffer), g_teeInout);
1004 EXPECT_EQ(operation.params[1].memref.size, g_teeInoutLen);
1005 TEEC_ReleaseSharedMemory(&testMem.sharedMem);
1006 }
1007
1008 /**
1009 * @testcase.name : InvokeCommand_WithMemrefPartialInoutExceed2048k
1010 * @testcase.desc : call TEEC_InvokeCommand With paramType is PARTIAL_INOUT and size is 2048k + 1
1011 * @testcase.expect : return TEEC_ERROR_OUT_OF_MEMORY
1012 */
1013 TEE_TEST(TeeBasicTestFram, InvokeCommand_WithMemrefPartialInoutExceed2048k, Function | MediumTest | Level0)
1014 {
1015 TEEC_Result ret;
1016 int rc;
1017 uint32_t origin;
1018 TEEC_Operation operation = { 0 };
1019 ClientShareMemMgr testMem;
1020 ClientSessionMgr sess;
1021 TEEC_UUID testId = CLIENTAPI_UUID_1;
1022 ret = sess.Start(&testId);
1023 ASSERT_EQ(ret, TEEC_SUCCESS);
1024
1025 /* *allocate shared memory* */
1026 g_teeInoutLen = strlen(g_teeInout) + 1;
1027 testMem.sharedMem.size = SIZE_2048K + 1;
1028 testMem.sharedMem.flags = TEEC_MEM_INOUT;
1029 ret = TEEC_AllocateSharedMemory(&sess.context, &testMem.sharedMem);
1030 ASSERT_EQ(ret, TEEC_SUCCESS);
1031 (void)memset_s(testMem.sharedMem.buffer, SIZE_2048K + 1, 0x0, SIZE_2048K + 1);
1032 rc = memcpy_s(testMem.sharedMem.buffer, SIZE_2048K + 1, g_testString.c_str(), g_testString.length());
1033 ASSERT_EQ(rc, 0);
1034
1035 operation.started = 1;
1036 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_MEMREF_PARTIAL_INOUT, TEEC_NONE, TEEC_NONE);
1037 operation.params[1].memref.parent = &testMem.sharedMem;
1038 operation.params[1].memref.offset = 0;
1039 operation.params[1].memref.size = testMem.sharedMem.size;
1040
1041 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_ALLTYPE, &operation, &origin);
1042 EXPECT_EQ(ret, TEEC_ERROR_OUT_OF_MEMORY);
1043 EXPECT_EQ(origin, TEEC_ORIGIN_COMMS);
1044 EXPECT_STREQ(reinterpret_cast<char *>(testMem.sharedMem.buffer), g_testString.c_str());
1045 EXPECT_EQ(operation.params[1].memref.size, testMem.sharedMem.size);
1046 TEEC_ReleaseSharedMemory(&testMem.sharedMem);
1047 }
1048
1049 /**
1050 * @testcase.name : InvokeCommand_ReturnLenWithMemrefTempOutput
1051 * @testcase.desc : for test TEEC_MEMREF_TEMP_OUTPUT, [0] size < tee size, [1] size < tee size,
1052 * [2] size > tee size, [3] size > tee size
1053 * @testcase.expect : return TEEC_ERROR_SHORT_BUFFER
1054 */
1055 TEE_TEST(TeeBasicTestFram, InvokeCommand_ReturnLenWithMemrefTempOutput, Function | MediumTest | Level0)
1056 {
1057 TEEC_Result ret;
1058 int rc;
1059 uint32_t origin;
1060 ClientSessionMgr sess;
1061 TEEC_UUID testId = CLIENTAPI_UUID_1;
1062 ret = sess.Start(&testId);
1063 ASSERT_EQ(ret, TEEC_SUCCESS);
1064
1065 g_teeOutputLen = strlen(g_teeOutput) + 1;
1066
1067 char *testData0 = reinterpret_cast<char *>(malloc(TEST_SIZE512));
1068 ASSERT_STRNE(testData0, NULL);
1069 (void)memset_s(testData0, TEST_SIZE512, 0x0, TEST_SIZE512);
1070 rc = strcpy_s(testData0, TEST_SIZE512, g_offset0);
1071 ASSERT_EQ(rc, 0);
1072 rc = strcpy_s(testData0 + OFFSET100, TEST_SIZE512 - OFFSET100, g_offset100);
1073 ASSERT_EQ(rc, 0);
1074 rc = strcpy_s(testData0 + OFFSET200, TEST_SIZE512 - OFFSET200, g_offset200);
1075 ASSERT_EQ(rc, 0);
1076 rc = strcpy_s(testData0 + OFFSET300, TEST_SIZE512 - OFFSET300, g_offset300);
1077 ASSERT_EQ(rc, 0);
1078
1079 TEEC_Operation operation = { 0 };
1080 operation.started = 1;
1081 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_OUTPUT, TEEC_MEMREF_TEMP_OUTPUT, TEEC_MEMREF_TEMP_OUTPUT,
1082 TEEC_MEMREF_TEMP_OUTPUT);
1083 operation.params[0].tmpref.buffer = testData0;
1084 operation.params[0].tmpref.size = SIZE10;
1085 operation.params[1].tmpref.buffer = testData0 + OFFSET100;
1086 operation.params[1].tmpref.size = SIZE10;
1087 operation.params[2].tmpref.buffer = testData0 + OFFSET200;
1088 operation.params[2].tmpref.size = SIZE20;
1089 operation.params[3].tmpref.buffer = testData0 + OFFSET300;
1090 operation.params[3].tmpref.size = SIZE20;
1091
1092 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_ALLTYPE, &operation, &origin);
1093 EXPECT_EQ(ret, TEEC_ERROR_SHORT_BUFFER);
1094 EXPECT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
1095 EXPECT_EQ(operation.params[0].tmpref.size, g_teeOutputLen);
1096 EXPECT_EQ(operation.params[1].tmpref.size, g_teeOutputLen);
1097 EXPECT_EQ(operation.params[2].tmpref.size, g_teeOutputLen);
1098 EXPECT_EQ(operation.params[3].tmpref.size, g_teeOutputLen);
1099 EXPECT_STREQ(testData0, g_offset0);
1100 EXPECT_STREQ(testData0 + OFFSET100, g_offset100);
1101 EXPECT_STREQ(testData0 + OFFSET200, g_teeOutput);
1102 EXPECT_STREQ(testData0 + OFFSET300, g_teeOutput);
1103 free(testData0);
1104 }
1105
1106 /**
1107 * @testcase.name : InvokeCommand_ReturnLenWithMemrefTempOutput
1108 * @testcase.desc : for test TEEC_MEMREF_TEMP_INOUT, [0] size > tee size, [1] size < tee size,
1109 * [2] size < tee size [3] size < tee size
1110 * @testcase.expect : return TEEC_ERROR_SHORT_BUFFER
1111 */
1112 TEE_TEST(TeeBasicTestFram, InvokeCommand_ReturnLenWithMemrefTempInout, Function | MediumTest | Level0)
1113 {
1114 TEEC_Result ret;
1115 int rc;
1116 uint32_t origin;
1117 ClientSessionMgr sess;
1118 TEEC_UUID testId = CLIENTAPI_UUID_1;
1119 ret = sess.Start(&testId);
1120 ASSERT_EQ(ret, TEEC_SUCCESS);
1121 g_teeInoutLen = strlen(g_teeInout) + 1;
1122 g_teeOutputLen = strlen(g_teeOutput) + 1;
1123
1124 char *testData0 = reinterpret_cast<char *>(malloc(TEST_SIZE512));
1125 ASSERT_STRNE(testData0, NULL);
1126 (void)memset_s(testData0, TEST_SIZE512, 0x0, TEST_SIZE512);
1127 rc = strcpy_s(testData0, TEST_SIZE512, g_offset0);
1128 ASSERT_EQ(rc, 0);
1129 rc = strcpy_s(testData0 + OFFSET100, TEST_SIZE512 - OFFSET100, g_offset100);
1130 ASSERT_EQ(rc, 0);
1131 rc = strcpy_s(testData0 + OFFSET200, TEST_SIZE512 - OFFSET200, g_offset200);
1132 ASSERT_EQ(rc, 0);
1133 rc = strcpy_s(testData0 + OFFSET300, TEST_SIZE512 - OFFSET300, g_offset300);
1134 ASSERT_EQ(rc, 0);
1135
1136 TEEC_Operation operation = { 0 };
1137 operation.started = 1;
1138 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INOUT, TEEC_MEMREF_TEMP_INOUT, TEEC_MEMREF_TEMP_OUTPUT,
1139 TEEC_MEMREF_TEMP_OUTPUT);
1140 operation.params[0].tmpref.buffer = testData0;
1141 operation.params[0].tmpref.size = SIZE20 + SIZE10;
1142 operation.params[1].tmpref.buffer = testData0 + OFFSET100;
1143 operation.params[1].tmpref.size = SIZE20;
1144 operation.params[2].tmpref.buffer = testData0 + OFFSET200;
1145 operation.params[2].tmpref.size = SIZE10;
1146 operation.params[3].tmpref.buffer = testData0 + OFFSET300;
1147 operation.params[3].tmpref.size = SIZE10;
1148
1149 ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_ALLTYPE, &operation, &origin);
1150 EXPECT_EQ(ret, TEEC_ERROR_SHORT_BUFFER);
1151 EXPECT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
1152 EXPECT_EQ(operation.params[0].tmpref.size, g_teeInoutLen);
1153 EXPECT_EQ(operation.params[1].tmpref.size, g_teeInoutLen);
1154 EXPECT_EQ(operation.params[2].tmpref.size, g_teeOutputLen);
1155 EXPECT_EQ(operation.params[3].tmpref.size, g_teeOutputLen);
1156 EXPECT_STREQ(testData0, g_teeInout);
1157 EXPECT_STREQ(testData0 + OFFSET100, g_offset100);
1158 EXPECT_STREQ(testData0 + OFFSET200, g_offset200);
1159 EXPECT_STREQ(testData0 + OFFSET300, g_offset300);
1160 free(testData0);
1161 }
1162
CreateOpensession(TEEC_Operation * operation,TEEC_Session * session,TEEC_Context * context,uint32_t id)1163 static TEEC_Result CreateOpensession(TEEC_Operation *operation, TEEC_Session *session, TEEC_Context *context,
1164 uint32_t id)
1165 {
1166 uint32_t origin;
1167 TEEC_UUID uuid = CLIENTAPI_UUID_1;
1168 operation->started = 1;
1169 operation->paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_NONE, TEEC_NONE, TEEC_NONE);
1170
1171 char str[64] = { 0 };
1172 sprintf(str,"/data/local/tmp/%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x.sec", uuid.timeLow, uuid.timeMid,
1173 uuid.timeHiAndVersion, uuid.clockSeqAndNode[0], uuid.clockSeqAndNode[1], uuid.clockSeqAndNode[2],
1174 uuid.clockSeqAndNode[3], uuid.clockSeqAndNode[4], uuid.clockSeqAndNode[5], uuid.clockSeqAndNode[6],
1175 uuid.clockSeqAndNode[7]);
1176 context->ta_path = (uint8_t *)str;
1177 TEEC_Result result = TEEC_OpenSession(context, session, &uuid, TEEC_LOGIN_IDENTIFY, NULL, operation, &origin);
1178 if (result != TEEC_SUCCESS)
1179 TEST_PRINT_ERROR("thread %d: TEEC_OpenSession failed, result=0x%x, origin=%d\n", id, result, origin);
1180
1181 return result;
1182 }
1183
SetOperationParams(TEEC_Operation * operation,TEEC_SharedMemory * sharedMem)1184 static void SetOperationParams(TEEC_Operation *operation, TEEC_SharedMemory *sharedMem)
1185 {
1186 operation->started = 1;
1187 operation->paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INOUT, TEEC_MEMREF_PARTIAL_INOUT, TEEC_NONE, TEEC_NONE);
1188 operation->params[0].value.a = 0x10;
1189 operation->params[0].value.b = 0x20;
1190 operation->params[1].memref.parent = sharedMem;
1191 operation->params[1].memref.offset = 0;
1192 operation->params[1].memref.size = TEST_STR_LEN;
1193 return;
1194 }
1195
1196 /* each child thread test OpenSession, Invokecommand, Allocatesharemem */
ThreadTestOpenInvokeAllocmem(void * inParams)1197 static void *ThreadTestOpenInvokeAllocmem(void *inParams)
1198 {
1199 TEEC_Context *context = ((DatePacket *)inParams)->context;
1200 TEEC_Operation operation = { 0 };
1201 TEEC_Session session = { 0 };
1202 TEEC_SharedMemory sharedMem = { 0 };
1203 uint32_t origin;
1204 uint32_t id = ((DatePacket *)inParams)->id;
1205 g_teeInoutLen = strlen(g_teeInout) + 1;
1206
1207 TEEC_Result result = CreateOpensession(&operation, &session, context, id);
1208 if (result != TEEC_SUCCESS) {
1209 ((DatePacket *)inParams)->ret = result;
1210 return NULL;
1211 }
1212 sharedMem.size = TEST_STR_LEN;
1213 sharedMem.flags = TEEC_MEM_INOUT;
1214 result = TEEC_AllocateSharedMemory(context, &sharedMem);
1215 if (result != TEEC_SUCCESS) {
1216 TEST_PRINT_ERROR("thread %d: TEEC_AllocateSharedMemory failed, result=0x%x\n", id, result);
1217 ((DatePacket *)inParams)->ret = result;
1218 goto clean;
1219 }
1220 (void)memset_s(sharedMem.buffer, TEST_STR_LEN, 0x0, TEST_STR_LEN);
1221
1222 SetOperationParams(&operation, &sharedMem);
1223 ((DatePacket *)inParams)->ret = TEEC_InvokeCommand(&session, TEE_TEST_ALLTYPE, &operation, &origin);
1224 if (((DatePacket *)inParams)->ret != TEEC_SUCCESS) {
1225 TEST_PRINT_ERROR("thread %d:Invoke failed,result=0x%x,origin=%d\n", id, ((DatePacket *)inParams)->ret, origin);
1226 goto clean1;
1227 }
1228
1229 if ((operation.params[0].value.a != (0x10 - 1)) || (operation.params[0].value.b != (0x20 - 1))) {
1230 TEST_PRINT_ERROR("thread %d:Invoke value failed,value.a=0x%x,value.b=0x%x\n", id, operation.params[0].value.a,
1231 operation.params[0].value.b);
1232 ((DatePacket *)inParams)->ret = TEEC_ERROR_GENERIC;
1233 }
1234 if ((operation.params[1].memref.size != g_teeInoutLen) ||
1235 (strncmp(g_teeInout, reinterpret_cast<char *>(sharedMem.buffer), g_teeInoutLen) != 0)) {
1236 TEST_PRINT_ERROR("thread %d:Invoke buffer failed,memref.size=%d,sharedMem.buffer=%s\n", id,
1237 operation.params[1].memref.size, reinterpret_cast<char *>(sharedMem.buffer));
1238 ((DatePacket *)inParams)->ret = TEEC_ERROR_GENERIC;
1239 }
1240
1241 TEEC_CloseSession(&session);
1242 TEEC_ReleaseSharedMemory(&sharedMem);
1243 return NULL;
1244 clean1:
1245 TEEC_ReleaseSharedMemory(&sharedMem);
1246 clean:
1247 TEEC_CloseSession(&session);
1248 return NULL;
1249 }
1250
1251 /**
1252 * @testcase.name : InvokeCommand_5Thread_SameContext_DiffSessionAndAllocSharemem
1253 * @testcase.desc : CA create 5 threads use same context, each child thread test OpenSession, Invokecommand,
1254 * Allocatesharemem use seperate session and sharemem
1255 * @testcase.expect : return TEEC_SUCCESS
1256 */
1257 TEE_TEST(TeeBasicTestFramWithInitContext, InvokeCommand_5Thread_SameContext_DiffSessionAndAllocSharemem, Function | MediumTest | Level0)
1258 {
1259 DatePacket iInvokeParams[5];
1260 uint32_t i;
1261 pthread_t id[5];
1262
1263 for (i = 0; i < 5; i++) {
1264 iInvokeParams[i].context = GetContext();
1265 iInvokeParams[i].id = i + 1;
1266 pthread_create(&id[i], NULL, ThreadTestOpenInvokeAllocmem, reinterpret_cast<void *>(&iInvokeParams[i]));
1267 }
1268 for (i = 0; i < 5; i++) {
1269 pthread_join(id[i], NULL);
1270 EXPECT_EQ(iInvokeParams[i].ret, TEEC_SUCCESS);
1271 }
1272 }
1273