• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 <vector>
16 #include <iostream>
17 
18 #include <securec.h>
19 #include <test_defines.h>
20 
21 #include <common_test.h>
22 #include <empty_test.h>
23 #include <public_test.h>
24 #include <session_mgr/client_session_mgr.h>
25 #include <tee_client_api.h>
26 #include <tee_client_type.h>
27 #include <test_comm_cmdid.h>
28 
29 // The test case uses the same string to pass the input and output test of buffer during REE and tee communication
30 static char g_teeOutput[] = "TEEMEM_OUTPUT";
31 static char g_teeInout[] = "the param is TEEMEM_INOUT";
32 static uint32_t g_teeOutputLen;
33 static uint32_t g_teeInoutLen;
34 
35 static char g_offset0[] = "11223344556677889900";
36 static char g_offset100[] = "offset is 100";
37 static char g_offset200[] = "offset is 200";
38 static char g_offset300[] = "offset is 300";
39 
40 
41 #define MAILBOXPOOL_MAX_SIZE (1024 * 1024 * 4)
42 
43 using namespace std;
44 using namespace testing::ext;
45 
46 /**
47  * @testcase.name      : AllocateSharedMemory_WithAllocatedMem
48  * @testcase.desc      : call TEEC_AllocateSharedMemory normal test
49  * @testcase.expect    : return TEEC_SUCCESS
50  */
51 TEE_TEST(TeeBasicTestFramWithInitContext, AllocateSharedMemory_WithAllocatedMem, Function | MediumTest | Level0)
52 {
53     TEEC_Result ret;
54     GetSharedMem()->size = TEST_STR_LEN;
55     GetSharedMem()->flags = TEEC_MEM_INOUT;
56     ret = TEEC_AllocateSharedMemory(GetContext(), GetSharedMem());
57     EXPECT_EQ(ret, TEEC_SUCCESS);
58 }
59 
60 /**
61  * @testcase.name      : AllocateSharedMemory_WithoutContext
62  * @testcase.desc      : call TEEC_AllocateSharedMemory Without Context
63  * @testcase.expect    : return TEEC_ERROR_BAD_PARAMETERS
64  */
65 TEE_TEST(TeeBasicTestFramWithInitContext, AllocateSharedMemory_WithoutContext, Function | MediumTest | Level0)
66 {
67     TEEC_Result ret;
68     GetSharedMem()->size = TEST_STR_LEN;
69     GetSharedMem()->flags = TEEC_MEM_INOUT;
70     ret = TEEC_AllocateSharedMemory(NULL, GetSharedMem());
71     ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
72 }
73 
74 /**
75  * @testcase.name      : AllocateSharedMemory_WithNotInitContext
76  * @testcase.desc      : call TEEC_AllocateSharedMemory With Context is not init
77  * @testcase.expect    : return TEEC_ERROR_BAD_PARAMETERS
78  */
79 TEE_TEST(TeeBasicTestFram, AllocateSharedMemory_WithNotInitContext, Function | MediumTest | Level0)
80 {
81     TEEC_Result ret;
82     TEEC_Context context = { 0 };
83     const char *name = "testname";
84     TEEC_SharedMemory sharedMem;
85     sharedMem.size = TEST_STR_LEN;
86     sharedMem.flags = TEEC_MEM_INOUT;
87     ret = TEEC_InitializeContext(name, &context);
88     EXPECT_EQ(ret, TEEC_SUCCESS);
89     TEEC_FinalizeContext(&context);
90     ret = TEEC_AllocateSharedMemory(&context, &sharedMem);
91     ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
92 }
93 
94 /**
95  * @testcase.name      : AllocateSharedMemory_WithoutSharedMem
96  * @testcase.desc      : call TEEC_AllocateSharedMemory Without SharedMem
97  * @testcase.expect    : return TEEC_ERROR_BAD_PARAMETERS
98  */
99 TEE_TEST(TeeBasicTestFramWithInitContext, AllocateSharedMemory_WithoutSharedMem, Function | MediumTest | Level0)
100 {
101     TEEC_Result ret;
102     ret = TEEC_AllocateSharedMemory(GetContext(), NULL);
103     ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
104 }
105 
106 /**
107  * @testcase.name      : AllocateSharedMemory_WithSharedMemHasReleased
108  * @testcase.desc      : call TEEC_AllocateSharedMemory With SharedMem has Released
109  * @testcase.expect    : return TEEC_ERROR_BAD_PARAMETERS
110  */
111 TEE_TEST(TeeBasicTestFramWithInitContext, AllocateSharedMemory_WithSharedMemHasReleased, Function | MediumTest | Level0)
112 {
113     TEEC_Result ret;
114     GetSharedMem()->size = TEST_STR_LEN;
115     GetSharedMem()->flags = TEEC_MEM_INOUT;
116     ret = TEEC_AllocateSharedMemory(GetContext(), GetSharedMem());
117     EXPECT_EQ(ret, TEEC_SUCCESS);
118 
119     TEEC_ReleaseSharedMemory(GetSharedMem());
120     ret = TEEC_AllocateSharedMemory(GetContext(), GetSharedMem());
121     ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
122 }
123 
124 /**
125  * @testcase.name      : AllocateSharedMemory_WithSharedMemSizeIsZero
126  * @testcase.desc      : call TEEC_AllocateSharedMemory With SharedMem size is 0
127  * @testcase.expect    : return TEEC_SUCCESS
128  */
129 TEE_TEST(TeeBasicTestFramWithInitContext, AllocateSharedMemory_WithSharedMemSizeIsZero, Function | MediumTest | Level0)
130 {
131     TEEC_Result ret;
132     GetSharedMem()->size = 0;
133     GetSharedMem()->flags = TEEC_MEM_INOUT;
134     ret = TEEC_AllocateSharedMemory(GetContext(), GetSharedMem());
135     ASSERT_EQ(ret, TEEC_SUCCESS);
136 }
137 
138 /**
139  * @testcase.name      : AllocateSharedMemory_WithSharedMemFlagIsZero
140  * @testcase.desc      : call TEEC_AllocateSharedMemory With SharedMem flag is 0
141  * @testcase.expect    : return TEEC_ERROR_BAD_PARAMETERS
142  */
143 TEE_TEST(TeeBasicTestFramWithInitContext, AllocateSharedMemory_WithSharedMemFlagIsZero, Function | MediumTest | Level0)
144 {
145     TEEC_Result ret;
146     GetSharedMem()->size = TEST_STR_LEN;
147     GetSharedMem()->flags = 0;
148     ret = TEEC_AllocateSharedMemory(GetContext(), GetSharedMem());
149     ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
150 }
151 
152 /**
153  * @testcase.name      : AllocateSharedMemory_WithSharedMemFlagIsInvalid
154  * @testcase.desc      : call TEEC_AllocateSharedMemory With SharedMem flag is invalid
155  * @testcase.expect    : return TEEC_ERROR_BAD_PARAMETERS
156  */
157 TEE_TEST(TeeBasicTestFramWithInitContext, AllocateSharedMemory_WithSharedMemFlagIsInvalid, Function | MediumTest | Level0)
158 {
159     TEEC_Result ret;
160     GetSharedMem()->size = TEST_STR_LEN;
161     GetSharedMem()->flags = TEEC_MEM_INVALID;
162     ret = TEEC_AllocateSharedMemory(GetContext(), GetSharedMem());
163     ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
164 }
165 
166 /**
167  * @testcase.name      : AllocateSharedMemory_WithFlagInput_UseParamTypesOutput
168  * @testcase.desc      : call TEEC_AllocateSharedMemory With SharedMem flag is input,
169  * while TEEC_InvokeCommand ParamTypes is output
170  * @testcase.expect    : return TEEC_ERROR_BAD_PARAMETERS
171  */
172 TEE_TEST(TeeBasicTestFram, AllocateSharedMemory_WithFlagInput_UseParamTypesOutput, Function | MediumTest | Level0)
173 {
174     TEEC_Result ret;
175     uint32_t origin;
176     ClientSessionMgr sess;
177     TEEC_UUID testId = CLIENTAPI_UUID_1;
178     ret = sess.Start(&testId);
179     EXPECT_EQ(ret, TEEC_SUCCESS);
180 
181     /* *allocate shared memory* */
182     ClientShareMemMgr testMem;
183     testMem.sharedMem.size = TEST_STR_LEN;
184     testMem.sharedMem.flags = TEEC_MEM_INPUT;
185     ret = TEEC_AllocateSharedMemory(&sess.context, &testMem.sharedMem);
186     ASSERT_EQ(ret, TEEC_SUCCESS);
187     (void)memset_s(testMem.sharedMem.buffer, testMem.sharedMem.size, 0x0, testMem.sharedMem.size);
188 
189     TEEC_Operation operation = { 0 };
190     operation.started = 1;
191     operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_OUTPUT, TEEC_NONE, TEEC_NONE, TEEC_NONE);
192     operation.params[0].memref.parent = &testMem.sharedMem;
193     operation.params[0].memref.offset = 0;
194     operation.params[0].memref.size = testMem.sharedMem.size;
195     ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_ALLTYPE, &operation, &origin);
196     TEEC_ReleaseSharedMemory(&testMem.sharedMem);
197     ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
198     ASSERT_EQ(origin, TEEC_ORIGIN_API);
199 }
200 
201 /**
202  * @testcase.name      : AllocateSharedMemory_WithFlagInput_UseParamTypesInout
203  * @testcase.desc      : call TEEC_AllocateSharedMemory With SharedMem flag is input,
204  * while TEEC_InvokeCommand ParamTypes is inout
205  * @testcase.expect    : return TEEC_ERROR_BAD_PARAMETERS
206  */
207 TEE_TEST(TeeBasicTestFram, AllocateSharedMemory_WithFlagInput_UseParamTypesInout, Function | MediumTest | Level0)
208 {
209     TEEC_Result ret;
210     uint32_t origin;
211     ClientSessionMgr sess;
212     TEEC_UUID testId = CLIENTAPI_UUID_1;
213     ret = sess.Start(&testId);
214     EXPECT_EQ(ret, TEEC_SUCCESS);
215 
216     /* *allocate shared memory* */
217     ClientShareMemMgr testMem;
218     testMem.sharedMem.flags = TEEC_MEM_INPUT;
219     testMem.sharedMem.size = TEST_STR_LEN;
220     ret = TEEC_AllocateSharedMemory(&sess.context, &testMem.sharedMem);
221     ASSERT_EQ(ret, TEEC_SUCCESS);
222     (void)memset_s(testMem.sharedMem.buffer, testMem.sharedMem.size, 0x0, testMem.sharedMem.size);
223 
224     TEEC_Operation operation = { 0 };
225     operation.started = 1;
226     operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_INOUT, TEEC_NONE, TEEC_NONE, TEEC_NONE);
227     operation.params[0].memref.parent = &testMem.sharedMem;
228     operation.params[0].memref.offset = 0;
229     operation.params[0].memref.size = testMem.sharedMem.size;
230     ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_ALLTYPE, &operation, &origin);
231     TEEC_ReleaseSharedMemory(&testMem.sharedMem);
232     ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
233     ASSERT_EQ(origin, TEEC_ORIGIN_API);
234 }
235 
236 /**
237  * @testcase.name      : AllocateSharedMemory_WithFlagInput_UseParamTypesWhole
238  * @testcase.desc      : call TEEC_AllocateSharedMemory With SharedMem flag is input,
239  * while TEEC_InvokeCommand ParamTypes is whole
240  * @testcase.expect    : return TEEC_SUCCESS
241  */
242 TEE_TEST(TeeBasicTestFram, AllocateSharedMemory_WithFlagInput_UseParamTypesWhole, Function | MediumTest | Level0)
243 {
244     TEEC_Result ret;
245     uint32_t origin;
246     TEEC_Operation operation = { 0 };
247     ClientSessionMgr sess;
248     TEEC_UUID testId = CLIENTAPI_UUID_1;
249     ret = sess.Start(&testId);
250     EXPECT_EQ(ret, TEEC_SUCCESS);
251 
252     /* *allocate shared memory* */
253     ClientShareMemMgr testMem;
254     testMem.sharedMem.flags = TEEC_MEM_INPUT;
255     testMem.sharedMem.size = TEST_STR_LEN;
256     ret = TEEC_AllocateSharedMemory(&sess.context, &testMem.sharedMem);
257     ASSERT_EQ(ret, TEEC_SUCCESS);
258     (void)memset_s(testMem.sharedMem.buffer, testMem.sharedMem.size, 0x0, testMem.sharedMem.size);
259 
260     operation.started = 1;
261     operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_INPUT, TEEC_MEMREF_WHOLE, TEEC_NONE, TEEC_NONE);
262     operation.params[0].memref.parent = &testMem.sharedMem;
263     operation.params[0].memref.offset = OFFSET100;
264     operation.params[0].memref.size = testMem.sharedMem.size - OFFSET100;
265     operation.params[1].memref.parent = &testMem.sharedMem;
266     operation.params[1].memref.offset = 0;
267     operation.params[1].memref.size = 0;
268     ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_ALLTYPE, &operation, &origin);
269     TEEC_ReleaseSharedMemory(&testMem.sharedMem);
270     ASSERT_EQ(ret, TEEC_SUCCESS);
271     ASSERT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
272 }
273 
274 /**
275  * @testcase.name      : AllocateSharedMemory_WithFlagOutput_UseParamTypesInput
276  * @testcase.desc      : call TEEC_AllocateSharedMemory With SharedMem flag is output,
277  * while TEEC_InvokeCommand ParamTypes is input
278  * @testcase.expect    : return TEEC_ERROR_BAD_PARAMETERS
279  */
280 TEE_TEST(TeeBasicTestFram, AllocateSharedMemory_WithFlagOutput_UseParamTypesInput, Function | MediumTest | Level0)
281 {
282     TEEC_Result ret;
283     uint32_t origin;
284     ClientSessionMgr sess;
285     TEEC_UUID testId = CLIENTAPI_UUID_1;
286     ret = sess.Start(&testId);
287     EXPECT_EQ(ret, TEEC_SUCCESS);
288 
289     /* *allocate shared memory* */
290     ClientShareMemMgr testMem;
291     testMem.sharedMem.size = TEST_STR_LEN;
292     testMem.sharedMem.flags = TEEC_MEM_OUTPUT;
293     ret = TEEC_AllocateSharedMemory(&sess.context, &testMem.sharedMem);
294     ASSERT_EQ(ret, TEEC_SUCCESS);
295     (void)memset_s(testMem.sharedMem.buffer, testMem.sharedMem.size, 0x0, testMem.sharedMem.size);
296 
297     TEEC_Operation operation = { 0 };
298     operation.started = 1;
299     operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_INPUT, TEEC_NONE, TEEC_NONE, TEEC_NONE);
300     operation.params[0].memref.parent = &testMem.sharedMem;
301     operation.params[0].memref.offset = 0;
302     operation.params[0].memref.size = testMem.sharedMem.size;
303     ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_ALLTYPE, &operation, &origin);
304     TEEC_ReleaseSharedMemory(&testMem.sharedMem);
305     ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
306     ASSERT_EQ(origin, TEEC_ORIGIN_API);
307 }
308 
309 /**
310  * @testcase.name      : AllocateSharedMemory_WithFlagOutput_UseParamTypesInout
311  * @testcase.desc      : call TEEC_AllocateSharedMemory With SharedMem flag is output,
312  * while TEEC_InvokeCommand ParamTypes is inout
313  * @testcase.expect    : return TEEC_ERROR_BAD_PARAMETERS
314  */
315 TEE_TEST(TeeBasicTestFram, AllocateSharedMemory_WithFlagOutput_UseParamTypesInout, Function | MediumTest | Level0)
316 {
317     TEEC_Result ret;
318     uint32_t origin;
319     ClientSessionMgr sess;
320     TEEC_UUID testId = CLIENTAPI_UUID_1;
321     ret = sess.Start(&testId);
322     EXPECT_EQ(ret, TEEC_SUCCESS);
323 
324     /* *allocate shared memory* */
325     ClientShareMemMgr testMem;
326     testMem.sharedMem.flags = TEEC_MEM_OUTPUT;
327     testMem.sharedMem.size = TEST_STR_LEN;
328     ret = TEEC_AllocateSharedMemory(&sess.context, &testMem.sharedMem);
329     ASSERT_EQ(ret, TEEC_SUCCESS);
330     (void)memset_s(testMem.sharedMem.buffer, testMem.sharedMem.size, 0x0, testMem.sharedMem.size);
331 
332     TEEC_Operation operation = { 0 };
333     operation.started = 1;
334     operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_INOUT, TEEC_NONE, TEEC_NONE, TEEC_NONE);
335     operation.params[0].memref.parent = &testMem.sharedMem;
336     operation.params[0].memref.offset = 0;
337     operation.params[0].memref.size = testMem.sharedMem.size;
338     ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_ALLTYPE, &operation, &origin);
339     TEEC_ReleaseSharedMemory(&testMem.sharedMem);
340     ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
341     ASSERT_EQ(origin, TEEC_ORIGIN_API);
342 }
343 
344 /**
345  * @testcase.name      : AllocateSharedMemory_WithFlagOutput_UseParamTypesWhole
346  * @testcase.desc      : call TEEC_AllocateSharedMemory With SharedMem flag is output,
347  * while TEEC_InvokeCommand ParamTypes is whole
348  * @testcase.expect    : return TEEC_SUCCESS ,output buffer is correct
349  */
350 TEE_TEST(TeeBasicTestFram, AllocateSharedMemory_WithFlagOutput_UseParamTypesWhole, Function | MediumTest | Level0)
351 {
352     TEEC_Result ret;
353     uint32_t origin;
354     ClientSessionMgr sess;
355     TEEC_UUID testId = CLIENTAPI_UUID_1;
356     ret = sess.Start(&testId);
357     EXPECT_EQ(ret, TEEC_SUCCESS);
358 
359     g_teeOutputLen = strlen(g_teeOutput) + 1;
360 
361     /* *allocate shared memory* */
362     ClientShareMemMgr testMem;
363     testMem.sharedMem.flags = TEEC_MEM_OUTPUT;
364     testMem.sharedMem.size = TEST_STR_LEN;
365     ret = TEEC_AllocateSharedMemory(&sess.context, &testMem.sharedMem);
366     ASSERT_EQ(ret, TEEC_SUCCESS);
367     (void)memset_s(testMem.sharedMem.buffer, testMem.sharedMem.size, 0x0, testMem.sharedMem.size);
368 
369     TEEC_Operation operation = { 0 };
370     operation.started = 1;
371     operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_OUTPUT, TEEC_MEMREF_WHOLE, TEEC_NONE, TEEC_NONE);
372     operation.params[0].memref.parent = &testMem.sharedMem;
373     operation.params[0].memref.offset = OFFSET100;
374     operation.params[0].memref.size = testMem.sharedMem.size - OFFSET100;
375     operation.params[1].memref.parent = &testMem.sharedMem;
376     operation.params[1].memref.offset = 0;
377     operation.params[1].memref.size = 0;
378     ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_ALLTYPE, &operation, &origin);
379     EXPECT_EQ(ret, TEEC_SUCCESS);
380     EXPECT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
381     EXPECT_STREQ(reinterpret_cast<char *>(testMem.sharedMem.buffer) + OFFSET100, g_teeOutput);
382     EXPECT_EQ(operation.params[0].memref.size, g_teeOutputLen);
383     EXPECT_STREQ(reinterpret_cast<char *>(testMem.sharedMem.buffer), g_teeOutput);
384     EXPECT_EQ(operation.params[1].memref.size, 0);
385     TEEC_ReleaseSharedMemory(&testMem.sharedMem);
386 }
387 
CopyToBuffer(char * buffer,uint32_t buffer_size)388 static int CopyToBuffer(char *buffer, uint32_t buffer_size)
389 {
390     int rc = strcpy_s(buffer, buffer_size, g_offset0);
391     EXPECT_EQ(rc, 0);
392     rc = strcpy_s(buffer + OFFSET100, buffer_size - OFFSET100, g_offset100);
393     EXPECT_EQ(rc, 0);
394     rc = strcpy_s(buffer + OFFSET200, buffer_size - OFFSET200, g_offset200);
395     EXPECT_EQ(rc, 0);
396     rc = strcpy_s(buffer + OFFSET300, buffer_size - OFFSET300, g_offset300);
397     EXPECT_EQ(rc, 0);
398     return rc;
399 }
400 
401 /**
402  * @testcase.name      : AllocateSharedMemory_ReturnLenUseTypesOutput
403  * @testcase.desc      : test for allocatedshared with some params ree size less tee write size, use output types
404  * @testcase.expect    : return TEEC_ERROR_SHORT_BUFFER ,output buffer is correct
405  */
406 TEE_TEST(TeeBasicTestFram, AllocateSharedMemory_ReturnLenUseTypesOutput, Function | MediumTest | Level0)
407 {
408     TEEC_Result ret;
409     uint32_t origin;
410     int rc;
411     ClientSessionMgr sess;
412     TEEC_UUID testId = CLIENTAPI_UUID_1;
413     ret = sess.Start(&testId);
414     EXPECT_EQ(ret, TEEC_SUCCESS);
415 
416     g_teeOutputLen = strlen(g_teeOutput) + 1;
417 
418     /* *allocate shared memory* */
419     ClientShareMemMgr testMem;
420     testMem.sharedMem.flags = TEEC_MEM_OUTPUT;
421     testMem.sharedMem.size = TEST_SIZE512;
422     ret = TEEC_AllocateSharedMemory(&sess.context, &testMem.sharedMem);
423     ASSERT_EQ(ret, TEEC_SUCCESS);
424     (void)memset_s(testMem.sharedMem.buffer, testMem.sharedMem.size, 0x0, testMem.sharedMem.size);
425     rc = CopyToBuffer(reinterpret_cast<char *>(testMem.sharedMem.buffer), testMem.sharedMem.size);
426     EXPECT_EQ(rc, 0);
427 
428     TEEC_Operation operation = { 0 };
429     /* for test TEEC_MEMREF_PARTIAL_OUTPUT, [0] size < tee size, [1] size < tee size [2] size > tee size [3] size > tee
430      * size */
431     operation.started = 1;
432     operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_OUTPUT, TEEC_MEMREF_PARTIAL_OUTPUT,
433         TEEC_MEMREF_PARTIAL_OUTPUT, TEEC_MEMREF_PARTIAL_OUTPUT);
434     operation.params[0].memref.parent = &testMem.sharedMem;
435     operation.params[0].memref.offset = 0;
436     operation.params[0].memref.size = SIZE10;
437     operation.params[1].memref.parent = &testMem.sharedMem;
438     operation.params[1].memref.offset = OFFSET100;
439     operation.params[1].memref.size = SIZE10;
440     operation.params[2].memref.parent = &testMem.sharedMem;
441     operation.params[2].memref.offset = OFFSET200;
442     operation.params[2].memref.size = SIZE20;
443     operation.params[3].memref.parent = &testMem.sharedMem;
444     operation.params[3].memref.offset = OFFSET300;
445     operation.params[3].memref.size = SIZE20;
446     ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_ALLTYPE, &operation, &origin);
447     EXPECT_EQ(ret, TEEC_ERROR_SHORT_BUFFER);
448     EXPECT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
449     EXPECT_EQ(operation.params[0].memref.size, g_teeOutputLen);
450     EXPECT_EQ(operation.params[1].memref.size, g_teeOutputLen);
451     EXPECT_EQ(operation.params[2].memref.size, g_teeOutputLen);
452     EXPECT_EQ(operation.params[3].memref.size, g_teeOutputLen);
453     EXPECT_STREQ(reinterpret_cast<char *>(testMem.sharedMem.buffer), g_offset0);
454     EXPECT_STREQ(reinterpret_cast<char *>(testMem.sharedMem.buffer) + OFFSET100, g_offset100);
455     EXPECT_STREQ(reinterpret_cast<char *>(testMem.sharedMem.buffer) + OFFSET200, g_teeOutput);
456     EXPECT_STREQ(reinterpret_cast<char *>(testMem.sharedMem.buffer) + OFFSET300, g_teeOutput);
457     TEEC_ReleaseSharedMemory(&testMem.sharedMem);
458 }
459 
460 /**
461  * @testcase.name      : AllocateSharedMemory_ReturnLenUseTypesInout
462  * @testcase.desc      : test for allocatedshared with some params ree size less tee write size, use inout types
463  * @testcase.expect    : return TEEC_ERROR_SHORT_BUFFER ,output buffer is correct
464  */
465 TEE_TEST(TeeBasicTestFram, AllocateSharedMemory_ReturnLenUseTypesInout, Function | MediumTest | Level0)
466 {
467     TEEC_Result ret;
468     uint32_t origin;
469     int rc;
470     ClientSessionMgr sess;
471     TEEC_UUID testId = CLIENTAPI_UUID_1;
472     ret = sess.Start(&testId);
473     EXPECT_EQ(ret, TEEC_SUCCESS);
474 
475     g_teeOutputLen = strlen(g_teeOutput) + 1;
476     g_teeInoutLen = strlen(g_teeInout) + 1;
477     /* *allocate shared memory* */
478     ClientShareMemMgr testMem;
479     testMem.sharedMem.size = TEST_SIZE512;
480     testMem.sharedMem.flags = TEEC_MEM_INOUT;
481     ret = TEEC_AllocateSharedMemory(&sess.context, &testMem.sharedMem);
482     ASSERT_EQ(ret, TEEC_SUCCESS);
483     (void)memset_s(testMem.sharedMem.buffer, testMem.sharedMem.size, 0x0, testMem.sharedMem.size);
484     rc = CopyToBuffer(reinterpret_cast<char *>(testMem.sharedMem.buffer), testMem.sharedMem.size);
485     EXPECT_EQ(rc, 0);
486 
487     TEEC_Operation operation = { 0 };
488     /* for test TEEC_MEMREF_PARTIAL_INOUT, [0] size > tee size, [1] size < tee size [2] size < tee size [3] size < tee
489      * size */
490     operation.started = 1;
491     operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_INOUT, TEEC_MEMREF_PARTIAL_INOUT,
492         TEEC_MEMREF_PARTIAL_OUTPUT, TEEC_MEMREF_PARTIAL_OUTPUT);
493     operation.params[0].memref.parent = &testMem.sharedMem;
494     operation.params[0].memref.offset = 0;
495     operation.params[0].memref.size = SIZE20 + SIZE10;
496     operation.params[1].memref.parent = &testMem.sharedMem;
497     operation.params[1].memref.offset = OFFSET100;
498     operation.params[1].memref.size = SIZE20;
499     operation.params[2].memref.parent = &testMem.sharedMem;
500     operation.params[2].memref.offset = OFFSET200;
501     operation.params[2].memref.size = SIZE10;
502     operation.params[3].memref.parent = &testMem.sharedMem;
503     operation.params[3].memref.offset = OFFSET300;
504     operation.params[3].memref.size = SIZE10;
505     ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_ALLTYPE, &operation, &origin);
506     EXPECT_EQ(ret, TEEC_ERROR_SHORT_BUFFER);
507     EXPECT_EQ(origin, TEEC_ORIGIN_TRUSTED_APP);
508     EXPECT_EQ(operation.params[0].memref.size, g_teeInoutLen);
509     EXPECT_EQ(operation.params[1].memref.size, g_teeInoutLen);
510     EXPECT_EQ(operation.params[2].memref.size, g_teeOutputLen);
511     EXPECT_EQ(operation.params[3].memref.size, g_teeOutputLen);
512     EXPECT_STREQ(reinterpret_cast<char *>(testMem.sharedMem.buffer), g_teeInout);
513     EXPECT_STREQ(reinterpret_cast<char *>(testMem.sharedMem.buffer) + OFFSET100, g_offset100);
514     EXPECT_STREQ(reinterpret_cast<char *>(testMem.sharedMem.buffer) + OFFSET200, g_offset200);
515     EXPECT_STREQ(reinterpret_cast<char *>(testMem.sharedMem.buffer) + OFFSET300, g_offset300);
516     TEEC_ReleaseSharedMemory(&testMem.sharedMem);
517 }
518 
519 /**
520  * @testcase.name      : AllocateSharedMemory_OffsetExceedTest1
521  * @testcase.desc      : test for memref.offset + memref.size > sharedMem.size ,should return bad params
522  * @testcase.expect    : return TEEC_ERROR_BAD_PARAMETERS
523  */
524 TEE_TEST(TeeBasicTestFram, AllocateSharedMemory_OffsetExceedTest1, Function | MediumTest | Level0)
525 {
526     TEEC_Result ret;
527     uint32_t origin;
528     ClientSessionMgr sess;
529     TEEC_UUID testId = CLIENTAPI_UUID_1;
530     ret = sess.Start(&testId);
531     EXPECT_EQ(ret, TEEC_SUCCESS);
532 
533     g_teeOutputLen = strlen(g_teeOutput) + 1;
534     /* *allocate shared memory* */
535     ClientShareMemMgr testMem;
536     testMem.sharedMem.size = TEST_SIZE512;
537     testMem.sharedMem.flags = TEEC_MEM_INOUT;
538     ret = TEEC_AllocateSharedMemory(&sess.context, &testMem.sharedMem);
539     ASSERT_EQ(ret, TEEC_SUCCESS);
540     (void)memset_s(testMem.sharedMem.buffer, testMem.sharedMem.size, 0x0, testMem.sharedMem.size);
541 
542     TEEC_Operation operation = { 0 };
543     operation.started = 1;
544     operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_OUTPUT, TEEC_MEMREF_PARTIAL_OUTPUT,
545         TEEC_MEMREF_PARTIAL_OUTPUT, TEEC_MEMREF_PARTIAL_OUTPUT);
546     operation.params[0].memref.parent = &testMem.sharedMem;
547     operation.params[0].memref.offset = 0;
548     operation.params[0].memref.size = SIZE10;
549     operation.params[1].memref.parent = &testMem.sharedMem;
550     operation.params[1].memref.offset = OFFSET100;
551     operation.params[1].memref.size = SIZE10;
552     operation.params[2].memref.parent = &testMem.sharedMem;
553     operation.params[2].memref.offset = OFFSET200;
554     operation.params[2].memref.size = SIZE20;
555     operation.params[3].memref.parent = &testMem.sharedMem;
556     operation.params[3].memref.offset = TEST_SIZE512 - SIZE10 + 1;
557     operation.params[3].memref.size = SIZE10;
558     ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_ALLTYPE, &operation, &origin);
559     TEEC_ReleaseSharedMemory(&testMem.sharedMem);
560     ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
561     ASSERT_EQ(origin, TEEC_ORIGIN_API);
562 }
563 
564 /**
565  * @testcase.name      : AllocateSharedMemory_OffsetExceedTest2
566  * @testcase.desc      : test for memref.offset > sharedMem.size ,should return bad params
567  * @testcase.expect    : return TEEC_ERROR_BAD_PARAMETERS
568  */
569 TEE_TEST(TeeBasicTestFram, AllocateSharedMemory_OffsetExceedTest2, Function | MediumTest | Level0)
570 {
571     TEEC_Result ret;
572     uint32_t origin;
573     ClientSessionMgr sess;
574     TEEC_UUID testId = CLIENTAPI_UUID_1;
575     ret = sess.Start(&testId);
576     EXPECT_EQ(ret, TEEC_SUCCESS);
577 
578     g_teeOutputLen = strlen(g_teeOutput) + 1;
579     /* *allocate shared memory* */
580     ClientShareMemMgr testMem;
581     testMem.sharedMem.flags = TEEC_MEM_INOUT;
582     testMem.sharedMem.size = TEST_SIZE512;
583     ret = TEEC_AllocateSharedMemory(&sess.context, &testMem.sharedMem);
584     ASSERT_EQ(ret, TEEC_SUCCESS);
585     (void)memset_s(testMem.sharedMem.buffer, testMem.sharedMem.size, 0x0, testMem.sharedMem.size);
586 
587     TEEC_Operation operation = { 0 };
588     operation.started = 1;
589     operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_INOUT, TEEC_MEMREF_PARTIAL_INOUT,
590         TEEC_MEMREF_PARTIAL_INOUT, TEEC_MEMREF_PARTIAL_INOUT);
591     operation.params[0].memref.parent = &testMem.sharedMem;
592     operation.params[0].memref.offset = 0;
593     operation.params[0].memref.size = SIZE10;
594     operation.params[1].memref.parent = &testMem.sharedMem;
595     operation.params[1].memref.offset = OFFSET100;
596     operation.params[1].memref.size = SIZE10;
597     operation.params[2].memref.parent = &testMem.sharedMem;
598     operation.params[2].memref.offset = OFFSET200;
599     operation.params[2].memref.size = SIZE20;
600     operation.params[3].memref.parent = &testMem.sharedMem;
601     operation.params[3].memref.offset = TEST_SIZE512 + 1;
602     operation.params[3].memref.size = SIZE10;
603     ret = TEEC_InvokeCommand(&sess.session, TEE_TEST_ALLTYPE, &operation, &origin);
604     TEEC_ReleaseSharedMemory(&testMem.sharedMem);
605     ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
606     ASSERT_EQ(origin, TEEC_ORIGIN_API);
607 }
608 
609 /**
610  * @testcase.name      : AllocateSharedMemory_WithSizeExceed
611  * @testcase.desc      : call TEEC_AllocateSharedMemory With SharedMem size exceed 4M
612  * @testcase.expect    : return TEEC_ERROR_BAD_PARAMETERS
613  */
614 TEE_TEST(TeeBasicTestFramWithInitContext, AllocateSharedMemory_WithSizeExceed, Function | MediumTest | Level0)
615 {
616     TEEC_Result ret;
617     GetSharedMem()->size = MAILBOXPOOL_MAX_SIZE + 1; // 4M + 1
618     GetSharedMem()->flags = TEEC_MEM_INOUT;
619     ret = TEEC_AllocateSharedMemory(GetContext(), GetSharedMem());
620     ASSERT_EQ(ret, TEEC_ERROR_OUT_OF_MEMORY);
621 }
622 
623 #define SHAREMEM_LIMIT_MAX 64
624 
625 /**
626  * @testcase.name      : AllocateSharedMemory_ReachSharememNumLimit
627  * @testcase.desc      : call TEEC_AllocateSharedMemory With same Context 65 times,
628  * This case will generate wild pointers, but these pointers are all hung on the same context.
629  * The teardown function at the end of the use case will recycle the context to ensure the
630  * recycling of these wild pointers.
631  * @testcase.expect    : alloc 65 times should return TEEC_ERROR_BAD_PARAMETERS
632  */
633 TEE_TEST(TeeBasicTestFramWithInitContext, AllocateSharedMemory_ReachSharememNumLimit, Function | MediumTest | Level0)
634 {
635     TEEC_Result ret;
636     uint32_t i;
637     GetSharedMem()->size = TEST_STR_LEN; // 256
638     GetSharedMem()->flags = TEEC_MEM_INOUT;
639 
640     for (i = 1; i <= SHAREMEM_LIMIT_MAX; i++) {
641         ret = TEEC_AllocateSharedMemory(GetContext(), GetSharedMem());
642         ASSERT_EQ(ret, TEEC_SUCCESS);
643     }
644 
645     // alloc 65 times
646     ret = TEEC_AllocateSharedMemory(GetContext(), GetSharedMem());
647     ASSERT_EQ(ret, TEEC_ERROR_BAD_PARAMETERS);
648 }