1 /*
2 * Copyright (c) 2022-2024 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 "cm_test_log.h"
18 #include "cm_test_common.h"
19 #include "cert_manager_api.h"
20 #include "cm_log.h"
21 #include "cm_mem.h"
22 #include "cm_cert_data_user.h"
23
24 using namespace testing::ext;
25 using namespace CertmanagerTest;
26 namespace {
27 constexpr uint32_t MAX_URI_LEN = 256;
28
29 struct UserCertListResult {
30 struct CertAbstract certAbstract;
31 bool bExpectResult;
32 };
33
34 struct UserCertListResult g_certListExpectResult[] = {
35 {
36 {
37 "oh:t=c;o=40dc992e;u=0;a=0",
38 "40dc992e",
39 true,
40 "CN=Hellenic Academic and Research Institutions RootCA 2011,OU=,"
41 "O=Hellenic Academic and Research Institutions Cert. Authority"
42 },
43 true
44 },
45 {
46 {
47 "oh:t=c;o=985c1f52;u=0;a=0",
48 "985c1f52",
49 true,
50 "CN=GlobalSign,OU=GlobalSign Root CA - R6,O=GlobalSign"
51 },
52 true
53 },
54 {
55 {
56 "oh:t=c;o=1df5a75f;u=0;a=0",
57 "1df5a75f",
58 true,
59 "CN=D-TRUST Root Class 3 CA 2 2009,OU=,O=D-Trust GmbH"
60 },
61 true
62 },
63 {
64 {
65 "oh:t=c;o=2e0g9ue5;u=0;a=0",
66 "2e0g9ue5",
67 true,
68 "CN=TEST01,OU=TEST02,O=TEST03"
69 },
70 true
71 }
72 };
73
74 struct UserCertInfoResult {
75 struct CertInfo certInfo;
76 bool bExpectResult;
77 };
78
79 struct UserCertInfoResult g_certInfoExpectResult[] = {
80 {
81 {
82 "oh:t=c;o=40dc992e;u=0;a=0",
83 "40dc992e",
84 true,
85 "CN=Hellenic Academic and Research Institutions RootCA 2011,OU=,"
86 "O=Hellenic Academic and Research Institutions Cert. Authority",
87 "CN=Hellenic Academic and Research Institutions RootCA 2011,OU=,"
88 "O=Hellenic Academic and Research Institutions Cert. Authority",
89 "0",
90 "2011-12-6",
91 "2031-12-1",
92 "BC:10:4F:15:A4:8B:E7:09:DC:A5:42:A7:E1:D4:B9:DF:6F:05:45:27:E8:02:EA:A9:2D:59:54:44:25:8A:FE:71",
93 { sizeof(g_certData01), const_cast<uint8_t *>(g_certData01) }
94 },
95 true
96 },
97 {
98 {
99 "oh:t=c;o=985c1f52;u=0;a=0",
100 "985c1f52",
101 true,
102 "CN=GlobalSign,OU=GlobalSign Root CA - R6,O=GlobalSign",
103 "CN=GlobalSign,OU=GlobalSign Root CA - R6,O=GlobalSign",
104 "45E6BB038333C3856548E6FF4551",
105 "2014-12-10",
106 "2034-12-10",
107 "2C:AB:EA:FE:37:D0:6C:A2:2A:BA:73:91:C0:03:3D:25:98:29:52:C4:53:64:73:49:76:3A:3A:B5:AD:6C:CF:69",
108 { sizeof(g_certData02), const_cast<uint8_t *>(g_certData02) }
109 },
110 true
111 },
112 {
113 {
114 "oh:t=c;o=1df5a75f;u=0;a=0",
115 "1df5a75f",
116 true,
117 "CN=D-TRUST Root Class 3 CA 2 2009,OU=,O=D-Trust GmbH",
118 "CN=D-TRUST Root Class 3 CA 2 2009,OU=,O=D-Trust GmbH",
119 "0983F3",
120 "2009-11-5",
121 "2029-11-5",
122 "49:E7:A4:42:AC:F0:EA:62:87:05:00:54:B5:25:64:B6:50:E4:F4:9E:42:E3:48:D6:AA:38:E0:39:E9:57:B1:C1",
123 { sizeof(g_certData03), const_cast<uint8_t *>(g_certData03) }
124 },
125 true
126 },
127 {
128 {
129 "oh:t=c;o=2e0g9ue5;u=0;a=0",
130 "2e0g9ue5",
131 true,
132 "CN=Example Root CA,OU=,O=",
133 "CN=TEST01,OU=TEST02,O=TEST03",
134 "01",
135 "2022-12-16",
136 "2025-9-10",
137 "60:57:A8:41:CD:4E:45:F6:7F:93:21:C4:E9:A0:F9:5F:45:CB:D5:39:02:43:A9:AF:4F:0A:04:D0:2C:41:99:68",
138 { sizeof(g_certData05), const_cast<uint8_t *>(g_certData05) }
139 },
140 true
141 }
142 };
143
144 struct UserCertStatusExpectResult {
145 char uri[MAX_URI_LEN];
146 bool inparamStatus;
147 bool expectStatus;
148 };
149
150 struct UserCertStatusExpectResult g_certStatusExpectResult[] = {
151 {
152 {"oh:t=c;o=40dc992e;u=0;a=0"}, false, false
153 },
154 {
155 {"oh:t=c;o=985c1f52;u=0;a=0"}, false, false
156 },
157 {
158 {"oh:t=c;o=1df5a75f;u=0;a=0"}, true, true
159 },
160 {
161 {"oh:t=c;o=2e0g9ue5;u=0;a=0"}, true, true
162 }
163 };
164
165 struct CmBlob userCert[] = {
166 { sizeof(g_certData01), const_cast<uint8_t *>(g_certData01) },
167 { sizeof(g_certData02), const_cast<uint8_t *>(g_certData02) },
168 { sizeof(g_certData03), const_cast<uint8_t *>(g_certData03) },
169 { sizeof(g_certData05), const_cast<uint8_t *>(g_certData05) }
170 };
171
172 static uint8_t certAliasBuf01[] = "40dc992e";
173 static uint8_t certAliasBuf02[] = "985c1f52";
174 static uint8_t certAliasBuf03[] = "1df5a75f";
175 static uint8_t certAliasBuf05[] = "2e0g9ue5";
176 static uint8_t certAliasBuf06[] = "3a2g6de7";
177
178 struct CmBlob certAlias[] = {
179 { sizeof(certAliasBuf01), certAliasBuf01 },
180 { sizeof(certAliasBuf02), certAliasBuf02 },
181 { sizeof(certAliasBuf03), certAliasBuf03 },
182 { sizeof(certAliasBuf05), certAliasBuf05 }
183 };
184
185 class CmUserCertTest : public testing::Test {
186 public:
187 static void SetUpTestCase(void);
188
189 static void TearDownTestCase(void);
190
191 void SetUp();
192
193 void TearDown();
194 };
195
SetUpTestCase(void)196 void CmUserCertTest::SetUpTestCase(void)
197 {
198 SetATPermission();
199 }
200
TearDownTestCase(void)201 void CmUserCertTest::TearDownTestCase(void)
202 {
203 }
204
SetUp()205 void CmUserCertTest::SetUp()
206 {
207 }
208
TearDown()209 void CmUserCertTest::TearDown()
210 {
211 }
212
213 /**
214 * @tc.name: InstallUserCertTest001
215 * @tc.desc: Test CertManager Install user cert interface base function
216 * @tc.type: FUNC
217 * @tc.require: AR000H0MJ8 /SR000H09N7
218 */
219 HWTEST_F(CmUserCertTest, InstallUserCertTest001, TestSize.Level0)
220 {
221 int32_t ret;
222 uint8_t uriBuf001[MAX_URI_LEN] = {0};
223 struct CmBlob certUri = { sizeof(uriBuf001), uriBuf001 };
224
225 ret = CmInstallUserTrustedCert(&userCert[0], &certAlias[0], &certUri);
226 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
227
228 ret = CmUninstallUserTrustedCert(&certUri);
229 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall test failed, recode:" << ret;
230 }
231
232 /**
233 * @tc.name: InstallUserCertTest002
234 * @tc.desc: Test CertManager Install cert interface base function
235 * @tc.type: FUNC
236 * @tc.require: AR000H0MJ8 /SR000H09N7
237 */
238 HWTEST_F(CmUserCertTest, InstallUserCertTest002, TestSize.Level0)
239 {
240 int32_t ret;
241 uint8_t uriBuf002[MAX_URI_LEN] = {0};
242 struct CmBlob certUri = { sizeof(uriBuf002), uriBuf002 };
243
244 ret = CmInstallUserTrustedCert(&userCert[1], &certAlias[1], &certUri);
245 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
246
247 ret = CmUninstallUserTrustedCert(&certUri);
248 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall test failed, recode:" << ret;
249 }
250
251 /**
252 * @tc.name: InstallUserCertTest003
253 * @tc.desc: Test CertManager Install user cert interface base function
254 * @tc.type: FUNC
255 * @tc.require: AR000H0MJ8 /SR000H09N7
256 */
257 HWTEST_F(CmUserCertTest, InstallUserCertTest003, TestSize.Level0)
258 {
259 int32_t ret;
260 uint8_t uriBuf003[MAX_URI_LEN] = {0};
261 struct CmBlob certUri = { sizeof(uriBuf003), uriBuf003 };
262
263 ret = CmInstallUserTrustedCert(&userCert[2], &certAlias[2], &certUri);
264 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
265
266 ret = CmUninstallUserTrustedCert(&certUri);
267 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall test failed, recode:" << ret;
268 }
269
270 /**
271 * @tc.name: InstallUserCertTest004
272 * @tc.desc: Test CertManager Update user cert interface base function
273 * @tc.type: FUNC
274 * @tc.require: AR000H0MJ8 /SR000H09N7
275 */
276 HWTEST_F(CmUserCertTest, InstallUserCertTest004, TestSize.Level0)
277 {
278 int32_t ret;
279 uint8_t aliasBuf001[] = "40dc992e";
280 uint8_t uriBuf004[MAX_URI_LEN] = {0};
281 struct CmBlob userCertUpdate = { sizeof(g_certData01), const_cast<uint8_t *>(g_certData01) };
282 struct CmBlob certAliasUpdate = { sizeof(aliasBuf001), aliasBuf001 };
283 struct CmBlob certUriUpdate = { sizeof(uriBuf004), uriBuf004 };
284
285 ret = CmInstallUserTrustedCert(&userCertUpdate, &certAliasUpdate, &certUriUpdate);
286 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
287
288 ret = CmInstallUserTrustedCert(&userCertUpdate, &certAliasUpdate, &certUriUpdate);
289 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
290
291 ret = CmUninstallUserTrustedCert(&certUriUpdate);
292 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall test failed, recode:" << ret;
293 }
294
295 /**
296 * @tc.name: InstallUserCertTest005
297 * @tc.desc: Test CertManager Install user cert interface Abnormal function
298 * @tc.type: FUNC
299 * @tc.require: AR000H0MJ8 /SR000H09N7
300 */
301 HWTEST_F(CmUserCertTest, InstallUserCertTest005, TestSize.Level0)
302 {
303 int32_t ret;
304 uint8_t aliasBuf002[] = "abnormal_invalid_certdata";
305 uint8_t uriBuf005[MAX_URI_LEN] = {0};
306
307 struct CmBlob userCertTemp = { sizeof(g_certData04),
308 const_cast<uint8_t *>(g_certData04) }; /* invalid certData */
309 struct CmBlob certAliasTemp = { sizeof(aliasBuf002), aliasBuf002 };
310 struct CmBlob certUriTemp = { sizeof(uriBuf005), uriBuf005 };
311
312 ret = CmInstallUserTrustedCert(&userCertTemp, &certAliasTemp, &certUriTemp);
313 EXPECT_EQ(ret, CMR_ERROR_INVALID_CERT_FORMAT) << "Normal user cert Install test failed, recode:" << ret;
314 }
315
316 /**
317 * @tc.name: InstallUserCertTest006
318 * @tc.desc: Test CertManager Install user cert interface Abnormal function
319 * @tc.type: FUNC
320 * @tc.require: AR000H0MJ8 /SR000H09N7
321 */
322 HWTEST_F(CmUserCertTest, InstallUserCertTest006, TestSize.Level0)
323 {
324 int32_t ret;
325 uint8_t aliasBuf003[] = "abnormal-inputparam-null";
326 uint8_t uriBuf006[MAX_URI_LEN] = {0};
327
328 struct CmBlob userCertTemp = { sizeof(g_certData03), const_cast<uint8_t *>(g_certData03) };
329 struct CmBlob certAliasTemp = { sizeof(aliasBuf003), aliasBuf003 };
330 struct CmBlob certUriTemp = { sizeof(uriBuf006), uriBuf006 };
331
332 ret = CmInstallUserTrustedCert(nullptr, &certAliasTemp, &certUriTemp);
333 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "Normal user cert Install test failed, recode:" << ret;
334
335 ret = CmInstallUserTrustedCert(&userCertTemp, nullptr, &certUriTemp);
336 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "Normal user cert Install test failed, recode:" << ret;
337
338 ret = CmInstallUserTrustedCert(&userCertTemp, &certAliasTemp, nullptr);
339 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "Normal user cert Install test failed, recode:" << ret;
340 }
341
342 /**
343 * @tc.name: InstallUserCertTest007
344 * @tc.desc: Test CertManager install max count user cert interface base function
345 * @tc.type: FUNC
346 * @tc.require: AR000H0MJ8 /SR000H09N7
347 */
348 HWTEST_F(CmUserCertTest, InstallUserCertTest007, TestSize.Level0)
349 {
350 int32_t ret;
351 struct CmBlob userCertTest = { sizeof(g_certData01), const_cast<uint8_t *>(g_certData01) };
352
353 for (uint32_t i = 0; i < MAX_COUNT_CERTIFICATE; i++) { /* install 256 times user cert */
354 char alias[] = "alias";
355 char aliasBuf004[MAX_LEN_CERT_ALIAS];
356 (void)snprintf_s(aliasBuf004, MAX_LEN_CERT_ALIAS, MAX_LEN_CERT_ALIAS - 1, "%s%u", alias, i);
357 struct CmBlob certAliasTest = { strlen(aliasBuf004) + 1, reinterpret_cast<uint8_t *>(aliasBuf004) };
358
359 uint8_t uriBuf007[MAX_URI_LEN] = {0};
360 struct CmBlob certUriTest = { sizeof(uriBuf007), uriBuf007 };
361
362 ret = CmInstallUserTrustedCert(&userCertTest, &certAliasTest, &certUriTest);
363 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
364 }
365
366 uint8_t certAliasBuf257[] = "40dc992e"; /* install 257th user cert */
367 uint8_t certUriBuf257[MAX_URI_LEN] = {0};
368 struct CmBlob certAlias257 = { sizeof(certAliasBuf257), certAliasBuf257 };
369 struct CmBlob certUri257 = { sizeof(certUriBuf257), certUriBuf257 };
370
371 ret = CmInstallUserTrustedCert(&userCertTest, &certAlias257, &certUri257);
372 EXPECT_EQ(ret, CMR_ERROR_MAX_CERT_COUNT_REACHED) << "Normal user cert Install test failed, recode:" << ret;
373
374 uint8_t certAliasBuf000[] = "alias0"; /* update 001th user cert */
375 uint8_t certUriBuf000[MAX_URI_LEN] = {0};
376 struct CmBlob certAlias000 = { sizeof(certAliasBuf000), certAliasBuf000 };
377 struct CmBlob certUri000 = { sizeof(certUriBuf000), certUriBuf000 };
378
379 ret = CmInstallUserTrustedCert(&userCertTest, &certAlias000, &certUri000);
380 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
381
382 ret = CmUninstallAllUserTrustedCert();
383 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall All test failed, recode:" << ret;
384 }
385
386 /**
387 * @tc.name: InstallUserCertTest008
388 * @tc.desc: Test CertManager Install user cert interface performance
389 * @tc.type: FUNC
390 * @tc.require: AR000H0MJ8 /SR000H09N7
391 */
392 HWTEST_F(CmUserCertTest, InstallUserCertTest008, TestSize.Level0)
393 {
394 int32_t ret;
395 for (uint32_t times = 0; times < PERFORMACE_COUNT; ++times) {
396 uint8_t uriBuf008[MAX_URI_LEN] = {0};
397 struct CmBlob certUri = { sizeof(uriBuf008), uriBuf008 };
398
399 ret = CmInstallUserTrustedCert(&userCert[2], &certAlias[2], &certUri);
400 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
401
402 ret = CmUninstallUserTrustedCert(&certUri);
403 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall test failed, recode:" << ret;
404 }
405 }
406
407 /**
408 * @tc.name: InstallUserCertTest009
409 * @tc.desc: Test CertManager Install user cert interface Abnormal function
410 * @tc.type: FUNC
411 * @tc.require: AR000H0MJ8 /SR000H09N7
412 */
413 HWTEST_F(CmUserCertTest, InstallUserCertTest009, TestSize.Level0)
414 {
415 int32_t ret;
416 /* size is 66, include 1 byte: the terminator('\0') */
417 uint8_t largeAliasBuf[] = "large-size-input-cert-alias-0000000000000000000000000000000000000";
418 uint8_t certUriBuf[MAX_URI_LEN] = {0};
419
420 struct CmBlob userCertTemp = { sizeof(g_certData02), const_cast<uint8_t *>(g_certData02) };
421 struct CmBlob largeAlias = { sizeof(largeAliasBuf), largeAliasBuf };
422 struct CmBlob certUriTemp = { sizeof(certUriBuf), certUriBuf };
423
424 ret = CmInstallUserTrustedCert(&userCertTemp, &largeAlias, &certUriTemp);
425 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "Normal user cert Install test failed, recode:" << ret;
426 }
427
428 /**
429 * @tc.name: InstallUserCertTest010
430 * @tc.desc: Test CertManager Install user cert interface Abnormal function
431 * @tc.type: FUNC
432 * @tc.require: AR000H0MJ8 /SR000H09N7
433 */
434 HWTEST_F(CmUserCertTest, InstallUserCertTest010, TestSize.Level0)
435 {
436 int32_t ret;
437 char errAliasBuf[] = "AliasNoEnd";
438 uint8_t certUriBuf[MAX_URI_LEN] = {0};
439
440 struct CmBlob userCertTemp = { sizeof(g_certData01), const_cast<uint8_t *>(g_certData01) };
441 struct CmBlob noEndAlias = { strlen(errAliasBuf), reinterpret_cast<uint8_t *>(errAliasBuf) };
442 struct CmBlob certUriTemp = { sizeof(certUriBuf), certUriBuf };
443
444 ret = CmInstallUserTrustedCert(&userCertTemp, &noEndAlias, &certUriTemp);
445 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "Normal user cert Install test failed, recode:" << ret;
446 }
447
448 /**
449 * @tc.name: InstallUserCertTest011
450 * @tc.desc: Test CertManager Install user cert interface normal function
451 * @tc.type: FUNC
452 * @tc.require: AR000H0MJ8 /SR000H09N7
453 */
454 HWTEST_F(CmUserCertTest, InstallUserCertTest011, TestSize.Level0)
455 {
456 int32_t ret;
457 char edgeAliasBuf[] = "alias_length_is_48_000000000000000000000000000000000000000000000"; /* size is 64 */
458 uint8_t uriBuf[MAX_URI_LEN] = {0};
459
460 struct CmBlob userCertTemp = { sizeof(g_certData01), const_cast<uint8_t *>(g_certData01) };
461 struct CmBlob edgeAlias = { strlen(edgeAliasBuf) + 1, reinterpret_cast<uint8_t *>(edgeAliasBuf) };
462 struct CmBlob uri = { sizeof(uriBuf), uriBuf };
463
464 ret = CmInstallUserTrustedCert(&userCertTemp, &edgeAlias, &uri);
465 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
466
467 ret = CmUninstallUserTrustedCert(&uri);
468 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall test failed, recode:" << ret;
469 }
470
471 /**
472 * @tc.name: InstallUserCertTest012
473 * @tc.desc: Test CertManager Install pem user cert interface base function
474 * @tc.type: FUNC
475 * @tc.require: AR000H0MJ8 /SR000H09N7
476 */
477 HWTEST_F(CmUserCertTest, InstallUserCertTest012, TestSize.Level0)
478 {
479 int32_t ret;
480 uint8_t uriBuf012[MAX_URI_LEN] = {0};
481 struct CmBlob certUri = { sizeof(uriBuf012), uriBuf012 };
482
483 struct CmBlob userCert012 = { strlen(g_certData06) + 1, reinterpret_cast<uint8_t *>(g_certData06) };
484 struct CmBlob certAlias012 = { sizeof(certAliasBuf06), certAliasBuf06 };
485 ret = CmInstallUserTrustedCert(&userCert012, &certAlias012, &certUri);
486 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
487
488 ret = CmUninstallUserTrustedCert(&certUri);
489 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
490 }
491
492 /**
493 * @tc.name: InstallUserCertTest013
494 * @tc.desc: Test CertManager Install user ca cert interface base function
495 * @tc.type: FUNC
496 * @tc.require: AR000H0MJ8 /SR000H09N7
497 */
498 HWTEST_F(CmUserCertTest, InstallUserCertTest013, TestSize.Level0)
499 {
500 int32_t ret;
501 uint8_t uriBuf013[MAX_URI_LEN] = {0};
502 struct CmBlob certUri013 = { sizeof(uriBuf013), uriBuf013 };
503
504 ret = CmInstallUserCACert(&userCert[0], &certAlias[0], TEST_USERID, true, &certUri013);
505 EXPECT_EQ(ret, CM_SUCCESS) << "Normal install user ca cert test failed, recode:" << ret;
506
507 ret = CmUninstallUserTrustedCert(&certUri013);
508 EXPECT_EQ(ret, CM_SUCCESS) << "Normal uninstall user ca cert test failed, recode:" << ret;
509 }
510
511 /**
512 * @tc.name: InstallUserCertTest014
513 * @tc.desc: Test CertManager Install user ca cert interface Abnormal function
514 * @tc.type: FUNC
515 * @tc.require: AR000H0MJ8 /SR000H09N7
516 */
517 HWTEST_F(CmUserCertTest, InstallUserCertTest014, TestSize.Level0)
518 {
519 int32_t ret;
520 uint8_t uriBuf014[MAX_URI_LEN] = {0};
521 struct CmBlob certUri014 = { sizeof(uriBuf014), uriBuf014 };
522
523 ret = CmInstallUserCACert(nullptr, &certAlias[0], TEST_USERID, true, &certUri014);
524 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "abnormal install user ca cert test failed, recode:" << ret;
525
526 ret = CmInstallUserCACert(&userCert[0], nullptr, TEST_USERID, true, &certUri014);
527 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "abnormal install user ca cert test failed, recode:" << ret;
528
529 ret = CmInstallUserCACert(&userCert[0], &certAlias[0], TEST_USERID, true, nullptr);
530 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "abnormal install user ca cert test failed, recode:" << ret;
531 }
532
533 /**
534 * @tc.name: InstallUserCertTest015
535 * @tc.desc: Test CertManager Install user ca cert interface Abnormal function
536 * @tc.type: FUNC
537 * @tc.require: AR000H0MJ8 /SR000H09N7
538 */
539 HWTEST_F(CmUserCertTest, InstallUserCertTest015, TestSize.Level0)
540 {
541 int32_t ret;
542 uint8_t uriBuf015[MAX_URI_LEN] = {0};
543 struct CmBlob certUri015 = { sizeof(uriBuf015), uriBuf015 };
544 struct CmBlob userCertTemp = { sizeof(g_certData04),
545 const_cast<uint8_t *>(g_certData04) }; /* invalid certData */
546
547 ret = CmInstallUserCACert(&userCertTemp, &certAlias[0], TEST_USERID, true, &certUri015);
548 EXPECT_EQ(ret, CMR_ERROR_INVALID_CERT_FORMAT) << "abnormal install user ca cert test failed, recode:" << ret;
549 }
550
551 /**
552 * @tc.name: InstallUserCertTest016
553 * @tc.desc: Test CertManager Install user ca cert interface Abnormal function
554 * @tc.type: FUNC
555 * @tc.require: AR000H0MJ8 /SR000H09N7
556 */
557 HWTEST_F(CmUserCertTest, InstallUserCertTest016, TestSize.Level0)
558 {
559 int32_t ret;
560 /* size is 66, include 1 byte: the terminator('\0') */
561 uint8_t largeAliasBuf[] = "large-size-input-cert-alias-0000000000000000000000000000000000000";
562 struct CmBlob largeAlias = { sizeof(largeAliasBuf), largeAliasBuf };
563 uint8_t uriBuf016[MAX_URI_LEN] = {0};
564 struct CmBlob certUri016 = { sizeof(uriBuf016), uriBuf016 };
565 struct CmBlob userCertTemp = { sizeof(g_certData02), const_cast<uint8_t *>(g_certData02) };
566
567 ret = CmInstallUserCACert(&userCertTemp, &largeAlias, TEST_USERID, true, &certUri016);
568 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "abnormal install user ca cert test failed, recode:" << ret;
569 }
570
571 /**
572 * @tc.name: InstallUserCertTest017
573 * @tc.desc: Test CertManager Install user ca cert interface Abnormal function
574 * @tc.type: FUNC
575 * @tc.require: AR000H0MJ8 /SR000H09N7
576 */
577 HWTEST_F(CmUserCertTest, InstallUserCertTest017, TestSize.Level0)
578 {
579 int32_t ret;
580 char errAliasBuf[] = "AliasNoEnd";
581 struct CmBlob noEndAlias017 = { strlen(errAliasBuf), reinterpret_cast<uint8_t *>(errAliasBuf) };
582 struct CmBlob userCertTemp = { sizeof(g_certData01), const_cast<uint8_t *>(g_certData01) };
583 uint8_t uriBuf017[MAX_URI_LEN] = {0};
584 struct CmBlob certUri016 = { sizeof(uriBuf017), uriBuf017 };
585
586 ret = CmInstallUserCACert(&userCertTemp, &noEndAlias017, TEST_USERID, true, &certUri016);
587 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "abnormal install user ca cert test failed, recode:" << ret;
588 }
589
590 /**
591 * @tc.name: InstallUserCertTest018
592 * @tc.desc: Test CertManager Install user ca cert interface normal function
593 * @tc.type: FUNC
594 * @tc.require: AR000H0MJ8 /SR000H09N7
595 */
596 HWTEST_F(CmUserCertTest, InstallUserCertTest018, TestSize.Level0)
597 {
598 int32_t ret;
599 char edgeAliasBuf[] = "alias_length_is_48_000000000000000000000000000000000000000000000"; /* size is 64 */
600 struct CmBlob edgeAlias018 = { strlen(edgeAliasBuf) + 1, reinterpret_cast<uint8_t *>(edgeAliasBuf) };
601 uint8_t uriBuf[MAX_URI_LEN] = {0};
602 struct CmBlob uri = { sizeof(uriBuf), uriBuf };
603 struct CmBlob userCertTemp = { sizeof(g_certData01), const_cast<uint8_t *>(g_certData01) };
604
605 ret = CmInstallUserCACert(&userCertTemp, &edgeAlias018, TEST_USERID, true, &uri);
606 EXPECT_EQ(ret, CM_SUCCESS) << "normal install user ca cert test failed, recode:" << ret;
607
608 ret = CmUninstallUserTrustedCert(&uri);
609 EXPECT_EQ(ret, CM_SUCCESS) << "normal install user ca cert test failed, recode:" << ret;
610 }
611
612 /**
613 * @tc.name: InstallUserCertTest019
614 * @tc.desc: Test CertManager Install user cert interface Abnormal function
615 * @tc.type: FUNC
616 * @tc.require: AR000H0MJ8 /SR000H09N7
617 */
618 HWTEST_F(CmUserCertTest, InstallUserCertTest019, TestSize.Level0)
619 {
620 int32_t ret;
621 uint8_t uriBuf019[MAX_URI_LEN] = {0};
622 struct CmBlob certUri19 = { sizeof(uriBuf019), nullptr };
623
624 ret = CmInstallUserCACert(&userCert[0], &certAlias[0], TEST_USERID, true, &certUri19);
625 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "abormal install user ca cert test failed, recode:" << ret;
626 }
627
628 /**
629 * @tc.name: InstallUserCertTest020
630 * @tc.desc: Test CertManager Install user cert interface Abnormal function
631 * @tc.type: FUNC
632 * @tc.require: AR000H0MJ8 /SR000H09N7
633 */
634 HWTEST_F(CmUserCertTest, InstallUserCertTest020, TestSize.Level0)
635 {
636 int32_t ret;
637 uint8_t uriBuf020[MAX_URI_LEN] = {0};
638 struct CmBlob certUri20 = { 0, uriBuf020 };
639
640 ret = CmInstallUserCACert(&userCert[0], &certAlias[0], TEST_USERID, true, &certUri20);
641 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "abormal install user ca cert test failed, recode:" << ret;
642 }
643
644 /**
645 * @tc.name: InstallUserCertTest021
646 * @tc.desc: Test CertManager Install user cert interface Abnormal function
647 * @tc.type: FUNC
648 * @tc.require: AR000H0MJ8 /SR000H09N7
649 */
650 HWTEST_F(CmUserCertTest, InstallUserCertTest021, TestSize.Level0)
651 {
652 int32_t ret;
653 uint8_t uriBuf021[MAX_URI_LEN] = {0};
654 struct CmBlob certUri21 = { sizeof(uriBuf021), uriBuf021 };
655
656 struct CmBlob userCert021 = { sizeof(g_certData01), nullptr };
657
658 ret = CmInstallUserCACert(&userCert021, &certAlias[0], TEST_USERID, true, &certUri21);
659 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "abormal install user ca cert test failed, recode:" << ret;
660 }
661
662 /**
663 * @tc.name: InstallUserCertTest022
664 * @tc.desc: Test CertManager Install user cert interface Abnormal function
665 * @tc.type: FUNC
666 * @tc.require: AR000H0MJ8 /SR000H09N7
667 */
668 HWTEST_F(CmUserCertTest, InstallUserCertTest022, TestSize.Level0)
669 {
670 int32_t ret;
671 uint8_t uriBuf022[MAX_URI_LEN] = {0};
672 struct CmBlob certUri22 = { sizeof(uriBuf022), uriBuf022 };
673
674 struct CmBlob userCert022 = { 0, const_cast<uint8_t *>(g_certData01) };
675
676 ret = CmInstallUserCACert(&userCert022, &certAlias[0], TEST_USERID, true, &certUri22);
677 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "abormal install user ca cert test failed, recode:" << ret;
678 }
679
680 /**
681 * @tc.name: InstallUserCertTest023
682 * @tc.desc: Test CertManager Install user cert interface Abnormal function
683 * @tc.type: FUNC
684 * @tc.require: AR000H0MJ8 /SR000H09N7
685 */
686 HWTEST_F(CmUserCertTest, InstallUserCertTest023, TestSize.Level0)
687 {
688 int32_t ret;
689 uint8_t uriBuf023[MAX_URI_LEN] = {0};
690 struct CmBlob certUri23 = { sizeof(uriBuf023), uriBuf023 };
691
692 uint8_t userData[MAX_LEN_CERTIFICATE + 1] = { 0 };
693 struct CmBlob userCert023 = { MAX_LEN_CERTIFICATE + 1, userData };
694
695 ret = CmInstallUserCACert(&userCert023, &certAlias[0], TEST_USERID, true, &certUri23);
696 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "abormal install user ca cert test failed, recode:" << ret;
697 }
698
699 /**
700 * @tc.name: InstallUserCertTest024
701 * @tc.desc: Test CertManager Install user cert interface Abnormal function
702 * @tc.type: FUNC
703 * @tc.require: AR000H0MJ8 /SR000H09N7
704 */
705 HWTEST_F(CmUserCertTest, InstallUserCertTest024, TestSize.Level0)
706 {
707 int32_t ret;
708 uint8_t uriBuf024[MAX_URI_LEN] = {0};
709 struct CmBlob certUri24 = { sizeof(uriBuf024), uriBuf024 };
710
711 char aliasBuf[] = "alias-length";
712 struct CmBlob alias024 = { strlen(aliasBuf) + 1, nullptr };
713
714 ret = CmInstallUserCACert(&userCert[0], &alias024, TEST_USERID, true, &certUri24);
715 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "abormal install user ca cert test failed, recode:" << ret;
716 }
717
718 /**
719 * @tc.name: InstallUserCertTest025
720 * @tc.desc: Test CertManager Install user cert interface Abnormal function
721 * @tc.type: FUNC
722 * @tc.require: AR000H0MJ8 /SR000H09N7
723 */
724 HWTEST_F(CmUserCertTest, InstallUserCertTest025, TestSize.Level0)
725 {
726 int32_t ret;
727 uint8_t uriBuf025[MAX_URI_LEN] = {0};
728 struct CmBlob certUri25 = { sizeof(uriBuf025), uriBuf025 };
729
730 char aliasBuf[] = "alias-length";
731 struct CmBlob alias025 = { 0, reinterpret_cast<uint8_t *>(aliasBuf) };
732
733 ret = CmInstallUserCACert(&userCert[0], &alias025, TEST_USERID, true, &certUri25);
734 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "abormal install user ca cert test failed, recode:" << ret;
735 }
736
737 /**
738 * @tc.name: InstallUserCertTest026
739 * @tc.desc: Test CertManager Install user cert interface base function
740 * @tc.type: FUNC
741 * @tc.require: AR000H0MJ8 /SR000H09N7
742 */
743 HWTEST_F(CmUserCertTest, InstallUserCertTest026, TestSize.Level0)
744 {
745 int32_t ret;
746 uint8_t uriBuf026[MAX_URI_LEN] = {0};
747 struct CmBlob certUri26 = { sizeof(uriBuf026), uriBuf026 };
748
749 char aliasBuf[] = "";
750 struct CmBlob alias026 = { strlen(aliasBuf) + 1, reinterpret_cast<uint8_t *>(aliasBuf) };
751
752 ret = CmInstallUserCACert(&userCert[0], &alias026, TEST_USERID, true, &certUri26);
753 EXPECT_EQ(ret, CM_SUCCESS) << "Normal install user ca cert test failed, recode:" << ret;
754
755 ret = CmUninstallUserTrustedCert(&certUri26);
756 EXPECT_EQ(ret, CM_SUCCESS) << "Normal uninstall user ca cert test failed, recode:" << ret;
757 }
758
759 /**
760 * @tc.name: UninstallUserCertTest001
761 * @tc.desc: Test CertManager Uninstall user cert interface base function
762 * @tc.type: FUNC
763 * @tc.require: AR000H0MJ8 /SR000H09N7
764 */
765 HWTEST_F(CmUserCertTest, UninstallUserCertTest001, TestSize.Level0)
766 {
767 int32_t ret;
768 uint8_t aliasBuf005[] = "985c1f52";
769 uint8_t uriBuf009[MAX_URI_LEN] = {0};
770 struct CmBlob userCertTemp = { sizeof(g_certData02), const_cast<uint8_t *>(g_certData02) };
771 struct CmBlob certAliasTemp = { sizeof(aliasBuf005), aliasBuf005 };
772 struct CmBlob certUriTemp = { sizeof(uriBuf009), uriBuf009 };
773
774 ret = CmInstallUserTrustedCert(&userCertTemp, &certAliasTemp, &certUriTemp);
775 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
776
777 ret = CmUninstallUserTrustedCert(&certUriTemp);
778 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall test failed, recode:" << ret;
779 }
780
781 /**
782 * @tc.name: UninstallUserCertTest002
783 * @tc.desc: Test CertManager Uninstall user cert interface Abnormal function
784 * @tc.type: FUNC
785 * @tc.require: AR000H0MJ8 /SR000H09N7
786 */
787 HWTEST_F(CmUserCertTest, UninstallUserCertTest002, TestSize.Level0)
788 {
789 int32_t ret;
790 uint8_t aliasBuf006[] = "40dc992e";
791 uint8_t uriBuf010[MAX_URI_LEN] = {0};
792
793 struct CmBlob userCertTemp = { sizeof(g_certData01), const_cast<uint8_t *>(g_certData01) };
794 struct CmBlob certAliasTemp = { sizeof(aliasBuf006), aliasBuf006 };
795 struct CmBlob certUriTemp = { sizeof(uriBuf010), uriBuf010 };
796
797 ret = CmInstallUserTrustedCert(&userCertTemp, &certAliasTemp, &certUriTemp);
798 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
799
800 ret = CmUninstallUserTrustedCert(nullptr); /* uri is nullptr */
801 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "Normal user cert Uninstall test failed, recode:" << ret;
802
803 ret = CmUninstallUserTrustedCert(&certUriTemp);
804 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall test failed, recode:" << ret;
805 }
806
807 /**
808 * @tc.name: UninstallUserCertTest003
809 * @tc.desc: Test CertManager Uninstall user cert interface Abnormal function
810 * @tc.type: FUNC
811 * @tc.require: AR000H0MJ8 /SR000H09N7
812 */
813 HWTEST_F(CmUserCertTest, UninstallUserCertTest003, TestSize.Level0)
814 {
815 int32_t ret;
816 uint8_t aliasBuf007[] = "985c1f52";
817 uint8_t uriBuf011[MAX_URI_LEN] = {0};
818
819 struct CmBlob userCertTemp = { sizeof(g_certData02), const_cast<uint8_t *>(g_certData02) };
820 struct CmBlob certAliasTemp = { sizeof(aliasBuf007), aliasBuf007 };
821 struct CmBlob certUriTemp = { sizeof(uriBuf011), uriBuf011 };
822
823 ret = CmInstallUserTrustedCert(&userCertTemp, &certAliasTemp, &certUriTemp);
824 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
825
826 uint8_t errUriBuf[MAX_URI_LEN] = "*****"; /* error uri */
827 struct CmBlob errUri = { sizeof(errUriBuf), errUriBuf };
828 ret = CmUninstallUserTrustedCert(&errUri);
829 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "Normal user cert Uninstall test failed, recode:" << ret;
830
831 ret = CmUninstallUserTrustedCert(&certUriTemp);
832 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall test failed, recode:" << ret;
833 }
834
835 /**
836 * @tc.name: UninstallUserCertTest004
837 * @tc.desc: Test CertManager Uninstall user cert interface Abnormal function
838 * @tc.type: FUNC
839 * @tc.require: AR000H0MJ8 /SR000H09N7
840 */
841 HWTEST_F(CmUserCertTest, UninstallUserCertTest004, TestSize.Level0)
842 {
843 int32_t ret;
844 char invalidUriBuf[] = "oh:t=c;o=NOEXIST;u=0;a=0"; /* cert of uri is not exist */
845 struct CmBlob invalidUri = { strlen(invalidUriBuf) + 1, reinterpret_cast<uint8_t *>(invalidUriBuf) };
846
847 ret = CmUninstallUserTrustedCert(&invalidUri);
848 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall test failed, recode:" << ret;
849 }
850
851 /**
852 * @tc.name: UninstallUserCertTest005
853 * @tc.desc: Test CertManager Uninstall user ca cert interface Abnormal function
854 * @tc.type: FUNC
855 * @tc.require: AR000H0MJ8 /SR000H09N7
856 */
857 HWTEST_F(CmUserCertTest, UninstallUserCertTest005, TestSize.Level0)
858 {
859 int32_t ret;
860 uint8_t uriBuf[MAX_URI_LEN] = {0};
861 struct CmBlob certUri = { sizeof(uriBuf), uriBuf };
862
863 ret = CmInstallUserCACert(&userCert[0], &certAlias[0], TEST_USERID, true, &certUri);
864 EXPECT_EQ(ret, CM_SUCCESS) << "Normal install user ca cert test failed, recode:" << ret;
865
866 uint8_t errUriBuf[] = "oh:t=c;o=40dc992e;u=100;a=1";
867 struct CmBlob errCertUri = { sizeof(errUriBuf), errUriBuf };
868 ret = CmUninstallUserTrustedCert(&errCertUri);
869 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "Normal uninstall user ca cert test failed, recode:" << ret;
870
871 ret = CmUninstallUserTrustedCert(&certUri);
872 EXPECT_EQ(ret, CM_SUCCESS) << "abormal uninstall user ca cert test failed, recode:" << ret;
873 }
874
875 /**
876 * @tc.name: UninstallALLUserCertTest001
877 * @tc.desc: Test CertManager uninstall all user cert interface base function
878 * @tc.type: FUNC
879 * @tc.require: AR000H0MJ8 /SR000H09N7
880 */
881 HWTEST_F(CmUserCertTest, UninstallALLUserCertTest001, TestSize.Level0)
882 {
883 int32_t ret;
884
885 uint32_t size = sizeof(certAlias) / sizeof(certAlias[0]);
886 for (uint32_t i = 0; i < size; i++) {
887 uint8_t uriBuf012[MAX_URI_LEN] = {0};
888 struct CmBlob certUri = { sizeof(uriBuf012), uriBuf012 };
889 ret = CmInstallUserTrustedCert(&userCert[i], &certAlias[i], &certUri);
890 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
891 }
892
893 ret = CmUninstallAllUserTrustedCert();
894 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall All test failed, recode:" << ret;
895 }
896
897 /**
898 * @tc.name: UninstallALLUserCertTest002
899 * @tc.desc: Test CertManager uninstall all user cert interface performance
900 * @tc.type: FUNC
901 * @tc.require: AR000H0MJ8 /SR000H09N7
902 */
903 HWTEST_F(CmUserCertTest, UninstallALLUserCertTest002, TestSize.Level0)
904 {
905 int32_t ret;
906
907 for (uint32_t time = 0; time < PERFORMACE_COUNT; time++) {
908 uint32_t size = sizeof(certAlias) / sizeof(certAlias[0]);
909 for (uint32_t i = 0; i < size; i++) {
910 uint8_t uriBuf013[MAX_URI_LEN] = {0};
911 struct CmBlob certUriTemp = { sizeof(uriBuf013), uriBuf013 };
912 ret = CmInstallUserTrustedCert(&userCert[i], &certAlias[i], &certUriTemp);
913 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
914 }
915
916 ret = CmUninstallAllUserTrustedCert();
917 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall All test failed, recode:" << ret;
918 }
919 }
920
921 /**
922 * @tc.name: GetUserCertListTest001
923 * @tc.desc: Test CertManager Get user cert list interface base function
924 * @tc.type: FUNC
925 * @tc.require: AR000H0MJ8 /SR000H09N7
926 */
927 HWTEST_F(CmUserCertTest, GetUserCertListTest001, TestSize.Level0)
928 {
929 int32_t ret;
930
931 uint32_t size = sizeof(certAlias) / sizeof(certAlias[0]);
932 for (uint32_t i = 0; i < size; i++) {
933 uint8_t uriBuf014[MAX_URI_LEN] = {0};
934 struct CmBlob certUri = { sizeof(uriBuf014), uriBuf014 };
935 ret = CmInstallUserTrustedCert(&userCert[i], &certAlias[i], &certUri);
936 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
937 }
938
939 struct CertList *certList001 = nullptr;
940 InitCertList(&certList001);
941 ret = CmGetUserCertList(CM_USER_TRUSTED_STORE, certList001);
942 EXPECT_EQ(ret, CM_SUCCESS) << "Normal get user cert list test failed, recode:" << ret;
943 FreeCertList(certList001);
944
945 ret = CmUninstallAllUserTrustedCert();
946 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall All test failed, recode:" << ret;
947 }
948
949 /**
950 * @tc.name: GetUserCertListTest002
951 * @tc.desc: Test CertManager Get user cert list And check content interface function
952 * @tc.type: FUNC
953 * @tc.require: AR000H0MJ8 /SR000H09N7
954 */
955 HWTEST_F(CmUserCertTest, GetUserCertListTest002, TestSize.Level0)
956 {
957 int32_t ret;
958 uint32_t size = sizeof(certAlias) / sizeof(certAlias[0]);
959 for (uint32_t i = 0; i < size; i++) {
960 uint8_t uriBuf015[MAX_URI_LEN] = {0};
961 struct CmBlob certUri = { sizeof(uriBuf015), uriBuf015 };
962 ret = CmInstallUserTrustedCert(&userCert[i], &certAlias[i], &certUri);
963 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
964 }
965
966 struct CertList *certList002 = nullptr;
967 InitCertList(&certList002);
968 ret = CmGetUserCertList(CM_USER_TRUSTED_STORE, certList002);
969 EXPECT_EQ(ret, CM_SUCCESS) << "Normal get user cert list test failed, recode:" << ret;
970
971 uint32_t len = sizeof(g_certListExpectResult) / sizeof(g_certListExpectResult[0]);
972 bool found = false;
973 for (uint32_t i = 0; i < len; i++) {
974 found = FindCertAbstract(&(g_certListExpectResult[i].certAbstract), certList002);
975 EXPECT_EQ(found, g_certListExpectResult[i].bExpectResult) << DumpCertList(certList002);
976 }
977 FreeCertList(certList002);
978
979 ret = CmUninstallAllUserTrustedCert();
980 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall All test failed, recode:" << ret;
981 }
982
983 /**
984 * @tc.name: GetUserCertListTest003
985 * @tc.desc: Test CertManager Get user cert list interface Abnormal function
986 * @tc.type: FUNC
987 * @tc.require: AR000H0MJ8 /SR000H09N7
988 */
989 HWTEST_F(CmUserCertTest, GetUserCertListTest003, TestSize.Level0)
990 {
991 int32_t ret;
992
993 uint32_t size = sizeof(certAlias) / sizeof(certAlias[0]);
994 for (uint32_t i = 0; i < size; i++) {
995 uint8_t uriBuf016[MAX_URI_LEN] = {0};
996 struct CmBlob certUri = { sizeof(uriBuf016), uriBuf016 };
997 ret = CmInstallUserTrustedCert(&userCert[i], &certAlias[i], &certUri);
998 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
999 }
1000
1001 ret = CmGetUserCertList(CM_USER_TRUSTED_STORE, nullptr); /* cList is nullptr */
1002 EXPECT_EQ(ret, CMR_ERROR_NULL_POINTER);
1003
1004 struct CertList *certList003 = nullptr;
1005 InitCertList(&certList003);
1006 ret = CmGetUserCertList(100, certList003); /* invalid store 100 */
1007 EXPECT_EQ(ret, CM_FAILURE);
1008 FreeCertList(certList003);
1009
1010 ret = CmUninstallAllUserTrustedCert();
1011 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall All test failed, recode:" << ret;
1012 }
1013
1014 /**
1015 * @tc.name: GetUserCertListTest004
1016 * @tc.desc: Test CertManager Get user cert list interface performance
1017 * @tc.type: FUNC
1018 * @tc.require: AR000H0MJ8 /SR000H09N7
1019 */
1020 HWTEST_F(CmUserCertTest, GetUserCertListTest004, TestSize.Level0)
1021 {
1022 int32_t ret;
1023
1024 uint32_t size = sizeof(certAlias) / sizeof(certAlias[0]);
1025 for (uint32_t i = 0; i < size; i++) {
1026 uint8_t uriBuf017[MAX_URI_LEN] = {0};
1027 struct CmBlob certUri = { sizeof(uriBuf017), uriBuf017 };
1028 ret = CmInstallUserTrustedCert(&userCert[i], &certAlias[i], &certUri);
1029 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
1030 }
1031
1032 for (uint32_t times = 0; times < PERFORMACE_COUNT; ++times) {
1033 struct CertList *certList004 = nullptr;
1034 InitCertList(&certList004);
1035 ret = CmGetUserCertList(CM_USER_TRUSTED_STORE, certList004);
1036 EXPECT_EQ(ret, CM_SUCCESS) << "Normal get user cert list test failed, recode:" << ret;
1037 FreeCertList(certList004);
1038 }
1039
1040 ret = CmUninstallAllUserTrustedCert();
1041 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall All test failed, recode:" << ret;
1042 }
1043
1044 /**
1045 * @tc.name: GetUserCertListTest005
1046 * @tc.desc: Test CertManager Get user cert list interface Abnormal function
1047 * @tc.type: FUNC
1048 * @tc.require: AR000H0MJ8 /SR000H09N7
1049 */
1050 HWTEST_F(CmUserCertTest, GetUserCertListTest005, TestSize.Level0)
1051 {
1052 struct CertList *certList005 = nullptr;
1053 InitCertList(&certList005);
1054 int32_t ret = CmGetUserCertList(CM_USER_TRUSTED_STORE, certList005); /* empty dir */
1055 EXPECT_EQ(ret, CM_SUCCESS) << "Normal get user cert list test failed, recode:" << ret;
1056 FreeCertList(certList005);
1057 }
1058
1059 /**
1060 * @tc.name: GetUserCertInfoTest001
1061 * @tc.desc: Test CertManager Get user cert info interface base function
1062 * @tc.type: FUNC
1063 * @tc.require: AR000H0MJ8 /SR000H09N7
1064 */
1065 HWTEST_F(CmUserCertTest, GetUserCertInfoTest001, TestSize.Level0)
1066 {
1067 int32_t ret;
1068 uint8_t aliasBuf008[] = "40dc992e";
1069 uint8_t uriBuf018[MAX_URI_LEN] = {0};
1070
1071 struct CmBlob testUserCert = { sizeof(g_certData01), const_cast<uint8_t *>(g_certData01) };
1072 struct CmBlob testCertAlias = { sizeof(aliasBuf008), aliasBuf008 };
1073 struct CmBlob testCertUri = { sizeof(uriBuf018), uriBuf018 };
1074
1075 ret = CmInstallUserTrustedCert(&testUserCert, &testCertAlias, &testCertUri);
1076 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
1077
1078 struct CertInfo *certInfo001 = nullptr;
1079 InitUserCertInfo(&certInfo001);
1080 ret = CmGetUserCertInfo(&testCertUri, CM_USER_TRUSTED_STORE, certInfo001);
1081 EXPECT_EQ(ret, CM_SUCCESS) << "Normal get user cert info test failed, recode:" << ret;
1082
1083 EXPECT_EQ(CompareCertInfo(certInfo001, &(g_certInfoExpectResult[0].certInfo)), true) << DumpCertInfo(certInfo001);
1084 EXPECT_EQ(CompareCertData(&(certInfo001->certInfo), &(g_certInfoExpectResult[0].certInfo.certInfo)), true);
1085 FreeCertInfo(certInfo001);
1086
1087 ret = CmUninstallUserTrustedCert(&testCertUri);
1088 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall test failed, recode:" << ret;
1089 }
1090
1091 /**
1092 * @tc.name: GetUserCertInfoTest002
1093 * @tc.desc: Test CertManager Get user cert info interface base function
1094 * @tc.type: FUNC
1095 * @tc.require: AR000H0MJ8 /SR000H09N7
1096 */
1097 HWTEST_F(CmUserCertTest, GetUserCertInfoTest002, TestSize.Level0)
1098 {
1099 int32_t ret;
1100
1101 uint32_t size = sizeof(certAlias) / sizeof(certAlias[0]);
1102 for (uint32_t i = 0; i < size; i++) {
1103 uint8_t uriBuf019[MAX_URI_LEN] = {0};
1104 struct CmBlob certUri = { sizeof(uriBuf019), uriBuf019 };
1105 ret = CmInstallUserTrustedCert(&userCert[i], &certAlias[i], &certUri);
1106 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
1107 }
1108
1109 struct CertList *certList006 = nullptr;
1110 InitCertList(&certList006);
1111 ret = CmGetUserCertList(CM_USER_TRUSTED_STORE, certList006);
1112 EXPECT_EQ(ret, CM_SUCCESS) << "Normal get user cert list test failed, recode:" << ret;
1113
1114 uint32_t certCnt = sizeof(g_certInfoExpectResult) / sizeof(g_certInfoExpectResult[0]);
1115 bool found = false;
1116 for (uint32_t i = 0; i < certCnt; i++) {
1117 struct CertAbstract *ptr = &(g_certListExpectResult[i].certAbstract);
1118 ASSERT_TRUE(ptr != nullptr);
1119 found = FindCertAbstract(ptr, certList006);
1120 EXPECT_EQ(found, g_certListExpectResult[i].bExpectResult);
1121
1122 struct CmBlob uriBlob = { strlen(ptr->uri) + 1, reinterpret_cast<uint8_t *>(ptr->uri) };
1123 struct CertInfo *certInfo002 = nullptr;
1124 InitUserCertInfo(&certInfo002);
1125 ret = CmGetUserCertInfo(&uriBlob, CM_USER_TRUSTED_STORE, certInfo002);
1126 EXPECT_EQ(ret, CM_SUCCESS) << "Normal get user cert info test failed, recode:" << ret;
1127
1128 EXPECT_EQ(CompareCertInfo(certInfo002, &(g_certInfoExpectResult[i].certInfo)), true) <<
1129 DumpCertInfo(certInfo002);
1130 EXPECT_EQ(CompareCertData(&(certInfo002->certInfo), &(g_certInfoExpectResult[i].certInfo.certInfo)), true);
1131 FreeCertInfo(certInfo002);
1132 }
1133 FreeCertList(certList006);
1134
1135 ret = CmUninstallAllUserTrustedCert();
1136 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall All test failed, recode:" << ret;
1137 }
1138
1139 /**
1140 * @tc.name: GetUserCertInfoTest003
1141 * @tc.desc: Test CertManager Get user cert info interface Abnormal function
1142 * @tc.type: FUNC
1143 * @tc.require: AR000H0MJ8 /SR000H09N7
1144 */
1145 HWTEST_F(CmUserCertTest, GetUserCertInfoTest003, TestSize.Level0)
1146 {
1147 int32_t ret;
1148 struct CertInfo *certInfo003 = nullptr;
1149 InitUserCertInfo(&certInfo003);
1150 ret = CmGetUserCertInfo(nullptr, CM_USER_TRUSTED_STORE, certInfo003); /* uri is nullptr */
1151 EXPECT_EQ(ret, CMR_ERROR_NULL_POINTER);
1152 FreeCertInfo(certInfo003);
1153 }
1154
1155 /**
1156 * @tc.name: GetUserCertInfoTest004
1157 * @tc.desc: Test CertManager Get user cert info interface Abnormal function
1158 * @tc.type: FUNC
1159 * @tc.require: AR000H0MJ8 /SR000H09N7
1160 */
1161 HWTEST_F(CmUserCertTest, GetUserCertInfoTest004, TestSize.Level0)
1162 {
1163 int32_t ret;
1164 char *uri = g_certInfoExpectResult[0].certInfo.uri;
1165 struct CmBlob certUri = { strlen(uri) + 1, reinterpret_cast<uint8_t *>(uri) };
1166
1167 struct CertInfo *certInfo004 = nullptr;
1168 InitUserCertInfo(&certInfo004);
1169 ret = CmGetUserCertInfo(&certUri, 100, certInfo004); /* invalid store 100 */
1170 EXPECT_EQ(ret, CM_FAILURE);
1171 FreeCertInfo(certInfo004);
1172 }
1173
1174 /**
1175 * @tc.name: GetUserCertInfoTest005
1176 * @tc.desc: Test CertManager Get user cert info interface Abnormal function
1177 * @tc.type: FUNC
1178 * @tc.require: AR000H0MJ8 /SR000H09N7
1179 */
1180 HWTEST_F(CmUserCertTest, GetUserCertInfoTest005, TestSize.Level0)
1181 {
1182 int32_t ret;
1183 char *uri = g_certInfoExpectResult[1].certInfo.uri;
1184 struct CmBlob certUri = { strlen(uri) + 1, reinterpret_cast<uint8_t *>(uri) };
1185
1186 ret = CmGetUserCertInfo(&certUri, CM_USER_TRUSTED_STORE, nullptr); /* cInfo not malloc */
1187 EXPECT_EQ(ret, CMR_ERROR_NULL_POINTER);
1188 }
1189
1190 /**
1191 * @tc.name: GetUserCertInfoTest006
1192 * @tc.desc: Test CertManager Get user cert info interface performance
1193 * @tc.type: FUNC
1194 * @tc.require: AR000H0MJ8 /SR000H09N7
1195 */
1196 HWTEST_F(CmUserCertTest, GetUserCertInfoTest006, TestSize.Level0)
1197 {
1198 int32_t ret;
1199 uint8_t aliasBuf009[] = "40dc992e";
1200 uint8_t uriBuf020[MAX_URI_LEN] = {0};
1201
1202 struct CmBlob userCertTemp = { sizeof(g_certData01), const_cast<uint8_t *>(g_certData01) };
1203 struct CmBlob certAliasTemp = { sizeof(aliasBuf009), aliasBuf009 };
1204 struct CmBlob certUri = { sizeof(uriBuf020), uriBuf020 };
1205
1206 for (uint32_t time = 0; time < PERFORMACE_COUNT; time++) {
1207 ret = CmInstallUserTrustedCert(&userCertTemp, &certAliasTemp, &certUri);
1208 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
1209
1210 struct CertInfo *certInfo005 = nullptr;
1211 InitUserCertInfo(&certInfo005);
1212 ret = CmGetUserCertInfo(&certUri, CM_USER_TRUSTED_STORE, certInfo005);
1213 EXPECT_EQ(ret, CM_SUCCESS) << "Normal get user cert info test failed, recode:" << ret;
1214
1215 EXPECT_EQ(CompareCertInfo(certInfo005, &(g_certInfoExpectResult[0].certInfo)), true) <<
1216 DumpCertInfo(certInfo005);
1217 EXPECT_EQ(CompareCertData(&(certInfo005->certInfo), &(g_certInfoExpectResult[0].certInfo.certInfo)), true);
1218 FreeCertInfo(certInfo005);
1219
1220 ret = CmUninstallUserTrustedCert(&certUri);
1221 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall test failed, recode:" << ret;
1222 }
1223 }
1224
1225 /**
1226 * @tc.name: SetUserCertStatusTest001
1227 * @tc.desc: Test CertManager Set user cert status interface base function
1228 * @tc.type: FUNC
1229 * @tc.require: AR000H0MJ8 /SR000H09N7
1230 */
1231 HWTEST_F(CmUserCertTest, SetUserCertStatusTest001, TestSize.Level0)
1232 {
1233 int32_t ret;
1234
1235 uint8_t aliasBuf010[] = "1df5a75f";
1236 uint8_t uriBuf021[MAX_URI_LEN] = {0};
1237 struct CmBlob userCertTemp = { sizeof(g_certData03), const_cast<uint8_t *>(g_certData03) };
1238 struct CmBlob certAliasTemp = { sizeof(aliasBuf010), aliasBuf010 };
1239 struct CmBlob certUri = { sizeof(uriBuf021), uriBuf021 };
1240 ret = CmInstallUserTrustedCert(&userCertTemp, &certAliasTemp, &certUri);
1241 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
1242
1243 char *uri = g_certStatusExpectResult[2].uri;
1244 struct CmBlob uriTemp = { strlen(uri) + 1, reinterpret_cast<uint8_t *>(uri) };
1245 ret = CmSetUserCertStatus(&uriTemp, CM_USER_TRUSTED_STORE, g_certStatusExpectResult[2].inparamStatus);
1246 EXPECT_EQ(ret, CM_SUCCESS) << "Normal set user cert status test failed, recode:" << ret;
1247
1248 ret = CmSetUserCertStatus(&uriTemp, CM_USER_TRUSTED_STORE, true);
1249 EXPECT_EQ(ret, CM_SUCCESS) << "Normal set user cert status test failed, recode:" << ret;
1250 ret = CmUninstallUserTrustedCert(&certUri);
1251 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall test failed, recode:" << ret;
1252 }
1253
1254 /**
1255 * @tc.name: SetUserCertStatusTest002
1256 * @tc.desc: Test CertManager set user cert status interface base function
1257 * @tc.type: FUNC
1258 * @tc.require: AR000H0MJ8 /SR000H09N7
1259 */
1260 HWTEST_F(CmUserCertTest, SetUserCertStatusTest002, TestSize.Level0)
1261 {
1262 int32_t ret;
1263
1264 uint32_t size = sizeof(certAlias) / sizeof(certAlias[0]);
1265 for (uint32_t i = 0; i < size; i++) {
1266 uint8_t uriBuf022[MAX_URI_LEN] = {0};
1267 struct CmBlob certUriTemp = { sizeof(uriBuf022), uriBuf022 };
1268 ret = CmInstallUserTrustedCert(&userCert[i], &certAlias[i], &certUriTemp);
1269 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
1270 }
1271
1272 uint32_t len = sizeof(g_certStatusExpectResult) / sizeof(g_certStatusExpectResult[0]);
1273 for (uint32_t i = 0; i < len; i++) {
1274 struct CmBlob certUri = { strlen(g_certStatusExpectResult[i].uri) + 1,
1275 reinterpret_cast<uint8_t *>(g_certStatusExpectResult[i].uri) };
1276
1277 ret = CmSetUserCertStatus(&certUri, CM_USER_TRUSTED_STORE, g_certStatusExpectResult[i].inparamStatus);
1278 EXPECT_EQ(ret, CM_SUCCESS) << "Normal set user cert status test failed, recode:" << ret;
1279
1280 struct CertInfo *certInfo006 = nullptr;
1281 InitUserCertInfo(&certInfo006);
1282 ret = CmGetUserCertInfo(&certUri, CM_USER_TRUSTED_STORE, certInfo006);
1283 EXPECT_EQ(ret, CM_SUCCESS) << "Normal get user cert info test failed, recode:" << ret;
1284
1285 int32_t status = (g_certStatusExpectResult[i].expectStatus == certInfo006->status) ? 1 : 0;
1286 EXPECT_EQ(status, 1) << "set user cert status test failed, cert info: " <<
1287 DumpCertInfo(certInfo006);
1288 FreeCertInfo(certInfo006);
1289
1290 ret = CmSetUserCertStatus(&certUri, CM_USER_TRUSTED_STORE, true);
1291 EXPECT_EQ(ret, CM_SUCCESS) << "Normal set user cert status test failed, recode:" << ret;
1292 }
1293
1294 ret = CmUninstallAllUserTrustedCert();
1295 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall All test failed, recode:" << ret;
1296 }
1297
1298 /**
1299 * @tc.name: SetUserCertStatusTest003
1300 * @tc.desc: Test CertManager Set user cert status interface base function
1301 * @tc.type: FUNC
1302 * @tc.require: AR000H0MJ8 /SR000H09N7
1303 */
1304 HWTEST_F(CmUserCertTest, SetUserCertStatusTest003, TestSize.Level0)
1305 {
1306 int32_t ret;
1307
1308 uint32_t size = sizeof(certAlias) / sizeof(certAlias[0]);
1309 for (uint32_t i = 0; i < size; i++) {
1310 uint8_t uriBuf023[MAX_URI_LEN] = {0};
1311 struct CmBlob certUriTemp = { sizeof(uriBuf023), uriBuf023 };
1312 ret = CmInstallUserTrustedCert(&userCert[i], &certAlias[i], &certUriTemp);
1313 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
1314 }
1315
1316 struct CertList *certList007 = nullptr;
1317 InitCertList(&certList007);
1318 ret = CmGetUserCertList(CM_USER_TRUSTED_STORE, certList007);
1319 EXPECT_EQ(ret, CM_SUCCESS) << "Normal get user cert list test failed, recode:" << ret;
1320
1321 for (uint32_t i = 0; i < certList007->certsCount; ++i) {
1322 struct CertAbstract *ptr = &(certList007->certAbstract[i]);
1323 struct CmBlob uri01 = { strlen(ptr->uri) + 1, reinterpret_cast<uint8_t *>(ptr->uri) };
1324 ret = CmSetUserCertStatus(&uri01, CM_USER_TRUSTED_STORE, false);
1325 EXPECT_EQ(ret, CM_SUCCESS) << "Normal set user cert status test failed, recode:" << ret;
1326 }
1327
1328 for (uint32_t i = 0; i < certList007->certsCount; ++i) {
1329 struct CertAbstract *ptr = &(certList007->certAbstract[i]);
1330 struct CmBlob uri02 = { strlen(ptr->uri) + 1, reinterpret_cast<uint8_t *>(ptr->uri) };
1331 ret = CmSetUserCertStatus(&uri02, CM_USER_TRUSTED_STORE, true);
1332 EXPECT_EQ(ret, CM_SUCCESS) << "Normal set user cert status test failed, recode:" << ret;
1333 }
1334
1335 FreeCertList(certList007);
1336 ret = CmUninstallAllUserTrustedCert();
1337 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall All test failed, recode:" << ret;
1338 }
1339
1340 /**
1341 * @tc.name: SetUserCertStatusTest004
1342 * @tc.desc: Test CertManager set user cert status interface Abnormal function
1343 * @tc.type: FUNC
1344 * @tc.require: AR000H0MJ8 /SR000H09N7
1345 */
1346 HWTEST_F(CmUserCertTest, SetUserCertStatusTest004, TestSize.Level0)
1347 {
1348 int32_t ret;
1349
1350 ret = CmSetUserCertStatus(nullptr, CM_USER_TRUSTED_STORE, true); /* uri is nullptr */
1351 EXPECT_EQ(ret, CMR_ERROR_NULL_POINTER) << "Normal set user cert status test failed, recode:" << ret;
1352 }
1353
1354 /**
1355 * @tc.name: SetUserCertStatusTest005
1356 * @tc.desc: Test CertManager set user cert status interface Abnormal function
1357 * @tc.type: FUNC
1358 * @tc.require: AR000H0MJ8 /SR000H09N7
1359 */
1360 HWTEST_F(CmUserCertTest, SetUserCertStatusTest005, TestSize.Level0)
1361 {
1362 int32_t ret;
1363 struct CmBlob certUri = { strlen(g_certStatusExpectResult[1].uri) + 1,
1364 reinterpret_cast<uint8_t *>(g_certStatusExpectResult[1].uri) };
1365
1366 ret = CmSetUserCertStatus(&certUri, 100, true); /* invalid store */
1367 EXPECT_EQ(ret, CM_FAILURE) << "Normal set user cert status test failed, recode:" << ret;
1368 }
1369
1370 /**
1371 * @tc.name: SetUserCertStatusTest006
1372 * @tc.desc: Test CertManager set user cert status interface Abnormal function
1373 * @tc.type: FUNC
1374 * @tc.require: AR000H0MJ8 /SR000H09N7
1375 */
1376 HWTEST_F(CmUserCertTest, SetUserCertStatusTest006, TestSize.Level0)
1377 {
1378 int32_t ret;
1379 uint8_t invalidUriBuf[] = "invaliduri";
1380 struct CmBlob invalidCertUri = { sizeof(invalidUriBuf), invalidUriBuf };
1381
1382 ret = CmSetUserCertStatus(&invalidCertUri, CM_USER_TRUSTED_STORE, true);
1383 EXPECT_EQ(ret, CMR_ERROR_NOT_FOUND) << "Normal set user cert status test failed, recode:" << ret;
1384 }
1385
1386 /**
1387 * @tc.name: SetUserCertStatusTest007
1388 * @tc.desc: Test CertManager update user cert AND set user cert status interface Abnormal function
1389 * @tc.type: FUNC
1390 * @tc.require: AR000H0MJ8 /SR000H09N7
1391 */
1392 HWTEST_F(CmUserCertTest, SetUserCertStatusTest007, TestSize.Level0)
1393 {
1394 int32_t ret;
1395 uint8_t aliasBuf011[] = "40dc992e";
1396 uint8_t uriBuf024[MAX_URI_LEN] = {0};
1397 struct CmBlob userCertTemp = { sizeof(g_certData01), const_cast<uint8_t *>(g_certData01) };
1398 struct CmBlob certAliasTemp = { sizeof(aliasBuf011), aliasBuf011 };
1399 struct CmBlob certUri = { sizeof(uriBuf024), uriBuf024 };
1400
1401 ret = CmInstallUserTrustedCert(&userCertTemp, &certAliasTemp, &certUri); /* install */
1402 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
1403
1404 ret = CmSetUserCertStatus(&certUri, CM_USER_TRUSTED_STORE, false); /* set status false */
1405 EXPECT_EQ(ret, CM_SUCCESS) << "Normal set user cert status test failed, recode:" << ret;
1406
1407 ret = CmInstallUserTrustedCert(&userCertTemp, &certAliasTemp, &certUri); /* update cert */
1408 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
1409
1410 struct CertInfo *certInfo007 = nullptr;
1411 InitUserCertInfo(&certInfo007);
1412 ret = CmGetUserCertInfo(&certUri, CM_USER_TRUSTED_STORE, certInfo007);
1413 EXPECT_EQ(ret, CM_SUCCESS) << "Normal get user cert info test failed, recode:" << ret;
1414
1415 EXPECT_EQ(true, certInfo007->status);
1416
1417 FreeCertInfo(certInfo007);
1418
1419 ret = CmUninstallAllUserTrustedCert();
1420 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall All test failed, recode:" << ret;
1421 }
1422
1423 /**
1424 * @tc.name: SetUserCertStatusTest008
1425 * @tc.desc: Test CertManager set user cert status interface performance
1426 * @tc.type: FUNC
1427 * @tc.require: AR000H0MJ8 /SR000H09N7
1428 */
1429 HWTEST_F(CmUserCertTest, SetUserCertStatusTest008, TestSize.Level0)
1430 {
1431 int32_t ret;
1432 uint8_t aliasBuf012[] = "1df5a75f";
1433 uint8_t uriBuf025[MAX_URI_LEN] = {0};
1434 struct CmBlob userCert = { sizeof(g_certData03), const_cast<uint8_t *>(g_certData03) };
1435 struct CmBlob certAlias = { sizeof(aliasBuf012), aliasBuf012 };
1436 struct CmBlob certUri = { sizeof(uriBuf025), uriBuf025 };
1437
1438 ret = CmInstallUserTrustedCert(&userCert, &certAlias, &certUri);
1439 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Install test failed, recode:" << ret;
1440
1441 for (uint32_t time = 0; time < PERFORMACE_COUNT; time++) {
1442 ret = CmSetUserCertStatus(&certUri, CM_USER_TRUSTED_STORE, g_certStatusExpectResult[2].inparamStatus);
1443 EXPECT_EQ(ret, CM_SUCCESS) << "Normal set user cert status test failed, recode:" << ret;
1444
1445 ret = CmSetUserCertStatus(&certUri, CM_USER_TRUSTED_STORE, true);
1446 EXPECT_EQ(ret, CM_SUCCESS) << "Normal set user cert status test failed, recode:" << ret;
1447 }
1448
1449 ret = CmUninstallUserTrustedCert(&certUri);
1450 EXPECT_EQ(ret, CM_SUCCESS) << "Normal user cert Uninstall test failed, recode:" << ret;
1451 }
1452 }
1453