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