• 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 #include <public_test.h>
15 #include <test_log.h>
16 #include <securec.h>
17 #include <common_test.h>
18 #include <tee_client_api.h>
19 #include <tee_client_type.h>
20 #include <session_mgr/client_session_mgr.h>
21 
22 using namespace testing::ext;
23 /**
24  * @testcase.name      : BigInt_ComputeFMM
25  * @testcase.desc      : test TEE_BigIntComputeFMM api
26  * @testcase.expect    : return TEEC_SUCCESS
27  */
28 TEE_TEST(TeeBasicTestFram, BigInt_ComputeFMM, Function | MediumTest | Level0)
29 {
30     ClientSessionMgr sess;
31     uint32_t origin;
32     TEEC_UUID testId = ARITHMETIC_API_UUID;
33     TEEC_Result ret = sess.Start(&testId);
34     ASSERT_EQ(ret, TEEC_SUCCESS);
35 
36     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_BIG_INT_COMPUTE_FMM, NULL, &origin);
37     ASSERT_EQ(ret, TEEC_SUCCESS);
38     sess.Destroy();
39 }
40 
41 /**
42  * @testcase.name      : BigInt_InitFMMContext
43  * @testcase.desc      : test initialize context for FMM
44  * @testcase.expect    : return TEEC_SUCCESS
45  */
46 TEE_TEST(TeeBasicTestFram, BigInt_InitFMMContext, Function | MediumTest | Level0)
47 {
48     ClientSessionMgr sess;
49     uint32_t origin;
50     TEEC_UUID testId = ARITHMETIC_API_UUID;
51     TEEC_Result ret = sess.Start(&testId);
52     ASSERT_EQ(ret, TEEC_SUCCESS);
53 
54     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_BIG_INT_INIT_FMM_CONTEXT, NULL, &origin);
55     ASSERT_EQ(ret, TEEC_SUCCESS);
56     sess.Destroy();
57 }
58 
59 /**
60  * @testcase.name      : BigInt_ConverterBetweenBigIntAndFMM
61  * @testcase.desc      : test converter between big int and FMM
62  * @testcase.expect    : return TEEC_SUCCESS
63  */
64 TEE_TEST(TeeBasicTestFram, BigInt_ConverterBetweenBigIntAndFMM, Function | MediumTest | Level0)
65 {
66     ClientSessionMgr sess;
67     uint32_t origin;
68     TEEC_UUID testId = ARITHMETIC_API_UUID;
69     TEEC_Result ret = sess.Start(&testId);
70     ASSERT_EQ(ret, TEEC_SUCCESS);
71 
72     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_CONVERTER_BETWEEN_BIG_INT_AND_FMM, NULL, &origin);
73     ASSERT_EQ(ret, TEEC_SUCCESS);
74     sess.Destroy();
75 }
76 
77 /**
78  * @testcase.name      : BigInt_ComputeExpMod
79  * @testcase.desc      : test TEE_BigIntExpMod api
80  * @testcase.expect    : return TEEC_SUCCESS
81  */
82 TEE_TEST(TeeBasicTestFram, BigInt_ComputeExpMod, Function | MediumTest | Level0)
83 {
84     ClientSessionMgr sess;
85     uint32_t origin;
86     TEEC_UUID testId = ARITHMETIC_API_UUID;
87     TEEC_Result ret = sess.Start(&testId);
88     ASSERT_EQ(ret, TEEC_SUCCESS);
89 
90     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_BIG_INT_EXP_MOD, NULL, &origin);
91     ASSERT_EQ(ret, TEEC_SUCCESS);
92     sess.Destroy();
93 }
94 
95 /**
96  * @testcase.name      : BigInt_ConverterBetweenBigIntAndOctetString
97  * @testcase.desc      : test converter between big int and octet string
98  * @testcase.expect    : return TEEC_SUCCESS
99  */
100 TEE_TEST(TeeBasicTestFram, BigInt_ConverterBetweenBigIntAndOctetString, Function | MediumTest | Level0)
101 {
102     ClientSessionMgr sess;
103     uint32_t origin;
104     TEEC_UUID testId = ARITHMETIC_API_UUID;
105     TEEC_Result ret = sess.Start(&testId);
106     ASSERT_EQ(ret, TEEC_SUCCESS);
107 
108     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_CONVERTER_BETWEEN_BIG_INT_AND_OCTET_STRING, NULL, &origin);
109     ASSERT_EQ(ret, TEEC_SUCCESS);
110     sess.Destroy();
111 }
112 
113 /**
114  * @testcase.name      : BigInt_ComputeExpMod
115  * @testcase.desc      : test converter between big int and shortVal
116  * @testcase.expect    : return TEEC_SUCCESS
117  */
118 TEE_TEST(TeeBasicTestFram, BigInt_ConverterBetweenBigIntAndShortVal, Function | MediumTest | Level0)
119 {
120     ClientSessionMgr sess;
121     uint32_t origin;
122     TEEC_UUID testId = ARITHMETIC_API_UUID;
123     TEEC_Result ret = sess.Start(&testId);
124     ASSERT_EQ(ret, TEEC_SUCCESS);
125 
126     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_CONVERTER_BETWEEN_BIG_INT_AND_S32, NULL, &origin);
127     ASSERT_EQ(ret, TEEC_SUCCESS);
128     sess.Destroy();
129 }
130 
131 /**
132  * @testcase.name      : BigInt_AddAndSubMod
133  * @testcase.desc      : test compute add and sub mod
134  * @testcase.expect    : return TEEC_SUCCESS
135  */
136 TEE_TEST(TeeBasicTestFram, BigInt_AddAndSubMod, Function | MediumTest | Level0)
137 {
138     ClientSessionMgr sess;
139     uint32_t origin;
140     TEEC_UUID testId = ARITHMETIC_API_UUID;
141     TEEC_Result ret = sess.Start(&testId);
142     ASSERT_EQ(ret, TEEC_SUCCESS);
143 
144     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_BIG_INT_ADD_AND_SUB_MOD, NULL, &origin);
145     ASSERT_EQ(ret, TEEC_SUCCESS);
146     sess.Destroy();
147 }
148 
149 /**
150  * @testcase.name      : BigInt_MulAndInvMod
151  * @testcase.desc      : test compute mul, square and inv mod
152  * @testcase.expect    : return TEEC_SUCCESS
153  */
154 TEE_TEST(TeeBasicTestFram, BigInt_MulAndInvMod, Function | MediumTest | Level0)
155 {
156     ClientSessionMgr sess;
157     uint32_t origin;
158     TEEC_UUID testId = ARITHMETIC_API_UUID;
159     TEEC_Result ret = sess.Start(&testId);
160     ASSERT_EQ(ret, TEEC_SUCCESS);
161 
162     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_BIG_INT_MUL_AND_INV_MOD, NULL, &origin);
163     ASSERT_EQ(ret, TEEC_SUCCESS);
164     sess.Destroy();
165 }
166 
167 /**
168  * @testcase.name      : BigInt_InitMod
169  * @testcase.desc      : test TEE_BigIntMod api
170  * @testcase.expect    : return TEEC_SUCCESS
171  */
172 TEE_TEST(TeeBasicTestFram, BigInt_InitMod, Function | MediumTest | Level0)
173 {
174     ClientSessionMgr sess;
175     uint32_t origin;
176     TEEC_UUID testId = ARITHMETIC_API_UUID;
177     TEEC_Result ret = sess.Start(&testId);
178     ASSERT_EQ(ret, TEEC_SUCCESS);
179 
180     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_BIG_INT_MOD, NULL, &origin);
181     ASSERT_EQ(ret, TEEC_SUCCESS);
182     sess.Destroy();
183 }
184 
185 /**
186  * @testcase.name      : BigInt_AddAndSub
187  * @testcase.desc      : test add and sub
188  * @testcase.expect    : return TEEC_SUCCESS
189  */
190 TEE_TEST(TeeBasicTestFram, BigInt_AddAndSub, Function | MediumTest | Level0)
191 {
192     ClientSessionMgr sess;
193     uint32_t origin;
194     TEEC_UUID testId = ARITHMETIC_API_UUID;
195     TEEC_Result ret = sess.Start(&testId);
196     ASSERT_EQ(ret, TEEC_SUCCESS);
197 
198     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_BIG_INT_ADD_AND_SUB, NULL, &origin);
199     ASSERT_EQ(ret, TEEC_SUCCESS);
200     sess.Destroy();
201 }
202 
203 /**
204  * @testcase.name      : BigInt_Neg
205  * @testcase.desc      : test negate
206  * @testcase.expect    : return TEEC_SUCCESS
207  */
208 TEE_TEST(TeeBasicTestFram, BigInt_Neg, Function | MediumTest | Level0)
209 {
210     ClientSessionMgr sess;
211     uint32_t origin;
212     TEEC_UUID testId = ARITHMETIC_API_UUID;
213     TEEC_Result ret = sess.Start(&testId);
214     ASSERT_EQ(ret, TEEC_SUCCESS);
215 
216     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_BIG_INT_NEG, NULL, &origin);
217     ASSERT_EQ(ret, TEEC_SUCCESS);
218     sess.Destroy();
219 }
220 
221 /**
222  * @testcase.name      : BigInt_MulAndSquare
223  * @testcase.desc      : test mul and square
224  * @testcase.expect    : return TEEC_SUCCESS
225  */
226 TEE_TEST(TeeBasicTestFram, BigInt_MulAndSquare, Function | MediumTest | Level0)
227 {
228     ClientSessionMgr sess;
229     uint32_t origin;
230     TEEC_UUID testId = ARITHMETIC_API_UUID;
231     TEEC_Result ret = sess.Start(&testId);
232     ASSERT_EQ(ret, TEEC_SUCCESS);
233 
234     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_BIG_INT_MUL_AND_SQUARE, NULL, &origin);
235     ASSERT_EQ(ret, TEEC_SUCCESS);
236     sess.Destroy();
237 }
238 
239 /**
240  * @testcase.name      : BigInt_div
241  * @testcase.desc      : test div
242  * @testcase.expect    : return TEEC_SUCCESS
243  */
244 TEE_TEST(TeeBasicTestFram, BigInt_div, Function | MediumTest | Level0)
245 {
246     ClientSessionMgr sess;
247     uint32_t origin;
248     TEEC_UUID testId = ARITHMETIC_API_UUID;
249     TEEC_Result ret = sess.Start(&testId);
250     ASSERT_EQ(ret, TEEC_SUCCESS);
251 
252     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_BIG_INT_DIV, NULL, &origin);
253     ASSERT_EQ(ret, TEEC_SUCCESS);
254     sess.Destroy();
255 }
256 
257 /**
258  * @testcase.name      : BigInt_ShiftRight
259  * @testcase.desc      : test shift right
260  * @testcase.expect    : return TEEC_SUCCESS
261  */
262 TEE_TEST(TeeBasicTestFram, BigInt_ShiftRight, Function | MediumTest | Level0)
263 {
264     ClientSessionMgr sess;
265     uint32_t origin;
266     TEEC_UUID testId = ARITHMETIC_API_UUID;
267     TEEC_Result ret = sess.Start(&testId);
268     ASSERT_EQ(ret, TEEC_SUCCESS);
269 
270     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_BIG_INT_SHIFT_RIGHT, NULL, &origin);
271     ASSERT_EQ(ret, TEEC_SUCCESS);
272     sess.Destroy();
273 }
274 
275 /**
276  * @testcase.name      : BigInt_GetBit
277  * @testcase.desc      : test get bit
278  * @testcase.expect    : return TEEC_SUCCESS
279  */
280 TEE_TEST(TeeBasicTestFram, BigInt_GetBit, Function | MediumTest | Level0)
281 {
282     ClientSessionMgr sess;
283     uint32_t origin;
284     TEEC_UUID testId = ARITHMETIC_API_UUID;
285     TEEC_Result ret = sess.Start(&testId);
286     ASSERT_EQ(ret, TEEC_SUCCESS);
287 
288     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_BIG_INT_GET_BIT, NULL, &origin);
289     ASSERT_EQ(ret, TEEC_SUCCESS);
290     sess.Destroy();
291 }
292 
293 /**
294  * @testcase.name      : BigInt_GetBitCount
295  * @testcase.desc      : test get bit counts
296  * @testcase.expect    : return TEEC_SUCCESS
297  */
298 TEE_TEST(TeeBasicTestFram, BigInt_GetBitCount, Function | MediumTest | Level0)
299 {
300     ClientSessionMgr sess;
301     uint32_t origin;
302     TEEC_UUID testId = ARITHMETIC_API_UUID;
303     TEEC_Result ret = sess.Start(&testId);
304     ASSERT_EQ(ret, TEEC_SUCCESS);
305 
306     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_BIG_INT_GET_BIT_COUNT, NULL, &origin);
307     ASSERT_EQ(ret, TEEC_SUCCESS);
308     sess.Destroy();
309 }
310 
311 /**
312  * @testcase.name      : BigInt_SetBit
313  * @testcase.desc      : test set bit
314  * @testcase.expect    : return TEEC_SUCCESS
315  */
316 TEE_TEST(TeeBasicTestFram, BigInt_SetBit, Function | MediumTest | Level0)
317 {
318     ClientSessionMgr sess;
319     uint32_t origin;
320     TEEC_UUID testId = ARITHMETIC_API_UUID;
321     TEEC_Result ret = sess.Start(&testId);
322     ASSERT_EQ(ret, TEEC_SUCCESS);
323 
324     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_BIG_INT_SET_BIT, NULL, &origin);
325     ASSERT_EQ(ret, TEEC_SUCCESS);
326     sess.Destroy();
327 }
328 
329 /**
330  * @testcase.name      : BigInt_AssignSrcToDest
331  * @testcase.desc      : test TEE_BigIntAssign api
332  * @testcase.expect    : return TEEC_SUCCESS
333  */
334 TEE_TEST(TeeBasicTestFram, BigInt_AssignSrcToDest, Function | MediumTest | Level0)
335 {
336     ClientSessionMgr sess;
337     uint32_t origin;
338     TEEC_UUID testId = ARITHMETIC_API_UUID;
339     TEEC_Result ret = sess.Start(&testId);
340     ASSERT_EQ(ret, TEEC_SUCCESS);
341 
342     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_BIG_INT_ASSIGN, NULL, &origin);
343     ASSERT_EQ(ret, TEEC_SUCCESS);
344     sess.Destroy();
345 }
346 
347 /**
348  * @testcase.name      : BigInt_Abs
349  * @testcase.desc      : test abs
350  * @testcase.expect    : return TEEC_SUCCESS
351  */
352 TEE_TEST(TeeBasicTestFram, BigInt_Abs, Function | MediumTest | Level0)
353 {
354     ClientSessionMgr sess;
355     uint32_t origin;
356     TEEC_UUID testId = ARITHMETIC_API_UUID;
357     TEEC_Result ret = sess.Start(&testId);
358     ASSERT_EQ(ret, TEEC_SUCCESS);
359 
360     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_BIG_INT_ABS, NULL, &origin);
361     ASSERT_EQ(ret, TEEC_SUCCESS);
362     sess.Destroy();
363 }
364 
365 /**
366  * @testcase.name      : BigInt_RelativePrime
367  * @testcase.desc      : test Relative Prime
368  * @testcase.expect    : return TEEC_SUCCESS
369  */
370 TEE_TEST(TeeBasicTestFram, BigInt_RelativePrime, Function | MediumTest | Level0)
371 {
372     ClientSessionMgr sess;
373     uint32_t origin;
374     TEEC_UUID testId = ARITHMETIC_API_UUID;
375     TEEC_Result ret = sess.Start(&testId);
376     ASSERT_EQ(ret, TEEC_SUCCESS);
377 
378     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_BIG_INT_RELATIVE_PRIME, NULL, &origin);
379     ASSERT_EQ(ret, TEEC_SUCCESS);
380     sess.Destroy();
381 }
382 
383 /**
384  * @testcase.name      : BigInt_ComputeExtendedGcd
385  * @testcase.desc      : test compute extended gcd
386  * @testcase.expect    : return TEEC_SUCCESS
387  */
388 TEE_TEST(TeeBasicTestFram, BigInt_ComputeExtendedGcd, Function | MediumTest | Level0)
389 {
390     ClientSessionMgr sess;
391     uint32_t origin;
392     TEEC_UUID testId = ARITHMETIC_API_UUID;
393     TEEC_Result ret = sess.Start(&testId);
394     ASSERT_EQ(ret, TEEC_SUCCESS);
395 
396     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_BIG_INT_COMPUTE_EXTENTED_GCD, NULL, &origin);
397     ASSERT_EQ(ret, TEEC_SUCCESS);
398     sess.Destroy();
399 }
400 
401 /**
402  * @testcase.name      : BigInt_ProbabilisticPrimality
403  * @testcase.desc      : test probabilistic primality
404  * @testcase.expect    : return TEEC_SUCCESS
405  */
406 TEE_TEST(TeeBasicTestFram, BigInt_ProbabilisticPrimality, Function | MediumTest | Level0)
407 {
408     ClientSessionMgr sess;
409     uint32_t origin;
410     TEEC_UUID testId = ARITHMETIC_API_UUID;
411     TEEC_Result ret = sess.Start(&testId);
412     ASSERT_EQ(ret, TEEC_SUCCESS);
413 
414     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_BIG_INT_IS_PROBABLE_PRIME, NULL, &origin);
415     ASSERT_EQ(ret, TEEC_SUCCESS);
416     sess.Destroy();
417 }
418 
419 /**
420  * @testcase.name      : BigInt_Compare
421  * @testcase.desc      : test comparison
422  * @testcase.expect    : return TEEC_SUCCESS
423  */
424 TEE_TEST(TeeBasicTestFram, BigInt_Compare, Function | MediumTest | Level0)
425 {
426     ClientSessionMgr sess;
427     uint32_t origin;
428     TEEC_UUID testId = ARITHMETIC_API_UUID;
429     TEEC_Result ret = sess.Start(&testId);
430     ASSERT_EQ(ret, TEEC_SUCCESS);
431 
432     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_BIG_INT_CMP, NULL, &origin);
433     ASSERT_EQ(ret, TEEC_SUCCESS);
434     sess.Destroy();
435 }
436 
437 /**
438  * @testcase.name      : BigInt_CompareWithShortVal
439  * @testcase.desc      : test comparison with shortVal
440  * @testcase.expect    : return TEEC_SUCCESS
441  */
442 TEE_TEST(TeeBasicTestFram, BigInt_CompareWithShortVal, Function | MediumTest | Level0)
443 {
444     ClientSessionMgr sess;
445     uint32_t origin;
446     TEEC_UUID testId = ARITHMETIC_API_UUID;
447     TEEC_Result ret = sess.Start(&testId);
448     ASSERT_EQ(ret, TEEC_SUCCESS);
449 
450     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_BIG_INT_CMP_S32, NULL, &origin);
451     ASSERT_EQ(ret, TEEC_SUCCESS);
452     sess.Destroy();
453 }
454 
455 /**
456  * @testcase.name      : BigInt_InitializeFMM
457  * @testcase.desc      : test initialize bigIntFMM
458  * @testcase.expect    : return TEEC_SUCCESS
459  */
460 TEE_TEST(TeeBasicTestFram, BigInt_InitializeFMM, Function | MediumTest | Level0)
461 {
462     ClientSessionMgr sess;
463     uint32_t origin;
464     TEEC_UUID testId = ARITHMETIC_API_UUID;
465     TEEC_Result ret = sess.Start(&testId);
466     ASSERT_EQ(ret, TEEC_SUCCESS);
467 
468     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_BIG_INT_INIT_FMM, NULL, &origin);
469     ASSERT_EQ(ret, TEEC_SUCCESS);
470     sess.Destroy();
471 }
472 
473 /**
474  * @testcase.name      : BigInt_InitializeBigInt
475  * @testcase.desc      : test initialize bigInt
476  * @testcase.expect    : return TEEC_SUCCESS
477  */
478 TEE_TEST(TeeBasicTestFram, BigInt_InitializeBigInt, Function | MediumTest | Level0)
479 {
480     ClientSessionMgr sess;
481     uint32_t origin;
482     TEEC_UUID testId = ARITHMETIC_API_UUID;
483     TEEC_Result ret = sess.Start(&testId);
484     ASSERT_EQ(ret, TEEC_SUCCESS);
485 
486     ret = TEEC_InvokeCommand(&sess.session, CMD_ID_TEST_BIG_INT_INIT, NULL, &origin);
487     ASSERT_EQ(ret, TEEC_SUCCESS);
488     sess.Destroy();
489 }