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