1 /*
2 * Copyright (c) 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
18 #include "cert_manager_api.h"
19 #include "cm_cert_data_ecc.h"
20 #include "cm_cert_data_part1_rsa.h"
21 #include "cm_cert_data_part3_rsa.h"
22 #include "cm_mem.h"
23 #include "cm_test_common.h"
24
25 using namespace testing::ext;
26 using namespace CertmanagerTest;
27 namespace {
28 static uint32_t g_selfTokenId = 0;
29 static MockHapToken* g_MockHap = nullptr;
30 static const struct CmBlob g_appCert = { sizeof(g_rsa2048P12CertInfo), const_cast<uint8_t *>(g_rsa2048P12CertInfo) };
31 static const struct CmBlob g_eccAppCert = { sizeof(g_eccP256P12CertInfo), const_cast<uint8_t *>(g_eccP256P12CertInfo) };
32 static const struct CmBlob g_appCertPwd = { sizeof(g_certPwd), const_cast<uint8_t *>(g_certPwd) };
33
34 static const uint8_t g_abnormalCertData[] = {
35 0x30, 0x82, 0x0b, 0xc1, 0x02, 0x01, 0x03, 0xf7, 0x0d, 0x01, 0x07, 0x06, 0x09, 0x2a, 0x86, 0x48,
36 0x86, 0xf7, 0x0d, 0x01, 0x07, 0x01, 0xa0, 0x82, 0x0b, 0x78, 0x04, 0x82, 0x0b, 0x74, 0x30, 0x82,
37 0x00, 0x3a, 0x69, 0x16, 0xe1, 0x63, 0x0c, 0xe5, 0x92, 0xc2, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x07,
38 0x06, 0xa0, 0x82, 0x06, 0x18, 0x30, 0x82, 0x06, 0x14, 0x02, 0x01, 0x00, 0x30, 0x82, 0x06, 0x0d,
39 0x06, 0x09, 0x0b, 0x74, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x07, 0x01, 0x30, 0x1c, 0x06, 0x0a, 0x2a,
40 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x0c, 0x01
41 };
42
43 struct Credential g_credExpectResult[] = {
44 /* cert num is 2, len is 1961 */
45 { 1, "sk", "Syskey035", "oh:t=sk;o=Syskey035;u=100;a=0", 2, 1, { 1961, nullptr } }
46 };
47
48 class CmSysAppCertTest : public testing::Test {
49 public:
50 static void SetUpTestCase(void);
51
52 static void TearDownTestCase(void);
53
54 void SetUp();
55
56 void TearDown();
57 };
58
SetUpTestCase(void)59 void CmSysAppCertTest::SetUpTestCase(void)
60 {
61 g_selfTokenId = GetSelfTokenID();
62 CmTestCommon::SetTestEnvironment(g_selfTokenId);
63 }
64
TearDownTestCase(void)65 void CmSysAppCertTest::TearDownTestCase(void)
66 {
67 CmTestCommon::ResetTestEnvironment();
68 }
69
SetUp()70 void CmSysAppCertTest::SetUp()
71 {
72 g_MockHap = new (std::nothrow) MockHapToken();
73 }
74
TearDown()75 void CmSysAppCertTest::TearDown()
76 {
77 if (g_MockHap != nullptr) {
78 delete g_MockHap;
79 g_MockHap = nullptr;
80 }
81 }
82
83 /**
84 * @tc.name: SysAppCertTest001
85 * @tc.desc: Test CertManager Install sys app cert interface base function
86 * @tc.type: FUNC
87 */
88 HWTEST_F(CmSysAppCertTest, SysAppCertTest001, TestSize.Level0)
89 {
90 char retUriBuf[MAX_LEN_URI] = {0};
91 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
92
93 uint8_t certAliasBuf[] = "SyskeyA";
94 struct CmBlob certAlias = { sizeof(certAliasBuf), certAliasBuf };
95
96 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_appCert, (struct CmBlob *)&g_appCertPwd,
97 &certAlias, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
98 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
99 EXPECT_EQ(ret, CM_SUCCESS) << "SysAppCertTest001 credentail test failed, retcode:" << ret;
100
101 char uriBuf[] = "oh:t=sk;o=SyskeyA;u=100;a=0";
102 EXPECT_EQ(strcmp(uriBuf, (char *)sysKeyUri.data), 0) << "strcmp failed";
103
104 ret = CmUninstallAppCert(&sysKeyUri, CM_SYS_CREDENTIAL_STORE);
105 EXPECT_EQ(ret, CM_SUCCESS) << "SysAppCertTest001 uninstall failed, retcode:" << ret;
106 }
107
108 /**
109 * @tc.name: SysAppCertTest002
110 * @tc.desc: Test CertManager Install sys app cert interface abnormal function
111 * @tc.type: FUNC
112 */
113 HWTEST_F(CmSysAppCertTest, SysAppCertTest002, TestSize.Level0)
114 {
115 char retUriBuf[MAX_LEN_URI] = {0};
116 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
117
118 uint8_t certAliasBuf[] = "SyskeyA";
119 struct CmBlob certAlias = { sizeof(certAliasBuf), certAliasBuf };
120
121 uint8_t appCertPwdBuf[] = "123456789"; /* err password */
122 struct CmBlob errAppCertPwd = { sizeof(appCertPwdBuf), appCertPwdBuf };
123
124 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_appCert, &errAppCertPwd,
125 &certAlias, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
126 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
127 EXPECT_EQ(ret, CMR_ERROR_PASSWORD_IS_ERR) << "SysAppCertTest002 credentail test failed, retcode:" << ret;
128 }
129
130 /**
131 * @tc.name: SysAppCertTest003
132 * @tc.desc: Test CertManager Install sys app cert interface abnormal function
133 * @tc.type: FUNC
134 */
135 HWTEST_F(CmSysAppCertTest, SysAppCertTest003, TestSize.Level0)
136 {
137 char retUriBuf[MAX_LEN_URI] = {0};
138 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
139
140 uint8_t certAliasBuf[] = "SysAppCertTest003";
141 struct CmBlob certAlias003 = { sizeof(certAliasBuf), certAliasBuf };
142
143 /* sys app cert data is abnormal */
144 struct CmBlob abnormalAppCert = { sizeof(g_abnormalCertData), const_cast<uint8_t *>(g_abnormalCertData) };
145
146 struct CmAppCertParam appCertParam = { &abnormalAppCert, (struct CmBlob *)&g_appCertPwd,
147 &certAlias003, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
148 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
149 EXPECT_EQ(ret, CMR_ERROR_INVALID_CERT_FORMAT) << "SysAppCertTest003 credentail test failed, retcode:" << ret;
150 }
151
152 /**
153 * @tc.name: SysAppCertTest004
154 * @tc.desc: Test CertManager Install sys app cert interface abnormal function
155 * @tc.type: FUNC
156 */
157 HWTEST_F(CmSysAppCertTest, SysAppCertTest004, TestSize.Level0)
158 {
159 char retUriBuf[MAX_LEN_URI] = {0};
160 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
161
162 /* certParam is nullptr */
163 int32_t ret = CmInstallSystemAppCert(nullptr, &sysKeyUri);
164 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest004 credentail test failed, retcode:" << ret;
165 }
166
167 /**
168 * @tc.name: SysAppCertTest005
169 * @tc.desc: Test CertManager Install sys app cert interface abnormal function
170 * @tc.type: FUNC
171 */
172 HWTEST_F(CmSysAppCertTest, SysAppCertTest005, TestSize.Level0)
173 {
174 char retUriBuf[MAX_LEN_URI] = {0};
175 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
176
177 uint8_t certAliasBuf[] = "SysAppCertTest005";
178 struct CmBlob certAlias005 = { sizeof(certAliasBuf), certAliasBuf };
179
180 /* certParam->appCert is nullptr */
181 struct CmAppCertParam appCertParam = { nullptr, (struct CmBlob *)&g_appCertPwd,
182 &certAlias005, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
183 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
184 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest005 credentail test failed, retcode:" << ret;
185 }
186
187 /**
188 * @tc.name: SysAppCertTest006
189 * @tc.desc: Test CertManager Install sys app cert interface abnormal function
190 * @tc.type: FUNC
191 */
192 HWTEST_F(CmSysAppCertTest, SysAppCertTest006, TestSize.Level0)
193 {
194 char retUriBuf[MAX_LEN_URI] = {0};
195 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
196
197 uint8_t certAliasBuf[] = "SysAppCertTest006";
198 struct CmBlob certAlias006 = { sizeof(certAliasBuf), certAliasBuf };
199
200 /* certParam->appCertPwd is nullptr */
201 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_appCert, nullptr,
202 &certAlias006, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
203 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
204 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest006 credentail test failed, retcode:" << ret;
205 }
206
207 /**
208 * @tc.name: SysAppCertTest007
209 * @tc.desc: Test CertManager Install sys app cert interface abnormal function
210 * @tc.type: FUNC
211 */
212 HWTEST_F(CmSysAppCertTest, SysAppCertTest007, TestSize.Level0)
213 {
214 char retUriBuf[MAX_LEN_URI] = {0};
215 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
216
217 /* certParam->certAlias is nullptr */
218 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_appCert, (struct CmBlob *)&g_appCertPwd,
219 nullptr, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
220 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
221 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest007 credentail test failed, retcode:" << ret;
222 }
223
224 /**
225 * @tc.name: SysAppCertTest008
226 * @tc.desc: Test CertManager Install sys app cert interface abnormal function
227 * @tc.type: FUNC
228 */
229 HWTEST_F(CmSysAppCertTest, SysAppCertTest008, TestSize.Level0)
230 {
231 char retUriBuf[MAX_LEN_URI] = {0};
232 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
233
234 uint8_t certAliasBuf[] = "SysAppCertTest008";
235 struct CmBlob certAlias008 = { sizeof(certAliasBuf), certAliasBuf };
236
237 /* certParam->store is not CM_SYS_CREDENTIAL_STORE */
238 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_appCert, (struct CmBlob *)&g_appCertPwd,
239 &certAlias008, CM_CREDENTIAL_STORE, TEST_USERID };
240 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
241 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest008 credentail test failed, retcode:" << ret;
242 }
243
244 /**
245 * @tc.name: SysAppCertTest009
246 * @tc.desc: Test CertManager Install sys app cert interface abnormal function
247 * @tc.type: FUNC
248 */
249 HWTEST_F(CmSysAppCertTest, SysAppCertTest009, TestSize.Level0)
250 {
251 char retUriBuf[MAX_LEN_URI] = {0};
252 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
253
254 uint8_t certAliasBuf[] = "SysAppCertTest009";
255 struct CmBlob certAlias008 = { sizeof(certAliasBuf), certAliasBuf };
256
257 /* certParam->userId is 0 */
258 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_appCert, (struct CmBlob *)&g_appCertPwd,
259 &certAlias008, CM_SYS_CREDENTIAL_STORE, 0 };
260 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
261 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest009 credentail test failed, retcode:" << ret;
262 }
263
264 /**
265 * @tc.name: SysAppCertTest010
266 * @tc.desc: Test CertManager Install sys app cert interface abnormal function
267 * @tc.type: FUNC
268 */
269 HWTEST_F(CmSysAppCertTest, SysAppCertTest010, TestSize.Level0)
270 {
271 char retUriBuf[MAX_LEN_URI] = {0};
272 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
273
274 uint8_t certAliasBuf[] = "SysAppCertTest010";
275 struct CmBlob certAlias008 = { sizeof(certAliasBuf), certAliasBuf };
276
277 /* certParam->userId is INIT_INVALID_VALUE */
278 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_appCert, (struct CmBlob *)&g_appCertPwd,
279 &certAlias008, CM_SYS_CREDENTIAL_STORE, INIT_INVALID_VALUE };
280 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
281 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest010 credentail test failed, retcode:" << ret;
282 }
283
284 /**
285 * @tc.name: SysAppCertTest011
286 * @tc.desc: Test CertManager Install sys app cert interface abnormal function
287 * @tc.type: FUNC
288 */
289 HWTEST_F(CmSysAppCertTest, SysAppCertTest011, TestSize.Level0)
290 {
291 uint8_t certAliasBuf[] = "SysAppCertTest011";
292 struct CmBlob certAlias011 = { sizeof(certAliasBuf), certAliasBuf };
293 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_appCert, (struct CmBlob *)&g_appCertPwd,
294 &certAlias011, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
295
296 /* keyUri is nullptr */
297 int32_t ret = CmInstallSystemAppCert(&appCertParam, nullptr);
298 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest011 credentail test failed, retcode:" << ret;
299 }
300
301 /**
302 * @tc.name: SysAppCertTest012
303 * @tc.desc: Test CertManager Install sys app cert interface abnormal function
304 * @tc.type: FUNC
305 */
306 HWTEST_F(CmSysAppCertTest, SysAppCertTest012, TestSize.Level0)
307 {
308 struct CmBlob sysKeyUri = { 0, nullptr };
309 uint8_t certAliasBuf[] = "SysAppCertTest011";
310 struct CmBlob certAlias012 = { sizeof(certAliasBuf), certAliasBuf };
311 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_appCert, (struct CmBlob *)&g_appCertPwd,
312 &certAlias012, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
313
314 /* keyUri data is nullptr */
315 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
316 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest012 credentail test failed, retcode:" << ret;
317 }
318
319 /**
320 * @tc.name: SysAppCertTest013
321 * @tc.desc: Test CertManager Install sys app cert interface base function
322 * @tc.type: FUNC
323 */
324 HWTEST_F(CmSysAppCertTest, SysAppCertTest013, TestSize.Level0)
325 {
326 char retUriBuf[MAX_LEN_URI] = {0};
327 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
328
329 uint8_t certAliasBuf[] = "SyskeyB";
330 struct CmBlob certAlias013 = { sizeof(certAliasBuf), certAliasBuf };
331
332 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_eccAppCert, (struct CmBlob *)&g_appCertPwd,
333 &certAlias013, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
334 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
335 EXPECT_EQ(ret, CM_SUCCESS) << "SysAppCertTest013 credentail test failed, retcode:" << ret;
336
337 char uriBuf[] = "oh:t=sk;o=SyskeyB;u=100;a=0";
338 EXPECT_EQ(strcmp(uriBuf, (char *)sysKeyUri.data), 0) << "strcmp failed";
339
340 ret = CmUninstallAppCert(&sysKeyUri, CM_SYS_CREDENTIAL_STORE);
341 EXPECT_EQ(ret, CM_SUCCESS) << "SysAppCertTest013 uninstall failed, retcode:" << ret;
342 }
343
344 /**
345 * @tc.name: SysAppCertTest014
346 * @tc.desc: Test CertManager Install sys app cert interface abnormal function
347 * @tc.type: FUNC
348 */
349 HWTEST_F(CmSysAppCertTest, SysAppCertTest014, TestSize.Level0)
350 {
351 char retUriBuf[MAX_LEN_URI] = {0};
352 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
353
354 uint8_t certAliasBuf[] = "SyskeyB";
355 struct CmBlob certAlias014 = { sizeof(certAliasBuf) - 1, certAliasBuf }; /* not include '\0' */
356
357 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_eccAppCert, (struct CmBlob *)&g_appCertPwd,
358 &certAlias014, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
359 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
360 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest014 credentail test failed, retcode:" << ret;
361 }
362
363 /**
364 * @tc.name: SysAppCertTest015
365 * @tc.desc: Test CertManager Install sys app cert interface abnormal function
366 * @tc.type: FUNC
367 */
368 HWTEST_F(CmSysAppCertTest, SysAppCertTest015, TestSize.Level0)
369 {
370 char retUriBuf[MAX_LEN_URI] = {0};
371 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
372 uint8_t certAliasBuf[] = "SyskeyB";
373 struct CmBlob certAlias015 = { sizeof(certAliasBuf), certAliasBuf };
374
375 uint8_t errPwdBuf[] = "123789";
376 struct CmBlob errPwd = { sizeof(errPwdBuf) - 1, errPwdBuf }; /* not include '\0' */
377
378 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_eccAppCert, &errPwd,
379 &certAlias015, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
380 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
381 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest015 credentail test failed, retcode:" << ret;
382 }
383
384 /**
385 * @tc.name: SysAppCertTest016
386 * @tc.desc: Test CertManager Install sys app cert interface abnormal function
387 * @tc.type: FUNC
388 */
389 HWTEST_F(CmSysAppCertTest, SysAppCertTest016, TestSize.Level0)
390 {
391 char retUriBuf[MAX_LEN_URI] = {0};
392 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
393
394 uint8_t certAliasBuf[] = "SyskeyB";
395 struct CmBlob certAlias016 = { sizeof(certAliasBuf), nullptr }; /* certAlias data is nullptr */
396
397 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_eccAppCert, (struct CmBlob *)&g_appCertPwd,
398 &certAlias016, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
399 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
400 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest016 credentail test failed, retcode:" << ret;
401 }
402
403 /**
404 * @tc.name: SysAppCertTest017
405 * @tc.desc: Test CertManager Install sys app cert interface abnormal function
406 * @tc.type: FUNC
407 */
408 HWTEST_F(CmSysAppCertTest, SysAppCertTest017, TestSize.Level0)
409 {
410 char retUriBuf[MAX_LEN_URI] = {0};
411 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
412
413 uint8_t certAliasBuf[] = "SyskeyB";
414 struct CmBlob certAlias017 = { 0, certAliasBuf }; /* certAlias size is 0 */
415
416 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_eccAppCert, (struct CmBlob *)&g_appCertPwd,
417 &certAlias017, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
418 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
419 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest016 credentail test failed, retcode:" << ret;
420 }
421
422 /**
423 * @tc.name: SysAppCertTest018
424 * @tc.desc: Test CertManager Install sys app cert interface abnormal function
425 * @tc.type: FUNC
426 */
427 HWTEST_F(CmSysAppCertTest, SysAppCertTest018, TestSize.Level0)
428 {
429 char retUriBuf[MAX_LEN_URI] = {0};
430 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
431
432 uint8_t certAliasBuf[] = "123456789012345678901234567890123456789012345678901234567890 \
433 12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789";
434 struct CmBlob certAlias018 = { sizeof(certAliasBuf), certAliasBuf }; /* certAlias size beyond max */
435
436 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_eccAppCert, (struct CmBlob *)&g_appCertPwd,
437 &certAlias018, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
438 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
439 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) <<
440 "SysAppCertTest018 credentail test failed, retcode:" << ret;
441 }
442
443 /**
444 * @tc.name: SysAppCertTest019
445 * @tc.desc: Test CertManager Install sys app cert interface abnormal function
446 * @tc.type: FUNC
447 */
448 HWTEST_F(CmSysAppCertTest, SysAppCertTest019, TestSize.Level0)
449 {
450 char retUriBuf[MAX_LEN_URI] = {0};
451 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
452 uint8_t certAliasBuf[] = "SyskeyB";
453 struct CmBlob certAlias019 = { sizeof(certAliasBuf), certAliasBuf };
454
455 struct CmBlob appCert = { sizeof(g_rsa2048P12CertInfo), nullptr }; /* appCert data is nullptr */
456
457 struct CmAppCertParam appCertParam = { &appCert, (struct CmBlob *)&g_appCertPwd,
458 &certAlias019, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
459 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
460 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest019 credentail test failed, retcode:" << ret;
461 }
462
463 /**
464 * @tc.name: SysAppCertTest020
465 * @tc.desc: Test CertManager Install sys app cert interface abnormal function
466 * @tc.type: FUNC
467 */
468 HWTEST_F(CmSysAppCertTest, SysAppCertTest020, TestSize.Level0)
469 {
470 char retUriBuf[MAX_LEN_URI] = {0};
471 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
472 uint8_t certAliasBuf[] = "SyskeyB";
473 struct CmBlob certAlias020 = { sizeof(certAliasBuf), certAliasBuf };
474
475 struct CmBlob appCert = { 0, const_cast<uint8_t *>(g_rsa2048P12CertInfo) }; /* appCert size is 0 */
476
477 struct CmAppCertParam appCertParam = { &appCert, (struct CmBlob *)&g_appCertPwd,
478 &certAlias020, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
479 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
480 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest020 credentail test failed, retcode:" << ret;
481 }
482
483 /**
484 * @tc.name: SysAppCertTest021
485 * @tc.desc: Test CertManager Install sys app cert interface abnormal function
486 * @tc.type: FUNC
487 */
488 HWTEST_F(CmSysAppCertTest, SysAppCertTest021, TestSize.Level0)
489 {
490 char retUriBuf[MAX_LEN_URI] = {0};
491 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
492 uint8_t certAliasBuf[] = "SyskeyB";
493 struct CmBlob certAlias021 = { sizeof(certAliasBuf), certAliasBuf };
494
495 /* appCert size beyond max */
496 uint8_t appCertData[MAX_LEN_APP_CERT + 1] = { 0 };
497 struct CmBlob appCert = { MAX_LEN_APP_CERT + 1, appCertData };
498
499 struct CmAppCertParam appCertParam = { &appCert, (struct CmBlob *)&g_appCertPwd,
500 &certAlias021, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
501 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
502 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest021 credentail test failed, retcode:" << ret;
503 }
504
505 /**
506 * @tc.name: SysAppCertTest022
507 * @tc.desc: Test CertManager Install sys app cert interface abnormal function
508 * @tc.type: FUNC
509 */
510 HWTEST_F(CmSysAppCertTest, SysAppCertTest022, TestSize.Level0)
511 {
512 char retUriBuf[MAX_LEN_URI] = {0};
513 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
514 uint8_t certAliasBuf[] = "SyskeyB";
515 struct CmBlob certAlias022 = { sizeof(certAliasBuf), certAliasBuf };
516
517 uint8_t pwdBuf[] = "123789";
518 struct CmBlob appCertPwd = { sizeof(pwdBuf), nullptr }; /* appCertPwd data is nullptr */
519
520 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_eccAppCert, &appCertPwd,
521 &certAlias022, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
522 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
523 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest022 credentail test failed, retcode:" << ret;
524 }
525
526 /**
527 * @tc.name: SysAppCertTest023
528 * @tc.desc: Test CertManager Install sys app cert interface abnormal function
529 * @tc.type: FUNC
530 */
531 HWTEST_F(CmSysAppCertTest, SysAppCertTest023, TestSize.Level0)
532 {
533 char retUriBuf[MAX_LEN_URI] = {0};
534 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
535 uint8_t certAliasBuf[] = "SyskeyB";
536 struct CmBlob certAlias023 = { sizeof(certAliasBuf), certAliasBuf };
537
538 uint8_t pwdBuf[] = "123789";
539 struct CmBlob appCertPwd = { 0, pwdBuf }; /* appCertPwd size is 0 */
540
541 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_eccAppCert, &appCertPwd,
542 &certAlias023, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
543 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
544 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest023 credentail test failed, retcode:" << ret;
545 }
546
547 /**
548 * @tc.name: SysAppCertTest024
549 * @tc.desc: Test CertManager Install sys app cert interface abnormal function
550 * @tc.type: FUNC
551 */
552 HWTEST_F(CmSysAppCertTest, SysAppCertTest024, TestSize.Level0)
553 {
554 char retUriBuf[MAX_LEN_URI] = {0};
555 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
556 uint8_t certAliasBuf[] = "SyskeyB";
557 struct CmBlob certAlias024 = { sizeof(certAliasBuf), certAliasBuf };
558
559 uint8_t pwdBuf[] = "123456789012345678901234567890123456";
560 struct CmBlob appCertPwd = { sizeof(pwdBuf), pwdBuf }; /* appCertPwd size beyond max */
561
562 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_eccAppCert, &appCertPwd,
563 &certAlias024, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
564 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
565 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest024 credentail test failed, retcode:" << ret;
566 }
567
568 /**
569 * @tc.name: SysAppCertTest025
570 * @tc.desc: Test CertManager Uninstall sys app cert interface abnormal function
571 * @tc.type: FUNC
572 */
573 HWTEST_F(CmSysAppCertTest, SysAppCertTest025, TestSize.Level0)
574 {
575 int32_t ret = CmUninstallAppCert(nullptr, CM_SYS_CREDENTIAL_STORE); /* keyUri is nullptr */
576 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest025 uninstall failed, retcode:" << ret;
577 }
578
579 /**
580 * @tc.name: SysAppCertTest026
581 * @tc.desc: Test CertManager Uninstall sys app cert interface abnormal function
582 * @tc.type: FUNC
583 */
584 HWTEST_F(CmSysAppCertTest, SysAppCertTest026, TestSize.Level0)
585 {
586 char retUriBuf[MAX_LEN_URI] = {0};
587 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
588
589 int32_t ret = CmUninstallAppCert(&sysKeyUri, CM_SYS_CREDENTIAL_STORE + 1); /* store is invalid */
590 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest026 uninstall failed, retcode:" << ret;
591 }
592
593 /**
594 * @tc.name: SysAppCertTest027
595 * @tc.desc: Test CertManager Uninstall sys app cert interface abnormal function
596 * @tc.type: FUNC
597 */
598 HWTEST_F(CmSysAppCertTest, SysAppCertTest027, TestSize.Level0)
599 {
600 char retUriBuf[MAX_LEN_URI] = {0};
601 struct CmBlob sysKeyUri = { sizeof(retUriBuf), nullptr };
602
603 int32_t ret = CmUninstallAppCert(&sysKeyUri, CM_SYS_CREDENTIAL_STORE); /* keyUri data is nullptr */
604 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest027 uninstall failed, retcode:" << ret;
605 }
606
607 /**
608 * @tc.name: SysAppCertTest028
609 * @tc.desc: Test CertManager Uninstall sys app cert interface abnormal function
610 * @tc.type: FUNC
611 */
612 HWTEST_F(CmSysAppCertTest, SysAppCertTest028, TestSize.Level0)
613 {
614 char retUriBuf[MAX_LEN_URI] = {0};
615 struct CmBlob sysKeyUri = { 0, reinterpret_cast<uint8_t *>(retUriBuf) };
616
617 int32_t ret = CmUninstallAppCert(&sysKeyUri, CM_SYS_CREDENTIAL_STORE); /* keyUri size is 0 */
618 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest028 uninstall failed, retcode:" << ret;
619 }
620
621 /**
622 * @tc.name: SysAppCertTest029
623 * @tc.desc: Test CertManager Uninstall sys app cert interface abnormal function
624 * @tc.type: FUNC
625 */
626 HWTEST_F(CmSysAppCertTest, SysAppCertTest029, TestSize.Level0)
627 {
628 char retUriBuf[MAX_LEN_URI] = {0};
629 struct CmBlob sysKeyUri = { sizeof(retUriBuf) - 1, reinterpret_cast<uint8_t *>(retUriBuf) };
630
631 int32_t ret = CmUninstallAppCert(&sysKeyUri, CM_SYS_CREDENTIAL_STORE); /* not include '\0' */
632 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest029 uninstall failed, retcode:" << ret;
633 }
634
635 /**
636 * @tc.name: SysAppCertTest030
637 * @tc.desc: Test CertManager Uninstall sys app cert interface abnormal function
638 * @tc.type: FUNC
639 */
640 HWTEST_F(CmSysAppCertTest, SysAppCertTest030, TestSize.Level0)
641 {
642 char retUriBuf[MAX_LEN_URI] = {0};
643 struct CmBlob sysKeyUri = { sizeof(retUriBuf) + 1, reinterpret_cast<uint8_t *>(retUriBuf) };
644
645 int32_t ret = CmUninstallAppCert(&sysKeyUri, CM_SYS_CREDENTIAL_STORE); /* keyUri size beyond max */
646 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest030 uninstall failed, retcode:" << ret;
647 }
648
649 /**
650 * @tc.name: SysAppCertTest031
651 * @tc.desc: Test CertManager Uninstall sys app cert interface abnormal function
652 * @tc.type: FUNC
653 */
654 HWTEST_F(CmSysAppCertTest, SysAppCertTest031, TestSize.Level0)
655 {
656 char retUriBuf[MAX_LEN_URI] = {0};
657 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
658
659 uint8_t certAliasBuf[] = "SyskeyA";
660 struct CmBlob certAlias031 = { sizeof(certAliasBuf), certAliasBuf };
661
662 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_appCert, (struct CmBlob *)&g_appCertPwd,
663 &certAlias031, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
664 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
665 EXPECT_EQ(ret, CM_SUCCESS) << "SysAppCertTest031 credentail test failed, retcode:" << ret;
666
667 char uriBuf[] = "oh:t=sk;o=SyskeyA;u=100;a=0";
668 EXPECT_EQ(strcmp(uriBuf, (char *)sysKeyUri.data), 0) << "strcmp failed";
669
670 char errUriBuf01[] = "oh:t=ak;o=SyskeyA;u=100;a=0"; /* type is not CM_URI_TYPE_SYS_KEY */
671 struct CmBlob errKeyUri01 = { sizeof(errUriBuf01), reinterpret_cast<uint8_t *>(errUriBuf01) };
672 ret = CmUninstallAppCert(&errKeyUri01, CM_SYS_CREDENTIAL_STORE);
673 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest031 uninstall failed, retcode:" << ret;
674
675 char errUriBuf02[] = "oh:t=sk;o=SyskeyA;u=100;a=2"; /* uid is not equal to 0 */
676 struct CmBlob errKeyUri02 = { sizeof(errUriBuf02), reinterpret_cast<uint8_t *>(errUriBuf02) };
677 ret = CmUninstallAppCert(&errKeyUri02, CM_SYS_CREDENTIAL_STORE);
678 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest031 uninstall failed, retcode:" << ret;
679
680 ret = CmUninstallAppCert(&sysKeyUri, CM_SYS_CREDENTIAL_STORE);
681 EXPECT_EQ(ret, CM_SUCCESS) << "SysAppCertTest031 uninstall failed, retcode:" << ret;
682 }
683
684 /**
685 * @tc.name: SysAppCertTest032
686 * @tc.desc: Test CertManager uninstall all sys app cert list interface base function
687 * @tc.type: FUNC
688 */
689 HWTEST_F(CmSysAppCertTest, SysAppCertTest032, TestSize.Level0)
690 {
691 char retUriBuf01[MAX_LEN_URI] = {0};
692 struct CmBlob sysKeyUri01 = { sizeof(retUriBuf01), reinterpret_cast<uint8_t *>(retUriBuf01) };
693
694 uint8_t certAliasBuf01[] = "SyskeyA01";
695 struct CmBlob alias01 = { sizeof(certAliasBuf01), certAliasBuf01 };
696
697 struct CmAppCertParam appCertParam01 = { (struct CmBlob *)&g_appCert, (struct CmBlob *)&g_appCertPwd,
698 &alias01, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
699 int32_t ret = CmInstallSystemAppCert(&appCertParam01, &sysKeyUri01);
700 EXPECT_EQ(ret, CM_SUCCESS) << "SysAppCertTest032 credentail test failed, retcode:" << ret;
701 ret = CmUninstallAppCert(&sysKeyUri01, CM_SYS_CREDENTIAL_STORE);
702 EXPECT_EQ(ret, CM_SUCCESS) << "SysAppCertTest032 uninstall failed, retcode:" << ret;
703
704 char retUriBuf02[MAX_LEN_URI] = {0};
705 struct CmBlob sysKeyUri02 = { sizeof(retUriBuf02), reinterpret_cast<uint8_t *>(retUriBuf02) };
706 uint8_t certAliasBuf02[] = "SyskeyA02";
707 struct CmBlob alias02 = { sizeof(certAliasBuf02), certAliasBuf02 };
708
709 struct CmAppCertParam appCertParam02 = { (struct CmBlob *)&g_appCert, (struct CmBlob *)&g_appCertPwd,
710 &alias02, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
711 ret = CmInstallSystemAppCert(&appCertParam02, &sysKeyUri02);
712 EXPECT_EQ(ret, CM_SUCCESS) << "SysAppCertTest032 credentail test failed, retcode:" << ret;
713 ret = CmUninstallAppCert(&sysKeyUri02, CM_SYS_CREDENTIAL_STORE);
714 EXPECT_EQ(ret, CM_SUCCESS) << "SysAppCertTest032 uninstall failed, retcode:" << ret;
715
716 ret = CmUninstallAllAppCert();
717 EXPECT_EQ(ret, CM_SUCCESS) << "SysAppCertTest032 uninstall failed, retcode:" << ret;
718 }
719
720 /**
721 * @tc.name: SysAppCertTest033
722 * @tc.desc: Test CertManager get sys app cert list interface abnormal function
723 * @tc.type: FUNC
724 */
725 HWTEST_F(CmSysAppCertTest, SysAppCertTest033, TestSize.Level0)
726 {
727 struct CredentialList certificateList = { 0, nullptr };
728 uint32_t buffSize = MAX_COUNT_CERTIFICATE * sizeof(struct CredentialAbstract);
729 certificateList.credentialAbstract = static_cast<struct CredentialAbstract *>(CmMalloc(buffSize));
730 ASSERT_TRUE(certificateList.credentialAbstract != nullptr);
731 certificateList.credentialCount = MAX_COUNT_CERTIFICATE;
732 (void)memset_s(certificateList.credentialAbstract, buffSize, 0, buffSize);
733
734 int32_t ret = CmGetAppCertList(CM_SYS_CREDENTIAL_STORE + 1, &certificateList); /* store is invalid */
735 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest033 get cert list test failed, retcode:" << ret;
736 }
737
738 /**
739 * @tc.name: SysAppCertTest034
740 * @tc.desc: Test CertManager get sys app cert list interface abnormal function
741 * @tc.type: FUNC
742 */
743 HWTEST_F(CmSysAppCertTest, SysAppCertTest034, TestSize.Level0)
744 {
745 int32_t ret = CmGetAppCertList(CM_SYS_CREDENTIAL_STORE, nullptr); /* certificateList is nullptr */
746 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest034 get cert list test failed, retcode:" << ret;
747 }
748
749 /**
750 * @tc.name: SysAppCertTest035
751 * @tc.desc: Test CertManager get sys app cert interface base function
752 * @tc.type: FUNC
753 */
754 HWTEST_F(CmSysAppCertTest, SysAppCertTest035, TestSize.Level0)
755 {
756 char retUriBuf[MAX_LEN_URI] = {0};
757 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
758
759 uint8_t certAliasBuf[] = "Syskey035";
760 struct CmBlob certAlias035 = { sizeof(certAliasBuf), certAliasBuf };
761
762 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_appCert, (struct CmBlob *)&g_appCertPwd,
763 &certAlias035, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
764 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
765 EXPECT_EQ(ret, CM_SUCCESS) << "SysAppCertTest035 credentail test failed, retcode:" << ret;
766
767 char uriBuf[] = "oh:t=sk;o=Syskey035;u=100;a=0";
768 EXPECT_EQ(strcmp(uriBuf, (char *)sysKeyUri.data), 0) << "strcmp failed";
769
770 struct Credential credInfo;
771 (void)memset_s(&credInfo, sizeof(Credential), 0, sizeof(Credential));
772 credInfo.credData.data = static_cast<uint8_t *>(CmMalloc(MAX_LEN_CERTIFICATE_CHAIN));
773 ASSERT_TRUE(credInfo.credData.data != nullptr);
774 credInfo.credData.size = MAX_LEN_CERTIFICATE_CHAIN;
775
776 ret = CmGetAppCert(&sysKeyUri, CM_SYS_CREDENTIAL_STORE, &credInfo);
777 EXPECT_EQ(ret, CM_SUCCESS) << "SysAppCertTest035 get app cert failed, retcode:" << ret;
778 EXPECT_EQ(CompareCredential(&credInfo, &(g_credExpectResult[0])), true);
779 FreeCMBlobData(&credInfo.credData);
780
781 ret = CmUninstallAppCert(&sysKeyUri, CM_SYS_CREDENTIAL_STORE);
782 EXPECT_EQ(ret, CM_SUCCESS) << "SysAppCertTest035 uninstall failed, retcode:" << ret;
783 }
784
785
786 /**
787 * @tc.name: SysAppCertTest036
788 * @tc.desc: Test CertManager get sys app cert interface base function
789 * @tc.type: FUNC
790 */
791 HWTEST_F(CmSysAppCertTest, SysAppCertTest036, TestSize.Level0)
792 {
793 struct Credential credInfo036;
794 (void)memset_s(&credInfo036, sizeof(Credential), 0, sizeof(Credential));
795 credInfo036.credData.data = static_cast<uint8_t *>(CmMalloc(MAX_LEN_CERTIFICATE_CHAIN));
796 ASSERT_TRUE(credInfo036.credData.data != nullptr);
797 credInfo036.credData.size = MAX_LEN_CERTIFICATE_CHAIN;
798
799 int32_t ret = CmGetAppCert(nullptr, CM_SYS_CREDENTIAL_STORE, &credInfo036); /* keyUri is nullptr */
800 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest036 get app cert failed, retcode:" << ret;
801 FreeCMBlobData(&credInfo036.credData);
802 }
803
804 /**
805 * @tc.name: SysAppCertTest037
806 * @tc.desc: Test CertManager get sys app cert interface base function
807 * @tc.type: FUNC
808 */
809 HWTEST_F(CmSysAppCertTest, SysAppCertTest037, TestSize.Level0)
810 {
811 char retUriBuf[MAX_LEN_URI] = {0};
812 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
813
814 int32_t ret = CmGetAppCert(&sysKeyUri, CM_SYS_CREDENTIAL_STORE, nullptr); /* certificate is nullptr */
815 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest037 get app cert failed, retcode:" << ret;
816 }
817
818 /**
819 * @tc.name: SysAppCertTest038
820 * @tc.desc: Test CertManager get sys app cert interface base function
821 * @tc.type: FUNC
822 */
823 HWTEST_F(CmSysAppCertTest, SysAppCertTest038, TestSize.Level0)
824 {
825 char retUriBuf[MAX_LEN_URI] = {0};
826 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
827
828 struct Credential credInfo038;
829 (void)memset_s(&credInfo038, sizeof(Credential), 0, sizeof(Credential));
830 credInfo038.credData.data = static_cast<uint8_t *>(CmMalloc(MAX_LEN_CERTIFICATE_CHAIN));
831 ASSERT_TRUE(credInfo038.credData.data != nullptr);
832 credInfo038.credData.size = MAX_LEN_CERTIFICATE_CHAIN;
833
834 int32_t ret = CmGetAppCert(&sysKeyUri, CM_SYS_CREDENTIAL_STORE + 1, &credInfo038); /* store is invalid */
835 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest038 get app cert failed, retcode:" << ret;
836 FreeCMBlobData(&credInfo038.credData);
837 }
838
839 /**
840 * @tc.name: SysAppCertTest039
841 * @tc.desc: Test CertManager get sys app cert interface base function
842 * @tc.type: FUNC
843 */
844 HWTEST_F(CmSysAppCertTest, SysAppCertTest039, TestSize.Level0)
845 {
846 char retUriBuf[MAX_LEN_URI] = {0};
847 struct CmBlob sysKeyUri = { sizeof(retUriBuf), nullptr };
848
849 struct Credential credInfo039;
850 (void)memset_s(&credInfo039, sizeof(Credential), 0, sizeof(Credential));
851 credInfo039.credData.data = static_cast<uint8_t *>(CmMalloc(MAX_LEN_CERTIFICATE_CHAIN));
852 ASSERT_TRUE(credInfo039.credData.data != nullptr);
853 credInfo039.credData.size = MAX_LEN_CERTIFICATE_CHAIN;
854
855 int32_t ret = CmGetAppCert(&sysKeyUri, CM_SYS_CREDENTIAL_STORE, &credInfo039); /* keyUri data is nullptr */
856 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest039 get app cert failed, retcode:" << ret;
857 FreeCMBlobData(&credInfo039.credData);
858 }
859
860 /**
861 * @tc.name: SysAppCertTest040
862 * @tc.desc: Test CertManager get sys app cert interface base function
863 * @tc.type: FUNC
864 */
865 HWTEST_F(CmSysAppCertTest, SysAppCertTest040, TestSize.Level0)
866 {
867 char retUriBuf[MAX_LEN_URI] = {0};
868 struct CmBlob sysKeyUri = { 0, reinterpret_cast<uint8_t *>(retUriBuf) };
869
870 struct Credential credInfo040;
871 (void)memset_s(&credInfo040, sizeof(Credential), 0, sizeof(Credential));
872 credInfo040.credData.data = static_cast<uint8_t *>(CmMalloc(MAX_LEN_CERTIFICATE_CHAIN));
873 ASSERT_TRUE(credInfo040.credData.data != nullptr);
874 credInfo040.credData.size = MAX_LEN_CERTIFICATE_CHAIN;
875
876 int32_t ret = CmGetAppCert(&sysKeyUri, CM_SYS_CREDENTIAL_STORE, &credInfo040); /* keyUri size is 0 */
877 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest040 get app cert failed, retcode:" << ret;
878 FreeCMBlobData(&credInfo040.credData);
879 }
880
881 /**
882 * @tc.name: SysAppCertTest041
883 * @tc.desc: Test CertManager get sys app cert interface base function
884 * @tc.type: FUNC
885 */
886 HWTEST_F(CmSysAppCertTest, SysAppCertTest041, TestSize.Level0)
887 {
888 char retUriBuf[MAX_LEN_URI] = {0};
889 struct CmBlob sysKeyUri = { sizeof(retUriBuf) + 1, reinterpret_cast<uint8_t *>(retUriBuf) };
890
891 struct Credential credInfo041;
892 (void)memset_s(&credInfo041, sizeof(Credential), 0, sizeof(Credential));
893 credInfo041.credData.data = static_cast<uint8_t *>(CmMalloc(MAX_LEN_CERTIFICATE_CHAIN));
894 ASSERT_TRUE(credInfo041.credData.data != nullptr);
895 credInfo041.credData.size = MAX_LEN_CERTIFICATE_CHAIN;
896
897 int32_t ret = CmGetAppCert(&sysKeyUri, CM_SYS_CREDENTIAL_STORE, &credInfo041); /* keyUri size beyond max*/
898 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest041 get app cert failed, retcode:" << ret;
899 FreeCMBlobData(&credInfo041.credData);
900 }
901
902 /**
903 * @tc.name: SysAppCertTest042
904 * @tc.desc: Test CertManager get sys app cert interface base function
905 * @tc.type: FUNC
906 */
907 HWTEST_F(CmSysAppCertTest, SysAppCertTest042, TestSize.Level0)
908 {
909 char retUriBuf[MAX_LEN_URI] = {0};
910 struct CmBlob sysKeyUri = { sizeof(retUriBuf) - 1, reinterpret_cast<uint8_t *>(retUriBuf) };
911
912 struct Credential credInfo042;
913 (void)memset_s(&credInfo042, sizeof(Credential), 0, sizeof(Credential));
914 credInfo042.credData.data = static_cast<uint8_t *>(CmMalloc(MAX_LEN_CERTIFICATE_CHAIN));
915 ASSERT_TRUE(credInfo042.credData.data != nullptr);
916 credInfo042.credData.size = MAX_LEN_CERTIFICATE_CHAIN;
917
918 int32_t ret = CmGetAppCert(&sysKeyUri, CM_SYS_CREDENTIAL_STORE, &credInfo042); /* not include '\0'*/
919 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest042 get app cert failed, retcode:" << ret;
920 FreeCMBlobData(&credInfo042.credData);
921 }
922
923 /**
924 * @tc.name: SysAppCertTest043
925 * @tc.desc: Test CertManager Uninstall sys app cert interface abnormal function
926 * @tc.type: FUNC
927 */
928 HWTEST_F(CmSysAppCertTest, SysAppCertTest043, TestSize.Level0)
929 {
930 char retUriBuf[MAX_LEN_URI] = {0};
931 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
932
933 uint8_t certAliasBuf[] = "Syskey043";
934 struct CmBlob certAlias043 = { sizeof(certAliasBuf), certAliasBuf };
935
936 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_appCert, (struct CmBlob *)&g_appCertPwd,
937 &certAlias043, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
938 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
939 EXPECT_EQ(ret, CM_SUCCESS) << "SysAppCertTest043 credentail test failed, retcode:" << ret;
940
941 char uriBuf[] = "oh:t=sk;o=Syskey043;u=100;a=0";
942 EXPECT_EQ(strcmp(uriBuf, (char *)sysKeyUri.data), 0) << "strcmp failed";
943
944 struct Credential credInfo043;
945 (void)memset_s(&credInfo043, sizeof(Credential), 0, sizeof(Credential));
946 credInfo043.credData.data = static_cast<uint8_t *>(CmMalloc(MAX_LEN_CERTIFICATE_CHAIN));
947 ASSERT_TRUE(credInfo043.credData.data != nullptr);
948 credInfo043.credData.size = MAX_LEN_CERTIFICATE_CHAIN;
949
950 char errUriBuf01[] = "oh:t=ak;o=Syskey043;u=100;a=0"; /* type is not CM_URI_TYPE_SYS_KEY */
951 struct CmBlob errKeyUri01 = { sizeof(errUriBuf01), reinterpret_cast<uint8_t *>(errUriBuf01) };
952 ret = CmGetAppCert(&errKeyUri01, CM_SYS_CREDENTIAL_STORE, &credInfo043);
953 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest043 get app cert failed, retcode:" << ret;
954
955 char errUriBuf02[] = "oh:t=ak;o=;u=100;a=0"; /* object is nullptr */
956 struct CmBlob errKeyUri02 = { sizeof(errUriBuf02), reinterpret_cast<uint8_t *>(errUriBuf02) };
957 ret = CmGetAppCert(&errKeyUri02, CM_SYS_CREDENTIAL_STORE, &credInfo043);
958 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT) << "SysAppCertTest043 get app cert failed, retcode:" << ret;
959
960 FreeCMBlobData(&credInfo043.credData);
961 ret = CmUninstallAppCert(&sysKeyUri, CM_SYS_CREDENTIAL_STORE);
962 EXPECT_EQ(ret, CM_SUCCESS) << "SysAppCertTest043 uninstall failed, retcode:" << ret;
963 }
964
965 /**
966 * @tc.name: SysAppCertTest044
967 * @tc.desc: install system sm2, oid is valid
968 * @tc.type: FUNC
969 */
970 HWTEST_F(CmSysAppCertTest, SysAppCertTest044, TestSize.Level0)
971 {
972 char retUriBuf[MAX_LEN_URI] = {0};
973 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
974
975 uint8_t certAliasBuf[] = "SyskeySM2043";
976 struct CmBlob certAlias = { sizeof(certAliasBuf), certAliasBuf };
977
978 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_sm2AppCert, (struct CmBlob *)&g_appSM2CertPwd,
979 &certAlias, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
980 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
981 EXPECT_EQ(ret, CM_SUCCESS) << "SysAppCertTest001 credentail test failed, retcode:" << ret;
982
983 char uriBuf[] = "oh:t=sk;o=SyskeySM2043;u=100;a=0";
984 EXPECT_EQ(strcmp(uriBuf, (char *)sysKeyUri.data), 0) << "strcmp failed";
985
986 ret = CmUninstallAppCert(&sysKeyUri, CM_SYS_CREDENTIAL_STORE);
987 EXPECT_EQ(ret, CM_SUCCESS) << "SysAppCertTest001 uninstall failed, retcode:" << ret;
988 }
989
990 /**
991 * @tc.name: SysAppCertTest045
992 * @tc.desc: install system sm2, oid is invalid
993 * @tc.type: FUNC
994 */
995 HWTEST_F(CmSysAppCertTest, SysAppCertTest045, TestSize.Level0)
996 {
997 char retUriBuf[MAX_LEN_URI] = {0};
998 struct CmBlob sysKeyUri = { sizeof(retUriBuf), reinterpret_cast<uint8_t *>(retUriBuf) };
999
1000 uint8_t certAliasBuf[] = "SyskeySM2044";
1001 struct CmBlob certAlias = { sizeof(certAliasBuf), certAliasBuf };
1002
1003 struct CmAppCertParam appCertParam = { (struct CmBlob *)&g_sm2AppCert3, (struct CmBlob *)&g_appSM2CertPwd,
1004 &certAlias, CM_SYS_CREDENTIAL_STORE, TEST_USERID };
1005 int32_t ret = CmInstallSystemAppCert(&appCertParam, &sysKeyUri);
1006 EXPECT_EQ(ret, CMR_ERROR_INVALID_CERT_FORMAT) << "SysAppCertTest001 credentail test failed, retcode:" << ret;
1007 }
1008 }
1009