1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <cstddef>
18 #include <cstdint>
19 #include <iostream>
20 #include <cstdio>
21 #include <ctime>
22 #include <memory>
23 #include <cstring>
24 #include <securec.h>
25 #include <unistd.h>
26 #include <sys/types.h>
27 #include <sys/ioctl.h>
28 #include "tee_client_type.h"
29 #include "tee_client.h"
30 #include "tee_log.h"
31 #include "tc_ns_client.h"
32 #include "tee_client_ext_api.h"
33 #include "tee_client_api.h"
34 #include "tee_client_inner_api.h"
35 #include "tee_client_app_load.h"
36
37 using namespace testing::ext;
38 using namespace OHOS;
39 class TeecVendorTest : public testing::Test {
40 public:
41 static void SetUpTestCase(void);
42 static void TearDownTestCase(void);
43 void SetUp();
44 void TearDown();
45 };
46
SetUpTestCase(void)47 void TeecVendorTest::SetUpTestCase(void)
48 {
49 printf("SetUp\n");
50 }
51
TearDownTestCase(void)52 void TeecVendorTest::TearDownTestCase(void)
53 {
54 printf("SetUpTestCase\n");
55 }
56
SetUp(void)57 void TeecVendorTest::SetUp(void)
58 {
59 printf("TearDownTestCase\n");
60 }
61
TearDown(void)62 void TeecVendorTest::TearDown(void)
63 {
64 printf("TearDown\n");
65 }
66 namespace {
67 HWTEST_F(TeecVendorTest, SetBitTest_001, TestSize.Level1)
68 {
69 uint32_t i = 0, byteMax = 0;
70 uint8_t bitMap = 0;
71
72 SetBit(i, byteMax, nullptr);
73
74 byteMax = 1;
75 SetBit(i, byteMax, nullptr);
76
77 SetBit(i, byteMax, &bitMap);
78 EXPECT_TRUE(bitMap != 0);
79 }
80
81 HWTEST_F(TeecVendorTest, CheckBitTest_001, TestSize.Level1)
82 {
83 uint32_t i = 0, byteMax = 0;
84 uint8_t bitMap = 0;
85
86 bool ret = CheckBit(i, byteMax, nullptr);
87 EXPECT_TRUE(ret == false);
88
89 byteMax = 1;
90 ret = CheckBit(i, byteMax, nullptr);
91 EXPECT_TRUE(ret == false);
92
93 ret = CheckBit(i, byteMax, &bitMap);
94 EXPECT_TRUE(ret == false);
95 }
96
97 HWTEST_F(TeecVendorTest, ClearBitTest_001, TestSize.Level1)
98 {
99 uint32_t i = 0, byteMax = 0;
100 uint8_t bitMap = 0;
101
102 ClearBit(i, byteMax, nullptr);
103 EXPECT_TRUE(bitMap == 0);
104
105 byteMax = 1;
106 ClearBit(i, byteMax, nullptr);
107 EXPECT_TRUE(bitMap == 0);
108
109 ClearBit(i, byteMax, &bitMap);
110 EXPECT_TRUE(bitMap == 0);
111 }
112
113 HWTEST_F(TeecVendorTest, GetAndSetBitTest_001, TestSize.Level1)
114 {
115 uint8_t bitMap[1] = { 0 };
116 uint32_t byteMax = 0;
117
118 int32_t ret = GetAndSetBit(nullptr, byteMax);
119 EXPECT_TRUE(ret != 0);
120
121 byteMax = 1;
122 ret = GetAndSetBit(bitMap, byteMax);
123 EXPECT_TRUE(ret != -1);
124
125 bitMap[0] = 0xff;
126 ret = GetAndSetBit(bitMap, byteMax);
127 EXPECT_TRUE(ret != 0);
128 }
129
130 HWTEST_F(TeecVendorTest, GetAndCleartBitTest_001, TestSize.Level1)
131 {
132 uint8_t bitMap[1] = { 0 };
133 uint32_t byteMax = 0;
134
135 int32_t ret = GetAndCleartBit(nullptr, byteMax);
136 EXPECT_TRUE(ret != 0);
137
138 byteMax = 1;
139 ret = GetAndCleartBit(bitMap, byteMax);
140 EXPECT_TRUE(ret != 0);
141
142 bitMap[0] = 0xff;
143 ret = GetAndCleartBit(bitMap, byteMax);
144 EXPECT_TRUE(ret != -1);
145 }
146
147 HWTEST_F(TeecVendorTest, TEEC_RegisterSharedMemoryInnerTest_001, TestSize.Level1)
148 {
149 TEEC_ContextInner context = { 0 };
150 TEEC_SharedMemoryInner sharedMem = { 0 };
151
152 TEEC_Result ret = TEEC_RegisterSharedMemoryInner(nullptr, &sharedMem);
153 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
154
155 ret = TEEC_RegisterSharedMemoryInner(&context, nullptr);
156 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
157
158 sharedMem.buffer = nullptr;
159 ret = TEEC_RegisterSharedMemoryInner(&context, &sharedMem);
160 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
161
162 char buffer[4] = { 0 };
163 sharedMem.buffer = buffer;
164 sharedMem.flags = 0xffffffff;
165 ret = TEEC_RegisterSharedMemoryInner(&context, &sharedMem);
166 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
167 }
168
169 HWTEST_F(TeecVendorTest, TEEC_RegisterSharedMemoryTest_001, TestSize.Level1)
170 {
171 TEEC_Context context = { 0 };
172 TEEC_SharedMemory sharedMem = { 0 };
173
174 TEEC_Result ret = TEEC_RegisterSharedMemory(nullptr, &sharedMem);
175 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
176
177 ret = TEEC_RegisterSharedMemory(&context, nullptr);
178 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
179
180 ret = TEEC_InitializeContext(nullptr, &context);
181 EXPECT_TRUE(ret == TEEC_SUCCESS);
182
183 char buf[4] = { 0 };
184 sharedMem.buffer = buf;
185 sharedMem.size = 4;
186 sharedMem.flags = TEEC_MEM_INPUT;
187 ret = TEEC_RegisterSharedMemory(&context, &sharedMem);
188 EXPECT_TRUE(ret == TEEC_SUCCESS);
189 }
190
191 HWTEST_F(TeecVendorTest, TEEC_AllocateSharedMemoryTest_001, TestSize.Level1)
192 {
193 TEEC_Context context = { 0 };
194 TEEC_SharedMemory sharedMem = { 0 };
195
196 PutBnShrMem(nullptr);
197
198 TEEC_Result result = TEEC_AllocateSharedMemory(nullptr, &sharedMem);
199 EXPECT_TRUE(result == TEEC_ERROR_BAD_PARAMETERS);
200
201 result = TEEC_RegisterSharedMemory(&context, nullptr);
202 EXPECT_TRUE(result == TEEC_ERROR_BAD_PARAMETERS);
203
204 result = TEEC_InitializeContext(nullptr, &context);
205 EXPECT_TRUE(result == TEEC_SUCCESS);
206 sharedMem.size = 4;
207 sharedMem.flags = TEEC_MEM_INPUT;
208 result = TEEC_AllocateSharedMemory(&context, &sharedMem);
209 EXPECT_TRUE(result == TEEC_SUCCESS);
210
211 TEEC_ReleaseSharedMemory(&sharedMem);
212 }
213
214 HWTEST_F(TeecVendorTest, TEEC_CheckTmpRefTest_001, TestSize.Level1)
215 {
216 TEEC_ContextInner context = { 0 };
217 TEEC_Operation operation = { 0 };
218 operation.started = 1;
219
220 operation.paramTypes = TEEC_MEMREF_TEMP_INPUT;
221 operation.params[0].tmpref.buffer = nullptr;
222 operation.params[0].tmpref.size = 1;
223 TEEC_Result ret = TEEC_CheckOperation(&context, &operation);
224 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
225
226 operation.paramTypes = TEEC_MEMREF_TEMP_INPUT;
227 operation.params[0].tmpref.buffer = (void*)1;
228 operation.params[0].tmpref.size = 0;
229 ret = TEEC_CheckOperation(&context, &operation);
230 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
231 }
232
233 HWTEST_F(TeecVendorTest, TEEC_CheckMemRefTest_001, TestSize.Level1)
234 {
235 TEEC_ContextInner context = { 0 };
236 TEEC_Operation operation = { 0 };
237 operation.started = 1;
238 operation.paramTypes = TEEC_MEMREF_PARTIAL_INPUT;
239
240 operation.params[0].memref.parent = nullptr;
241 TEEC_Result ret = TEEC_CheckOperation(&context, &operation);
242 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
243
244 TEEC_SharedMemory sharedMem = { 0 };
245 operation.params[0].memref.parent = &sharedMem;
246 operation.params[0].memref.parent->buffer = nullptr;
247 ret = TEEC_CheckOperation(&context, &operation);
248 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
249
250 char buf[4] = { 0 };
251 operation.params[0].memref.parent->buffer = (void*)buf;
252 operation.params[0].memref.parent->size = 0;
253 ret = TEEC_CheckOperation(&context, &operation);
254 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
255
256 operation.params[0].memref.parent->size = 4;
257 operation.params[0].memref.parent->flags = 0;
258 ret = TEEC_CheckOperation(&context, &operation);
259 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
260
261 operation.paramTypes = TEEC_MEMREF_PARTIAL_OUTPUT;
262 operation.params[0].memref.parent->flags = 0;
263 ret = TEEC_CheckOperation(&context, &operation);
264 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
265
266 operation.paramTypes = TEEC_MEMREF_PARTIAL_INOUT;
267 operation.params[0].memref.parent->flags = 0;
268 ret = TEEC_CheckOperation(&context, &operation);
269 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
270
271 operation.paramTypes = TEEC_MEMREF_PARTIAL_INOUT;
272 operation.params[0].memref.parent->flags = TEEC_MEM_INPUT;
273 ret = TEEC_CheckOperation(&context, &operation);
274 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
275
276 operation.paramTypes = TEEC_MEMREF_WHOLE;
277 operation.params[0].memref.parent->flags = TEEC_MEM_INOUT;
278 operation.params[0].memref.parent->is_allocated = 0;
279 ret = TEEC_CheckOperation(&context, &operation);
280 EXPECT_TRUE(ret == TEEC_SUCCESS);
281 }
282
283 HWTEST_F(TeecVendorTest, TEEC_CheckMemRefTest_002, TestSize.Level1)
284 {
285 TEEC_ContextInner context = { 0 };
286 TEEC_Operation operation = { 0 };
287 operation.started = 1;
288
289 TEEC_SharedMemory sharedMem = { 0 };
290 operation.params[0].memref.parent = &sharedMem;
291
292 char buf[4] = { 0 };
293 operation.params[0].memref.parent->buffer = (void*)buf;
294 operation.params[0].memref.parent->size = 4;
295 operation.params[0].memref.offset = 1;
296 operation.params[0].memref.size = 4;
297
298 operation.paramTypes = TEEC_MEMREF_PARTIAL_INPUT;
299 operation.params[0].memref.parent->flags = TEEC_MEM_INPUT;
300 TEEC_Result ret = TEEC_CheckOperation(&context, &operation);
301 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
302
303 operation.paramTypes = TEEC_MEMREF_PARTIAL_OUTPUT;
304 operation.params[0].memref.parent->flags = TEEC_MEM_OUTPUT;
305 ret = TEEC_CheckOperation(&context, &operation);
306 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
307
308 operation.paramTypes = TEEC_MEMREF_PARTIAL_INOUT;
309 operation.params[0].memref.parent->flags = TEEC_MEM_INOUT;
310 ret = TEEC_CheckOperation(&context, &operation);
311 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
312 }
313
314 HWTEST_F(TeecVendorTest, CheckSharedBufferExistTest_002, TestSize.Level1)
315 {
316 TEEC_Operation operation = { 0 };
317 operation.started = 1;
318
319 TEEC_SharedMemory sharedMem = { 0 };
320 operation.params[0].memref.parent = &sharedMem;
321
322 char buf[4] = { 0 };
323 operation.params[0].memref.parent->buffer = (void*)buf;
324 operation.params[0].memref.parent->size = 4;
325 operation.params[0].memref.offset = 0;
326
327 operation.paramTypes = TEEC_MEMREF_WHOLE;
328 operation.params[0].memref.parent->is_allocated = 1;
329
330 TEEC_Result ret = TEEC_CheckOperation(nullptr, &operation);
331 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
332 }
333
334 HWTEST_F(TeecVendorTest, TEEC_CheckOperationTest_001, TestSize.Level1)
335 {
336 TEEC_ContextInner context = { 0 };
337 TEEC_Operation operation = { 0 };
338
339 TEEC_Result ret = TEEC_CheckOperation(&context, nullptr);
340 EXPECT_TRUE(ret == TEEC_SUCCESS);
341
342 operation.started = 0;
343 ret = TEEC_CheckOperation(&context, &operation);
344 EXPECT_TRUE(ret == TEEC_ERROR_NOT_IMPLEMENTED);
345
346 operation.started = 1;
347 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_ION_INPUT, TEEC_ION_INPUT, TEEC_ION_INPUT, TEEC_ION_INPUT);
348 operation.params[0].ionref.ion_share_fd = -1;
349 ret = TEEC_CheckOperation(&context, &operation);
350 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
351
352 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_ION_SGLIST_INPUT, TEEC_ION_INPUT, TEEC_ION_INPUT, TEEC_ION_INPUT);
353 operation.params[0].ionref.ion_share_fd = -1;
354 ret = TEEC_CheckOperation(&context, &operation);
355 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
356
357 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_ION_INPUT, TEEC_ION_INPUT, TEEC_ION_INPUT, TEEC_ION_INPUT);
358 operation.params[0].ionref.ion_share_fd = 0;
359 operation.params[0].ionref.ion_size = 0;
360 ret = TEEC_CheckOperation(&context, &operation);
361 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
362
363 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_ION_SGLIST_INPUT, TEEC_ION_INPUT, TEEC_ION_INPUT, TEEC_ION_INPUT);
364 operation.params[0].ionref.ion_share_fd = 0;
365 operation.params[0].ionref.ion_size = 0;
366 ret = TEEC_CheckOperation(&context, &operation);
367 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
368
369 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_VALUE_INPUT, TEEC_NONE, TEEC_MEMREF_SHARED_INOUT, TEEC_NONE);
370 ret = TEEC_CheckOperation(&context, &operation);
371 EXPECT_TRUE(ret == TEEC_SUCCESS);
372 }
373
374 HWTEST_F(TeecVendorTest, TEEC_RequestCancellationTest_001, TestSize.Level1)
375 {
376 TEEC_Operation operation = { 0 };
377
378 GetBnShmByOffset(0, nullptr);
379 TEEC_RequestCancellation(nullptr);
380
381 operation.session = nullptr;
382 TEEC_RequestCancellation(&operation);
383
384 TEEC_Session session = { 0 };
385 operation.session = &session;
386 session.context = nullptr;
387 TEEC_RequestCancellation(&operation);
388
389 TEEC_Context context = { 0 };
390 TEEC_Result result = TEEC_InitializeContext(nullptr, &context);
391 operation.started = 1;
392 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_NONE, TEEC_NONE, TEEC_NONE);
393 TEEC_UUID uuid = { 0xabe89147, 0xcd61, 0xf43f, { 0x71, 0xc4, 0x1a, 0x31, 0x7e, 0x40, 0x53, 0x12 } };
394 result = TEEC_OpenSession(&context, &session, &uuid, TEEC_LOGIN_IDENTIFY, nullptr, &operation, nullptr);
395 EXPECT_TRUE(result == TEEC_ERROR_GENERIC);
396
397 TEEC_RequestCancellation(&operation);
398 }
399
400 HWTEST_F(TeecVendorTest, TEEC_EXT_RegisterAgentTest_001, TestSize.Level1)
401 {
402 int devFd = 0;
403 char *buf = nullptr;
404
405 TEEC_Result ret = TEEC_EXT_RegisterAgent(0, nullptr, (void **)nullptr);
406 EXPECT_TRUE(ret == TEEC_ERROR_GENERIC);
407
408 ret = TEEC_EXT_RegisterAgent(0, &devFd, (void **)nullptr);
409 EXPECT_TRUE(ret == TEEC_ERROR_GENERIC);
410
411 ret = TEEC_EXT_RegisterAgent(0, &devFd, (void **)&buf);
412 EXPECT_TRUE(ret == TEEC_ERROR_GENERIC);
413 }
414
415 HWTEST_F(TeecVendorTest, TEEC_EXT_WaitEventTest_001, TestSize.Level1)
416 {
417 TEEC_Result ret = TEEC_EXT_WaitEvent(0, 0);
418 EXPECT_TRUE(ret == TEEC_ERROR_GENERIC);
419 }
420
421 HWTEST_F(TeecVendorTest, TEEC_EXT_SendEventResponseTest_001, TestSize.Level1)
422 {
423 TEEC_Result ret = TEEC_EXT_SendEventResponse(0, 0);
424 EXPECT_TRUE(ret == TEEC_ERROR_GENERIC);
425 }
426
427 HWTEST_F(TeecVendorTest, TEEC_EXT_UnregisterAgentTest_001, TestSize.Level1)
428 {
429 char *buf = nullptr;
430
431 TEEC_Result ret = TEEC_EXT_UnregisterAgent(0, 0, nullptr);
432 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
433
434 ret = TEEC_EXT_UnregisterAgent(0, 0, (void**)&buf);
435 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
436
437 char buf2[4] = { 0 };
438 ret = TEEC_EXT_UnregisterAgent(0, -1, (void **)&buf2);
439 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
440 }
441
442 HWTEST_F(TeecVendorTest, TEEC_SendSecfileTest_001, TestSize.Level1)
443 {
444 TEEC_Result ret = TEEC_SendSecfile(nullptr, nullptr);
445 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
446
447 char path[] = "/data/app/el2/100/base/com.huawei.hmos.skytone/files/abe89147-cd61-f43f-71c4-1a317e405312.sec";
448 ret = TEEC_SendSecfile(path, nullptr);
449 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
450
451 TEEC_Session session = { 0 };
452 session.context = nullptr;
453 ret = TEEC_SendSecfile(path, &session);
454 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
455
456 TEEC_UUID uuid = { 0xabe89147, 0xcd61, 0xf43f, { 0x71, 0xc4, 0x1a, 0x31, 0x7e, 0x40, 0x53, 0x12 } };
457 TEEC_Context context = { 0 };
458 ret = TEEC_InitializeContext(nullptr, &context);
459 EXPECT_TRUE(ret == TEEC_SUCCESS);
460 TEEC_Operation operation = { 0 };
461 operation.started = 1;
462 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_NONE, TEEC_NONE, TEEC_NONE);
463 ret = TEEC_OpenSession(&context, &session, &uuid, TEEC_LOGIN_IDENTIFY, nullptr, &operation, nullptr);
464 EXPECT_TRUE(ret == TEEC_ERROR_GENERIC);
465 ret = TEEC_SendSecfile(path, &session);
466 EXPECT_TRUE(ret != TEEC_ERROR_BAD_PARAMETERS);
467 }
468
469 HWTEST_F(TeecVendorTest, TEEC_SendSecfileInnerTest_001, TestSize.Level1)
470 {
471 TEEC_Result result = TEEC_SendSecfileInner(nullptr, 0, nullptr);
472 EXPECT_TRUE(result == TEEC_ERROR_BAD_PARAMETERS);
473
474 char path[] = "/data/app/el2/100/base/com.huawei.hmos.skytone/files/abe89147-cd61-f43f-71c4-1a317e405312.sec";
475 result = TEEC_SendSecfileInner(path, 0, nullptr);
476 EXPECT_TRUE(result == 13);
477 }
478
479 HWTEST_F(TeecVendorTest, TEEC_OpenSessionTest_001, TestSize.Level1)
480 {
481 TEEC_Context context = { 0 };
482 TEEC_Session session = { 0 };
483 TEEC_UUID uuid = { 0x95b9ad1e, 0x0af8, 0x4201, { 0x98, 0x91, 0x0d, 0xbe, 0x86, 0x02, 0xf3, 0x5f }};
484
485 TEEC_Result ret = TEEC_OpenSession(nullptr, nullptr, nullptr, TEEC_LOGIN_IDENTIFY, nullptr, nullptr, nullptr);
486 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
487
488 ret = TEEC_OpenSession(&context, nullptr, nullptr, TEEC_LOGIN_IDENTIFY, nullptr, nullptr, nullptr);
489 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
490
491 ret = TEEC_OpenSession(&context, &session, nullptr, TEEC_LOGIN_IDENTIFY, nullptr, nullptr, nullptr);
492 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
493
494 ret = TEEC_OpenSession(&context, &session, &uuid, TEEC_LOGIN_IDENTIFY, nullptr, nullptr, nullptr);
495 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
496 }
497
498 HWTEST_F(TeecVendorTest, TEEC_OpenSessionInnerTest_001, TestSize.Level1)
499 {
500 int callingPid = 0;
501 TaFileInfo taFile;
502 taFile.taFp = nullptr;
503 char path[] = "/vendor/bin/95b9ad1e-0af8-4201-9891-0dbe8602f35f.sec";
504 taFile.taPath = (uint8_t*)path;
505
506 TEEC_ContextInner contextInner = { 0 };
507 TEEC_Session session = { 0 };
508 TEEC_UUID destination = { 0x95b9ad1e, 0x0af8, 0x4201, { 0x98, 0x91, 0x0d, 0xbe, 0x86, 0x02, 0xf3, 0x5f }};
509 TEEC_Operation operation = { 0 };
510 uint32_t retOrigin = 0;
511
512 TEEC_Result ret = TEEC_OpenSessionInner(callingPid, &taFile, nullptr, &session, &destination,
513 TEEC_LOGIN_IDENTIFY, nullptr, &operation, &retOrigin);
514 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
515
516 ret = TEEC_OpenSessionInner(callingPid, nullptr, &contextInner, &session, &destination,
517 TEEC_LOGIN_IDENTIFY, nullptr, &operation, &retOrigin);
518 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
519
520 ret = TEEC_OpenSessionInner(callingPid, &taFile, &contextInner, nullptr, &destination,
521 TEEC_LOGIN_IDENTIFY, nullptr, &operation, &retOrigin);
522 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
523
524 ret = TEEC_OpenSessionInner(callingPid, &taFile, &contextInner, &session, nullptr,
525 TEEC_LOGIN_IDENTIFY, nullptr, &operation, &retOrigin);
526 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
527
528 ret = TEEC_OpenSessionInner(callingPid, &taFile, &contextInner, &session, &destination,
529 ~TEEC_LOGIN_IDENTIFY, nullptr, &operation, &retOrigin);
530 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
531
532 ret = TEEC_OpenSessionInner(callingPid, &taFile, &contextInner, &session, &destination,
533 TEEC_LOGIN_IDENTIFY, (void*)&callingPid, &operation, &retOrigin);
534 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
535
536 operation.started = 0;
537 ret = TEEC_OpenSessionInner(callingPid, &taFile, &contextInner, &session, &destination,
538 TEEC_LOGIN_IDENTIFY, nullptr, nullptr, &retOrigin);
539 EXPECT_TRUE(ret == TEEC_ERROR_GENERIC);
540
541 operation.started = 0;
542 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_NONE, TEEC_NONE, TEEC_NONE);
543 ret = TEEC_OpenSessionInner(callingPid, &taFile, &contextInner, &session, &destination,
544 TEEC_LOGIN_IDENTIFY, nullptr, &operation, &retOrigin);
545 EXPECT_TRUE(ret == TEEC_ERROR_NOT_IMPLEMENTED);
546 }
547
548 HWTEST_F(TeecVendorTest, TEEC_OpenSessionInnerTest_002, TestSize.Level1)
549 {
550 int callingPid = 0;
551 uint32_t retOrigin = 0;
552 TaFileInfo taFile;
553 taFile.taFp = nullptr;
554 char path[] = "/vendor/bin/95b9ad1e-0af8-4201-9891-0dbe8602f35f";
555 taFile.taPath = (uint8_t *)path;
556
557 TEEC_ContextInner contextInner = { 0 };
558 TEEC_Session session = { 0 };
559 TEEC_UUID destination = { 0x95b9ad1e, 0x0af8, 0x4201, { 0x98, 0x91, 0x0d, 0xbe, 0x86, 0x02, 0xf3, 0x5f }};
560
561 TEEC_Result ret = TEEC_OpenSessionInner(callingPid, &taFile, &contextInner, &session, &destination,
562 TEEC_LOGIN_IDENTIFY, nullptr, nullptr, &retOrigin);
563 EXPECT_TRUE(ret == TEEC_ERROR_GENERIC);
564 }
565
566 HWTEST_F(TeecVendorTest, TEEC_EncodeParamTest_001, TestSize.Level1)
567 {
568 int callingPid = 0;
569 uint32_t retOrigin = 0;
570 TaFileInfo taFile;
571 taFile.taFp = nullptr;
572 char path[] = "/vendor/bin/95b9ad1e-0af8-4201-9891-0dbe8602f35f.sec";
573 taFile.taPath = (uint8_t *)path;
574
575 TEEC_ContextInner contextInner = { 0 };
576 TEEC_Session session = { 0 };
577 TEEC_UUID destination = { 0x95b9ad1e, 0x0af8, 0x4201, { 0x98, 0x91, 0x0d, 0xbe, 0x86, 0x02, 0xf3, 0x5f }};
578 TEEC_Operation operation = { 0 };
579 operation.started = 1;
580 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INPUT, TEEC_NONE, TEEC_NONE, TEEC_NONE);
581 char buf[4] = { 0 };
582 operation.params[0].tmpref.buffer = (void*)buf;
583 operation.params[0].tmpref.size = 4;
584 TEEC_Result ret = TEEC_OpenSessionInner(callingPid, &taFile, &contextInner, &session, &destination,
585 TEEC_LOGIN_IDENTIFY, nullptr, &operation, &retOrigin);
586 EXPECT_TRUE(ret == TEEC_ERROR_GENERIC);
587 }
588
589 HWTEST_F(TeecVendorTest, TEEC_EncodePartialParamTest_001, TestSize.Level1)
590 {
591 int callingPid = 0;
592 uint32_t retOrigin = 0;
593 TaFileInfo taFile;
594 taFile.taFp = nullptr;
595 char path[] = "/vendor/bin/95b9ad1e-0af8-4201-9891-0dbe8602f35f.sec";
596 taFile.taPath = (uint8_t *)path;
597
598 char buf[4] = { 0 };
599 TEEC_ContextInner contextInner = { 0 };
600 TEEC_Session session = { 0 };
601 TEEC_UUID destination = { 0x95b9ad1e, 0x0af8, 0x4201, { 0x98, 0x91, 0x0d, 0xbe, 0x86, 0x02, 0xf3, 0x5f }};
602 TEEC_Operation operation = { 0 };
603 operation.started = 1;
604 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_INPUT, TEEC_MEMREF_SHARED_INOUT, TEEC_NONE, TEEC_NONE);
605 TEEC_SharedMemory sharedMem0 = { 0 }, sharedMem1 = { 0 };
606 operation.params[0].memref.parent = &sharedMem0;
607 operation.params[0].memref.parent->is_allocated = 0;
608 operation.params[0].memref.parent->buffer = (void*)buf;
609 operation.params[0].memref.parent->size = 4;
610 operation.params[0].memref.size = 4;
611 operation.params[0].memref.offset = 0;
612 operation.params[1].memref.parent = &sharedMem1;
613 operation.params[1].memref.parent->is_allocated = 1;
614 operation.params[1].memref.parent->buffer = (void*)buf;
615 operation.params[1].memref.parent->size = 4;
616 operation.params[1].memref.size = 4;
617 operation.params[1].memref.offset = 0;
618 TEEC_Result ret = TEEC_OpenSessionInner(callingPid, &taFile, &contextInner, &session, &destination,
619 TEEC_LOGIN_IDENTIFY, nullptr, &operation, &retOrigin);
620 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
621 }
622
623 HWTEST_F(TeecVendorTest, TranslateParamTypeTest_001, TestSize.Level1)
624 {
625 int callingPid = 0;
626 uint32_t retOrigin = 0;
627 TaFileInfo taFile;
628 taFile.taFp = nullptr;
629 char path[] = "/vendor/bin/95b9ad1e-0af8-4201-9891-0dbe8602f35f.sec";
630 taFile.taPath = (uint8_t*)path;
631
632 char buf[4] = { 0 };
633 TEEC_ContextInner contextInner = { 0 };
634 TEEC_Session session = { 0 };
635 TEEC_UUID destination = { 0x95b9ad1e, 0x0af8, 0x4201, { 0x98, 0x91, 0x0d, 0xbe, 0x86, 0x02, 0xf3, 0x5f }};
636 TEEC_Operation operation = { 0 };
637 operation.started = 1;
638 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_WHOLE, TEEC_MEMREF_WHOLE, TEEC_NONE, TEEC_NONE);
639 TEEC_SharedMemory sharedMem = { 0 };
640 operation.params[0].memref.parent = &sharedMem;
641 operation.params[0].memref.parent->is_allocated = 0;
642 operation.params[0].memref.parent->flags = TEEC_MEM_INPUT;
643 operation.params[0].memref.parent->buffer = (void*)buf;
644 operation.params[0].memref.parent->size = 4;
645 operation.params[0].memref.size = 4;
646 operation.params[0].memref.offset = 0;
647 operation.params[1].memref.parent = &sharedMem;
648 operation.params[1].memref.parent->is_allocated = 0;
649 operation.params[1].memref.parent->flags = TEEC_MEM_OUTPUT;
650 operation.params[1].memref.parent->buffer = (void*)buf;
651 operation.params[1].memref.parent->size = 4;
652 operation.params[1].memref.size = 4;
653 operation.params[1].memref.offset = 0;
654
655 TEEC_Result ret = TEEC_OpenSessionInner(callingPid, &taFile, &contextInner, &session, &destination,
656 TEEC_LOGIN_IDENTIFY, nullptr, &operation, &retOrigin);
657 EXPECT_TRUE(ret == TEEC_ERROR_GENERIC);
658
659 operation.params[0].memref.parent->flags = TEEC_MEM_INOUT;
660 operation.params[1].memref.parent->flags = 0xffffffff;
661 ret = TEEC_OpenSessionInner(callingPid, &taFile, &contextInner, &session, &destination,
662 TEEC_LOGIN_IDENTIFY, nullptr, &operation, &retOrigin);
663 EXPECT_TRUE(ret == TEEC_ERROR_GENERIC);
664 }
665
666 HWTEST_F(TeecVendorTest, TEEC_EncodeIonParam_001, TestSize.Level1)
667 {
668 int callingPid = 0;
669 uint32_t retOrigin = 0;
670 TaFileInfo taFile;
671 taFile.taFp = nullptr;
672 char path[] = "/vendor/bin/95b9ad1e-0af8-4201-9891-0dbe8602f35f.sec";
673 taFile.taPath = (uint8_t*)path;
674
675 TEEC_ContextInner contextInner = { 0 };
676 TEEC_Session session = { 0 };
677 TEEC_UUID destination = { 0x95b9ad1e, 0x0af8, 0x4201, { 0x98, 0x91, 0x0d, 0xbe, 0x86, 0x02, 0xf3, 0x5f }};
678 TEEC_Operation operation = { 0 };
679 operation.started = 1;
680 operation.paramTypes = TEEC_PARAM_TYPES(TEEC_ION_INPUT, TEEC_ION_SGLIST_INPUT, TEEC_NONE, TEEC_NONE);
681 operation.params[0].ionref.ion_share_fd = 0;
682 operation.params[0].ionref.ion_size = 1;
683 operation.params[1].ionref.ion_share_fd = 0;
684 operation.params[1].ionref.ion_size = 1;
685
686 TEEC_Result ret = TEEC_OpenSessionInner(callingPid, &taFile, &contextInner, &session, &destination,
687 TEEC_LOGIN_IDENTIFY, nullptr, &operation, &retOrigin);
688 EXPECT_TRUE(ret == TEEC_ERROR_GENERIC);
689 }
690
691
692 HWTEST_F(TeecVendorTest, TEEC_CloseSessionInnerTest_001, TestSize.Level1)
693 {
694 TEEC_Session session = { 0 };
695 TEEC_ContextInner contextInner = { 0 };
696
697
698 (void)TEEC_CloseSessionInner(nullptr, nullptr);
699 (void)TEEC_CloseSessionInner(&session, nullptr);
700
701 TEEC_Context context = { 0 };
702 TEEC_Result result = TEEC_InitializeContext(nullptr, &context);
703 EXPECT_TRUE(result == TEEC_SUCCESS);
704 (void)TEEC_CloseSessionInner(&session, &contextInner);
705 }
706
707 HWTEST_F(TeecVendorTest, TEEC_ReleaseSharedMemoryTest_001, TestSize.Level1)
708 {
709 TEEC_Context context = { 0 };
710 TEEC_SharedMemory sharedMem = { 0 };
711 TEEC_SharedMemoryInner sharedMemInner = { 0 };
712
713 TEEC_ReleaseSharedMemoryInner(nullptr);
714 sharedMemInner.context = nullptr;
715 TEEC_ReleaseSharedMemoryInner(&sharedMemInner);
716
717 sharedMem.context = nullptr;
718 TEEC_Result ret = TEEC_InitializeContext(nullptr, &context);
719 EXPECT_TRUE(ret == TEEC_SUCCESS);
720
721 char buf[4] = { 0 };
722 sharedMem.buffer = buf;
723 sharedMem.size = 4;
724 sharedMem.flags = TEEC_MEM_INPUT;
725 ret = TEEC_RegisterSharedMemory(&context, &sharedMem);
726 EXPECT_TRUE(ret == TEEC_SUCCESS);
727
728 TEEC_ReleaseSharedMemory(&sharedMem);
729 }
730
731 HWTEST_F(TeecVendorTest, TEEC_InvokeCommandTest_001, TestSize.Level1)
732 {
733 TEEC_Session session = { 0 };
734 TEEC_Operation operation = { 0 };
735 uint32_t returnOrigin = 0;
736
737 TEEC_Result ret = TEEC_InvokeCommand(nullptr, 0, &operation, &returnOrigin);
738 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
739
740 session.context = nullptr;
741 ret = TEEC_InvokeCommand(&session, 0, nullptr, &returnOrigin);
742 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
743
744 TEEC_Context context = { 0 };
745 TEEC_ContextInner contextInner = { 0 };
746
747 GetBnSession(nullptr, &contextInner);
748 GetBnSession(&session, nullptr);
749
750 ret = TEEC_InitializeContext(nullptr, &context);
751 EXPECT_TRUE(ret == TEEC_SUCCESS);
752 TEEC_UUID uuid = { 0xabe89147, 0xcd61, 0xf43f, { 0x71, 0xc4, 0x1a, 0x31, 0x7e, 0x40, 0x53, 0x12 } };
753 ret = TEEC_OpenSession(&context, &session, &uuid, TEEC_LOGIN_IDENTIFY, nullptr, nullptr, nullptr);
754 EXPECT_TRUE(ret != TEEC_SUCCESS);
755
756 session.context = &context;
757 ret = TEEC_InvokeCommand(&session, 0, nullptr, &returnOrigin);
758 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
759 TEEC_CloseSession(&session);
760 PutBnSession(nullptr);
761 TEEC_FinalizeContext(&context);
762 }
763
764 HWTEST_F(TeecVendorTest, TEEC_InvokeCommandInnerTest_001, TestSize.Level1)
765 {
766 TEEC_ContextInner context = { 0 };
767 TEEC_Session session = { 0 };
768 TEEC_Operation operation = { 0 };
769
770 TEEC_CloseSession(nullptr);
771 session.context = nullptr;
772 TEEC_CloseSession(&session);
773
774 TEEC_Result ret = TEEC_InvokeCommandInner(nullptr, &session, 0, nullptr, nullptr);
775 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
776
777 ret = TEEC_InvokeCommandInner(&context, nullptr, 0, nullptr, nullptr);
778 EXPECT_TRUE(ret == TEEC_ERROR_BAD_PARAMETERS);
779
780 operation.started = 0;
781 ret = TEEC_InvokeCommandInner(&context, &session, 0, &operation, nullptr);
782 EXPECT_TRUE(ret == TEEC_ERROR_NOT_IMPLEMENTED);
783 }
784 }
785