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